ASO.dev Tests Adaptive UIs Across 5 Platforms with Flutter

Flutter 3.47.5 is now available on stable! 🚀 Fixes occasional crashes when debugging on physical iOS 27 devices (flutter/190307), plus Widget Previewer and flutter_tools crash fixes. Check out the CHANGELOG for details here: https://lnkd.in/euYaYVWk If you have any feedback on this release, please report it here: https://lnkd.in/fs2_CDq

Flutter is slowly becoming much more than a mobile framework. One of Flutter’s most requested desktop features is finally taking shape: Real multi-window support. Flutter’s new experimental Desktop Windowing API can create actual native-style: Windows • Dialogs • Popups • Tooltips • Satellite windows Until now, Flutter’s architecture still carried an important assumption from its mobile roots — usually, one application means one main window. That works well on phones. But desktop applications are different. Think about IDEs, browsers, design tools, dashboards, or productivity software. They often need multiple independent windows, floating tool panels, dialogs, and popups. Flutter is now building proper support for those workflows. What I find most interesting is that Material components such as showDialog, showMenu, and Tooltip are planned to use these native windows automatically when the platform supports them. That means Flutter is moving toward: One codebase → More native desktop behavior For developers who mainly think of Flutter as an Android/iOS framework, this is a development worth watching. Flutter’s next big opportunity might not only be mobile. It could be desktop too. Would you use Flutter for a serious desktop product today? #Flutter #Dart #DesktopDevelopment #SoftwareDevelopment

DAERO is a small Android app I built for logging issues on construction sites, and the code is public on GitHub. The idea is simple: someone on site snaps a few photos, adds a title, notes and priority, and moves on. The app takes care of getting it to the server. What's in it: - Offline-first. Everything goes into Room first. WorkManager picks up pending issues when there's a connection and retries with backoff if a sync fails. - Conflicts. If the server copy changed while you were offline, you see your version and the server's side by side and choose which to keep. - Drafts that survive process death, so a half-finished issue isn't lost when Android kills the app in the background. The backend is a fake service you can configure at runtime to fail, conflict or drop photo uploads, which made the sync logic much easier to test. There are unit tests for sync, persistence and the ViewModels, plus Room migration tests. I also wrote up the architecture choices in an ADR, including why I went with plain MVVM and a repository instead of full Clean Architecture for an app this size. Code: https://lnkd.in/d8in5eki Feedback from other Android devs is welcome. #AndroidDev #Kotlin #JetpackCompose #OpenSource

Stop fighting your navigation library and start building better apps. androidx.navigation forces you into rigid framework coupling, verbose setup, workaround-based result passing, and single-screen transitions that limit what your UI can do. I built Awesome Nav — a pure Kotlin, zero-boilerplate navigation library engineered for total architectural freedom, setup simplicity, and full cross-platform compatibility. Here is what makes it a total upgrade: → Easiest KMP Setup: Single-block initialization in Application.onCreate() or MainViewController(), with native Android & iOS support out of the box. → Zero Annotation Processing: Pure Kotlin with @Serializable routes. No KSP/kapt build overhead or custom NavType parsers. → Global Navigator Access: Call NavRegistry.get() from ViewModels, Services, or native iOS code—no threading NavController through your UI tree. → Native Dual-Screen Animations: Custom Z-stack keeps both screens alive simultaneously during transitions for seamless parallel rendering and predictive gestures. → First-Class Result Passing: Clean, reactive state delivery via StateFlow and setResult()—ditch SavedStateHandle hacks completely. → Smarter Lifecycle & ViewModels: ViewModels stay alive until exit animations complete, while individual LifecycleOwner handles state accurately per entry. → Unified Deep Linking: Handle deep links cross-platform with a single addDeepLink() pattern instead of bloated per-destination configs. Pure Kotlin. Zero framework dependencies (Fragment, SavedStateRegistry, NavGraph). One single line to install. Check out the GitHub repo to see code examples and full docs — link in the comments! Feedback and contributions are welcome. https://lnkd.in/gG_T-wep #KotlinMultiplatform #JetpackCompose #AndroidDev #iOSDev #Kotlin #OpenSource #KMP #CMP #MobileArchitecture

