Capgo Live Updates

Capgo Live Updates

By Martin DonadieuTechnology
Download on the App Store

Capgo Live Updates episodes

  • Capgo Cloud Default Channel Not Updating Devices
    Capgo’s OTA update system follows a strict channel hierarchy that can leave devices stuck on an old version even after you change the cloud default channel. The SDK checks for a forced channel, a device‑specific override, a locally set channel, the native config file, and finally the cloud default, meaning any higher‑priority setting will block the cloud change. Developers often encounter this when a test device has a lingering local channel value, which isn’t visible in the dashboard and must be cleared by code or by reinstalling the app.
    Other common pitfalls include mismatched native plugins, unsynced Capacitor assets, and exact channel‑name typos that prevent updates from being applied. The article advises running npx capsync to copy web assets into the native project, using the SDK’s getChannel method for real‑time verification, and performing a post‑deploy smoke test on a dedicated canary device. Understanding these mechanics helps avoid endless refresh loops and ensures reliable, painless OTA releases.
    Topics:
    - Channel hierarchy and why cloud default is lowest priority
    - Clearing local channel overrides by reinstalling or code
    - Running npx capsync to sync native and web assets
    - Verifying channel routing with getChannel logs
    - Post‑deploy smoke test on a canary device
    Full article
    https://capgo.app/blog/capgo-cloud-default-channel-not-updating-devices/
    19 min
  • Capgo Auto Pause Minimum Attempts
    Capgo’s auto‑pause minimum attempts setting acts as a statistical gatekeeper for OTA updates in Capacitor.js apps. The episode explains why the setting counts raw download attempts—not unique users—to avoid false alarms caused by network retries, multiple devices, or intermittent connectivity. Listeners learn how to calibrate the threshold using a small test channel, record baseline attempt noise, and then apply a tailored value for production rollouts, ensuring a statistically significant sample before the system can pause a rollout.
    The discussion also covers the practical steps to change the setting safely: log the current channel state, update via the dashboard, CLI, or API, and then verify three key outcomes—correct threshold, correct bundle reference, and correct rollout status. It stresses automated CI/CD integration, secret management, and simulated failure testing to confirm the auto‑pause works before any real release.
    Topics:
    - Calibrating the minimum‑attempt threshold with real‑world attempt data
    - Verifying channel configuration after changes to avoid silent failures
    - Using CI/CD pipelines to automate threshold updates and state checks
    - Testing the auto‑pause mechanism with controlled failure bundles
    Full article
    https://capgo.app/blog/capgo-auto-pause-minimum-attempts/
    24 min
  • Capacitor Wsl2 Windows Setup
    Capacitor development on Windows works best when the web toolchain stays inside WSL2 and the Android tooling stays on the Windows side. The episode explains why Linux file paths, husky hooks and Makefiles break in PowerShell, and how keeping the project under the Linux home directory avoids costly file‑system translation overhead that can turn a two‑second build into a minute‑long one. Listeners learn how to install a headless Android SDK in WSL2, run a Windows‑side ADB server with the –A flag, and point Linux tools at it so compiled binaries move smoothly to the emulator.
    The show also covers using Windows 11 mirrored networking to expose a Vite dev server running in WSL2 directly to the Android emulator via the 10.0.2.2 address, enabling instant hot‑module reloads. Finally, it shows how to offload iOS builds to Capgo’s cloud service and push OTA updates with Capgo Live, letting developers ship fixes without App Store delays.
    Topics:
    - Separate project files in Linux home to avoid \mnt\c latency
    - Run a Windows ADB server (adb -a) and connect from WSL2
    - Enable mirrored networking and use 10.0.2.2 for live reload
    - Duplicate Android SDK in WSL2 for fast Gradle builds
    - Use Capgo CLI for cloud iOS builds and over‑the‑air updates
    Full article
    https://capgo.app/blog/capacitor-wsl2-windows-setup/
    21 min
  • Capacitor Wear Os App
    Capacitor lets you write a single web‑based app for iOS and Android, but Wear OS has no Capacitor runtime, so the watch side must be built in native Kotlin. To connect the two, you use Google’s Wear OS Data Layer API (play‑services‑wearable) and the Capgo watch plugin, configuring a matching capability string, identical application IDs, and the same signing certificate. The bridge enforces strict security, and mismatched keys silently return an empty node list, making debugging tricky.
    Three communication paths are covered: sendMessage for instant actions, updateApplicationContext for a small, persistent state (limited to ~100 KB and ignoring unchanged payloads unless you add a unique field), and putData for queued, guaranteed delivery. The episode also explains emulator requirements, Play Services dependency, versioning JSON payloads to handle uneven update cycles, and best practices for keeping the watch app thin while using Capgo to hot‑swap phone code.
    Topics:
    - Configuring capability strings, app IDs and signing certificates for Data Layer security
    - Choosing the right Data Layer method: live messages, context sync, or queued user info
    - Handling emulator setup and Play Services requirements for testing
    - Versioning JSON payloads to maintain compatibility between fast phone updates and slower watch releases
    - Keeping the watch side minimal and using Capgo for instant phone‑side hot updates
    Full article
    https://capgo.app/blog/capacitor-wear-os-app/
    21 min
  • Capacitor Privacy Screen Hide App Content
    Capacitor apps inherit the OS behavior of taking a snapshot of the screen when the app is backgrounded, exposing sensitive data in the app switcher, recents view, and screen recordings. The episode explains how Android’s windowManager.LayoutParams.FLAG_SECURE and iOS lifecycle events are used to block those snapshots, and why the timing of the protection matters for web‑based Capacitor apps.
    Listeners learn how to enable whole‑app protection via the capacitor.config.ts flag, or apply route‑level privacy screens with JavaScript calls tied to the app router. The discussion also covers trade‑offs such as user experience impact, screen‑sharing limitations, and how live‑update patches can quickly fix mis‑configured privacy logic.
    Topics:
    - Enabling global privacy screen through native config before the web view loads
    - Using router hooks to toggle privacy mode only on sensitive screens
    - Android FLAG_SECURE vs iOS overlay approach and their limitations
    - Balancing security with usability, including screenshot and screen‑share concerns
    - Applying live updates to correct privacy screen bugs without app store delays
    Full article
    https://capgo.app/blog/capacitor-privacy-screen-hide-app-content/
    24 min
  • Capacitor Live Reload Android Windows Linux
    Capacitor live reload on Android can be set up from Windows or Linux by configuring the dev server and the Capacitor server URL. The guide shows how to bind Vite, Angular, or Next.js to 0.0.0.0, set CAP_LIVE_RELOAD_URL, and run bunx cap sync/run with the appropriate host and port. It explains the three main connection methods—using the emulator’s 10.0.2.2 address, adb reverse for a USB‑connected device, or the LAN IP with firewall rules—for fast iteration without rebuilding the native app.
    Listeners also learn how to avoid shipping the dev config in release builds, fix HMR websocket host issues, and debug the WebView via chrome://inspect. The article highlights practical steps for Windows firewall rules, Linux udev setup, and WSL2 port exposure, ensuring reliable live reload across environments.
    Topics:
    - Binding the dev server to all interfaces and setting CAP_LIVE_RELOAD_URL
    - Choosing the correct address: emulator 10.0.2.2, adb reverse, or LAN IP with firewall
    - Preventing dev config from leaking into production builds
    - Fixing HMR websocket host mismatches in Vite, Angular, and Next.js
    - Using Chrome’s remote inspector to debug the Android WebView
    Full article
    https://capgo.app/blog/capacitor-live-reload-android-windows-linux/
    28 min
  • Capacitor Key Value Storage
    Capacitor key‑value storage in a mobile app must match the data’s size and sensitivity. The episode explains why WebView storage like localStorage or IndexedDB is volatile and can be wiped by the OS, and why developers should move to native storage options. It walks through the three native layers: Preferences for tiny settings, SQLite‑based stores (FastSQL or Data‑Storage‑SQLite) for larger caches, and the biometric plugin that talks to the iOS Keychain or Android Keystore for secrets.
    Listeners learn how to choose the right plugin, avoid performance and security pitfalls, and migrate existing data safely. The discussion covers the limits of each layer, the need for atomic writes, handling of encryption keys, and the importance of a first‑run flag to purge leftover keychain entries after an uninstall.
    Topics:
    - Why WebView storage is unsafe for persistent data
    - Using Capacitor Preferences for lightweight toggles only
    - Choosing FastSQL versus Data‑Storage‑SQLite for large JSON or binary blobs
    - Storing secrets in the biometric plugin with hardware‑backed keystore
    - Migration strategy from WebView storage to native layers with a first‑run flag
    Full article
    https://capgo.app/blog/capacitor-key-value-storage/
    24 min
  • Capacitor Iphone Duo Safe Area Guide
    The iPhone Duo’s foldable design moves the status bar and navigation chrome into a vertical side rail that consumes about 84 points of horizontal space, breaking the traditional top‑and‑bottom safe‑area assumptions that web‑based Capacitor apps have relied on for years. To keep layouts from collapsing, developers must treat the folded outer screen as a compact width and the opened inner screen as a regular width, using flexible CSS Grid or Flexbox and setting the meta viewport tag to viewport‑fit=cover so the web canvas can bleed to the edges while interactive elements receive explicit padding from env(safe‑area‑inset‑*) variables.
    Capacitor 8’s System Bars plugin can inject those insets automatically, but teams must choose either the plugin or a manual per‑page CSS strategy—not both—to avoid compounding padding. Real‑time JavaScript listeners for window resize and visual‑viewport changes are required, and native navigation plugins should be used so tab bars migrate with the OS rail. Finally, Capco’s live‑update pipeline lets teams push immediate CSS/JS fixes over‑the‑air, bypassing App Store delays when foldable‑specific bugs appear.
    Topics:
    - Using independent env(safe‑area‑inset) variables for left and right padding
    - Choosing between manual CSS padding and Capacitor System Bars plugin to avoid double padding
    - Implementing native navigation plugins to let iOS move tab bars into the side rail
    - Listening to resize and visual‑viewport events for dynamic layout recalculation
    - Deploying over‑the‑air fixes with Capco Live updates for foldable‑specific bugs
    Full article
    https://capgo.app/blog/capacitor-iphone-duo-safe-area-guide/
    24 min
  • Capacitor Ios Development Without Mac Faq
    Capacitor lets you develop iOS apps on Windows or Linux by writing web code, managing Apple developer accounts, and editing config files like info.plist without a Mac. The episode explains how the only Mac‑only step is compiling and signing the .ipa, which can be offloaded to cloud services such as Capco Native Build that run the required Xcode tools and upload the binary to App Store Connect.
    Listeners learn how to generate signing certificates with OpenSSL, push live JavaScript updates via Capco’s Live Updates without rebuilding, test builds through TestFlight or ad‑hoc links, and when renting a cloud Mac is still advisable for deep native debugging, plugin development, or initial signing UI walkthroughs.
    Topics:
    - Using Capco cloud build to compile and sign iOS apps from Windows
    - Creating Apple certificates with OpenSSL instead of Keychain
    - Instant web‑layer updates with Capco Live Updates
    - Testing on real devices via TestFlight or ad‑hoc IPA links
    - Edge cases where a rented cloud Mac is still needed
    Full article
    https://capgo.app/blog/capacitor-ios-development-without-mac-faq/
    22 min
  • Capacitor Google Maps Plugin Alternatives
    Capacitor developers face a hidden‑layer nightmare when using the official Google Maps plugin version 8: Android renders the native map behind the web view, forcing developers to make every UI layer transparent, fight blank‑map bugs, and cope with marker flicker because the API lacks an update‑marker call. The guide explains why these native constraints drive teams toward web‑based mapping solutions that avoid the billing overhead and complex layering.
    The episode walks through practical alternatives: MapLibre GL JS for WebGL vector tiles (requiring a custom tile source), Leaflet for lightweight raster tiles (with bundler icon fixes), and the Google Maps JavaScript API embedded in the web view (accepting higher usage costs). It also covers live‑update workflows with Capgo to push map URL or styling changes instantly, and tips for avoiding zero‑height containers and performance pitfalls on Android.
    Topics:
    - Why the official Capacitor Google Maps plugin creates a transparent‑background issue on Android
    - Using MapLibre GL JS for vector‑tile maps inside the web view
    - Leaflet’s raster‑tile approach and handling bundled icon assets
    - Embedding the Google Maps JS API in the web layer and managing API‑key restrictions
    - Leveraging Capgo live updates to fix map configuration without app store reviews
    Full article
    https://capgo.app/blog/capacitor-google-maps-plugin-alternatives/
    18 min

About Capgo Live Updates

From the publisher's feed

Capgo Live Updates is a podcast for developers building mobile apps with Capacitor and Ionic. Each episode explores an article from the Capgo blog, covering over-the-air updates, native integrations,…