𝗦𝘄𝗶𝗳𝘁𝗨𝗜 + 𝗪𝗶𝗱𝗴𝗲𝘁𝗞𝗶𝘁: 𝗔 𝗦𝗺𝗮𝗹𝗹 𝗕𝘂𝘁𝘁𝗼𝗻, 𝗔 𝗕𝗶𝗴 𝗟𝗲𝘀𝘀𝗼𝗻. 🚀 Last week, I worked on a workout summary widget using SwiftUI, WidgetKit, and AppIntents. The requirement was simple: ✅ Tap a button to mark a workout as complete. ✅ Update the shared data using App Groups and UserDefaults. ✅ Refresh the widget to reflect the latest status. I implemented the AppIntent, connected it to a shared UserDefaults suite, and added the button to the widget. But when I tapped it, nothing changed. The widget continued displaying the same data, as if it were a static snapshot. After spending hours debugging SwiftUI observation and data updates, I discovered the root cause. 𝗪𝗶𝗱𝗴𝗲𝘁𝗞𝗶𝘁 𝗱𝗼𝗲𝘀𝗻'𝘁 𝗮𝘂𝘁𝗼𝗺𝗮𝘁𝗶𝗰𝗮𝗹𝗹𝘆 𝗿𝗲𝗹𝗼𝗮𝗱 𝗶𝘁𝘀 𝘁𝗶𝗺𝗲𝗹𝗶𝗻𝗲 𝘄𝗵𝗲𝗻 𝗮𝗻 𝗔𝗽𝗽𝗜𝗻𝘁𝗲𝗻𝘁 𝗺𝗼𝗱𝗶𝗳𝗶𝗲𝘀 𝘀𝗵𝗮𝗿𝗲𝗱 𝗱𝗮𝘁𝗮. The solution was to explicitly request a timeline refresh: WidgetCenter.shared.reloadAllTimelines() This small addition made the difference. 💡 𝗞𝗲𝘆 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀 🔹 AppIntents enable interactive experiences directly within widgets. 🔹 App Groups allow the main app and widget extension to share data. 🔹 Updating shared data doesn't automatically refresh the widget's UI. 🔹 WidgetCenter.shared.reloadAllTimelines() requests a refresh, but WidgetKit determines when the updated content is displayed. This was a great reminder that building interactive widgets requires understanding not just SwiftUI, but also WidgetKit's timeline-based update mechanism. 𝗜'𝗱 𝗹𝗼𝘃𝗲 𝘁𝗼 𝗵𝗲𝗮𝗿 𝗳𝗿𝗼𝗺 𝗳𝗲𝗹𝗹𝗼𝘄 𝗶𝗢𝗦 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀: Have you faced similar challenges with WidgetKit and AppIntents? How do you handle widget refreshes in your projects? #SwiftUI #iOSDevelopment #WidgetKit #AppIntents #Swift #Xcode #iOSDevelopmentTips #MobileDevelopment #iOS

🚀 Android Studio Quail 4: Updates Android Developers Should Know Android Studio keeps evolving beyond just an IDE. The latest stable release, Android Studio Quail 4, brings some interesting improvements around AI, Jetpack Compose, Firebase, and debugging. Here are a few updates that caught my attention 👇 🤖 AI + Firebase Agent Mode can help configure Firebase services such as: 🔹 Firebase Authentication 🔹 Cloud Firestore This can reduce the setup work when starting a new project. 🔍 Better Compose Recomposition Debugging One of the most useful updates for Compose developers. Layout Inspector can now help identify: 👉 Which state reads triggered recomposition 👉 Recomposition history 👉 AI-assisted explanations This can make investigating unnecessary recompositions much easier. 🧠 Run Gemma Locally Android Studio also brings support for running Gemma 4 locally. This opens up interesting possibilities for: • Code assistance • Refactoring • Debugging • AI experimentation without always relying on cloud APIs 🎬 Compose Predictive Back You can now interact with Predictive Back behavior directly in Compose Interactive Preview. This makes testing back-navigation animations easier without constantly deploying the app. 💡 My Take What I find interesting is the direction Android Studio is taking: IDE + AI + Firebase + Compose tooling + Debugging For Android developers, tools like these can reduce repetitive work and give us more time to focus on building the actual product. For me, the Compose recomposition debugging improvements are probably the most practical. Which Android Studio feature are you most excited to try? 👇 #AndroidStudio #AndroidDevelopment #JetpackCompose #Kotlin #AndroidDev #Firebase #Gemma #AI #MobileDevelopment #SoftwareEngineering

The Android Developers site just rolled out an updated hub for Application Memory. Aside from the curiously named URL, the content does a fantastic job of structuring modern memory workflows! The clear distinction between local debugging (Perfetto heap explorer, Studio tools) and production monitoring (Android vitals, ProfilingManager) makes navigating performance at scale much clearer. Tip for developers: To bridge the gap between local profiling and production vitals, consider integrating automated memory checks into your CI/CD (e.g., via Macrobenchmark metrics or automated heap diffing) to catch allocation spikes and leaks before shipping to users. https://lnkd.in/dUJ9M5d7 #android #androidperformance #andriodmemory

Calf — Kotlin Multiplatform UI Components Calf is an open-source library by Mohamed Rejeb providing a collection of useful UI components and utilities for Compose Multiplatform. It can help simplify common UI needs when building Kotlin Multiplatform applications, with components designed to work across supported platforms. Repository: https://lnkd.in/eq7YivcR Author: Mohamed Rejeb written with a little help of a constrained IA For questions about trildaDevCenter, partnerships, or collaboration opportunities, please contact Paul Plaquette via LinkedIn. #Kotlin #KotlinMultiplatform #ComposeMultiplatform #JetpackCompose #Android #iOS #UI #OpenSource #trildaDevCenter

Last week I shared FocusLockAI. This week: everything that broke while building it. The app blocks your distracting apps behind a "say why + Face ID or walk-to-an-NFC-tag" ritual, built on Apple's Screen Time stack. Sounds simple. It was not. The stack: React Native + TypeScript for the UI A Swift native layer (TurboModule) that owns all enforcement — JS asks nicely, native decides Apple's Screen Time APIs: FamilyControls, ManagedSettings, DeviceActivity Two shield extensions + a local-only event log. No backend, nothing leaves the phone. What broke, in order of how much I aged: My kill test failed gloriously: unlock apps → force-quit FocusLock → shields never come back. Root cause: DeviceActivity has a 15-minute minimum monitoring window, and my 3-minute check was silently throwing intervalTooShort. The OS was ignoring me and didn't even leave a note. Fix: schedule a ≥15m post-expiry window and fail closed — if the schedule can't be guaranteed, the shields stay up. I named my project folder "FocusLock AI" — with a space. React Native's codegen took that personally. One patch script and a small existential crisis later, we were friends again. Unlock windows that cross midnight just... end early? Cinderella rules, apparently. Fix: never trust a timer you didn't verify — reconcile the real state on every launch. The shield screen legally cannot open your own app. Apple forbids it. So the unlock flow had to be designed around a door that only opens from one side. Principles that survived contact with reality: Native owns enforcement; JavaScript never decides whether a shield is active. The event log is the source of truth; the dashboard is just a fold over it. Fail closed for enforcement, fail usable for recovery. Building in public turned every one of these bugs into a documented decision instead of a private frustration. Happy to share notes with anyone building on the Screen Time APIs — it's a small club, and we all have the same scars. What's the most personally offended a build tool has ever been by your folder name? #BuildInPublic #iOS #ReactNative #Swift #ScreenTime #SideProject

Most mobile teams I talk to have unit tests and no end-to-end tests. Not because they don't want them: because "a device farm, a Mac runner and someone to maintain it all" sounds expensive. It doesn't have to be. I wrote a step-by-step tutorial that gets a mobile app from zero UI tests to a green or red end-to-end verdict on every pull request, on free CI: • Maestro flows that run on Android AND iOS from the same YAML • Tagging the app so tests survive copy and locale changes • One bash script that runs identically on a laptop and in CI, so a red run is reproducible in one line • A complete CircleCI config on the free plan: Android machine image with KVM, one emulator per suite, a per-test check on the PR • GitHub Actions as the alternative, and the arithmetic of what "free" really buys • 15 traps that each cost a day, with the fix for each The tutorial: https://lnkd.in/ePEz7pv4 Which trap have you already hit? #MobileDevelopment #AndroidDev #iOSDev #KotlinMultiplatform #ComposeMultiplatform #Testing #CICD #CircleCI #Maestro