Build high quality, feature rich apps with the new Flutter Extension for Gemini CLI

Today we’re excited to share the first experimental version of the Flutter Extension for Gemini CLI, which combines the Dart and Flutter MCP Server with additional context and commands, making it easier and more productive to build Flutter apps with Gemini CLI.

AI agents are changing the way we build Flutter apps by assisting with tasks like feature prototyping, code reviews, as well as writing and running tests. In order to use an AI agent effectively, you need to provide it with context and access to tools to help it become a productive Flutter coding assistant. This is where the Flutter Extension for Gemini CLI comes in. Gemini CLI extensions allow you to build integrations with Gemini CLI and your tools, and the Flutter extension builds off of these capabilities.

The Flutter Extension for Gemini CLI provides commands to accelerate app development, follows explicit rules to write high-quality code following Dart and Flutter best-practices, and runs tools from the Dart and Flutter MCP server to directly access Dart and Flutter’s developer tools. You spend less time on setup and more time building high quality Flutter apps.

See it in action

To get started, install the extension with the following command:

gemini extensions install https://github.com/gemini-cli-extensions/flutter

The Flutter Extension for Gemini CLI comes with a set of commands to help you with critical stages of development. Here are a few of the most common commands and how to use them:

/create-app: Creates a design doc and implementation plan for Gemini to follow.
/modify: Creates a plan to make large changes to the app.
/commit: Analyzes and tests the code, fixes any issues that were found, and then commits the change to Git.

To learn more about how to set up and use the Gemini CLI extension, follow the instructions in the GitHub repository.

Create an app

You can create a new application using the /create-app command. This command bootstraps a brand-new, production-ready Flutter app. It goes beyond flutter create by asking for your app’s purpose, setting up recommended linter rules, and generating detailed DESIGN.md and IMPLEMENTATION.md files for your review before any code is written.

/create-app

\"\" — Create app app with the /create-app command

The DESIGN.md file is a design document for the app; it specifies the problems that the app solves and provides technical details about how it will work. You can edit this file before you continue with the implementation steps, allowing you to guide Gemini to build the exact app that you’re looking for.

Once the design is ready, /create-app generates an IMPLEMENTATION.md file, a step-by-step implementation plan, so that it can iteratively work on feature implementation. It keeps a record of its progress, so you can pause and restart. By default, /create-app splits the plan up into 3–5 phases, where each phase is a logical stopping point. After each phase, Gemini will analyze and format the code, run tests, and commit the changes. It will also update this file after it completes a phase in the Journal section.

Implement features from the plan

After you’ve set up your project, you’re ready to implement the features in your implementation plan using the generated IMPLEMENTATION.md file. Each feature will be implemented separately, as outlined in this file. Once it finishes implementing a feature, the Flutter Extension will mark it as complete.

Before moving to the next phase, the extension will ask for your approval. You can enter the prompt “looks good” to start generating code:

\"\" — The guided implementation plan keeps Gemini CLI on track

Modify

To make changes to existing code, the /modify command initiates a guided development session. It asks for your goals, offers to create a new branch, and generates a MODIFICATION_PLAN.md design doc outlining the proposed modifications and a phased implementation plan.

/modify

\"\" — Use the /modify command to create a detailed modification plan for Gemini to follow

Clean up and commit

The final step is to commit the changes using /commit. This command prepares your changes before committing them with Git. It automatically runs dart fix and dart format, runs the analyzer and tests, and then generates a descriptive commit message based on the changes for you to approve.

\"\" — Use the /commit command to clean up and prepare the code for commit

Fully loaded with best-practices

Every interactive chat session includes rules containing best-practices for Flutter and Dart development. These rules ensure that Gemini writes high-quality Dart and Flutter code, interacts with MCP server tools correctly, and follows best practices such as creating unit tests, writing documentation, ensuring accessibility, and more.

\"\" — The extension includes rules and best-practices

Access to development tools with the Flutter and Dart MCP server

The Dart and Flutter MCP server is automatically configured when you install the Flutter Extension for Gemini CLI. This allows Gemini CLI and other AI agents to perform common development tasks:

Analyze and fix errors in your project’s code.
Introspect and interact with your running application (such as trigger a hot reload, get the selected widget, fetch runtime errors).
Search pub.dev for the best package for your use case.
Manage package dependencies in your pubspec.yaml file.
Run tests and analyze the results.
…and more!

\"\" — The MCP server provides Gemini CLI access to Dart and Flutter DevTools

Try it out

We hope you try out the Flutter extension for Gemini CLI and share your feedback.

Check out the Flutter extension on GitHub to learn more. If you have suggestions or run into problems, please file an issue. We can’t wait to see what you build!

$\"\"$

Meet the Flutter Extension for Gemini CLI was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","guid","https://medium.com/p/f8be3643eaad","Meet the Flutter Extension for Gemini CLI","medium_blogs",{"_2445":13},{"_8":2466,"_30":2467,"_2456":2457,"_2458":2468,"_2445":13,"_2460":2469,"_36":2470,"_2463":2471},766,"2025-08-14T18:23:26+00:00","

Hot Reload, Widget Previews, and More

Introduction

Welcome to the quarterly release of Flutter 3.35! This update is all about boosting your productivity, and brings the stable release of stateful hot reload on the web and the experimental launch of Widget Previews! Through the efforts of our community, Flutter 3.35 includes 1108 commits from 168 unique contributors, with 39 of them joining us for the first time. Let’s explore what’s new!

Web

Stateful hot reload on the web is now enabled by default

We’re thrilled to announce this milestone for Flutter on the web and welcome everyone to add hot reload into their web development workflow.

The positive feedback and issue reports we received during the experimental phase helped a lot. The Dart and Flutter web teams have been hard at work to improve the performance of hot-reloaded code while ensuring that more code changes can be successfully hot reloaded.

Our goal is to provide a seamless and consistent hot reload experience across all platforms. While you can still disable this feature using a flag, we plan to remove that ability in a future release.

Wasm dry runs

In anticipation of enabling WebAssembly (Wasm) as the default web build target, every JS build now performs a “dry run” compilation to Wasm. A series of checks determines the Wasm-readiness of your application, and any findings are emitted to the console as warnings. This feature can be toggled with the --(no-)wasm-dry-run flag.

What’s new?

Previously, you had to explicitly enable stateful hot reload on the web using an experimental flag. Now, when you run your Flutter web application, stateful hot reload is available out of the box! Whether you run your Flutter web application from the command line or launch it from your IDE or coding agent, just run it in development mode and hot reload freely.

The --web-experimental-hot-reload flag is no longer necessary to enable hot reload and you can remove it from your workflow or any IDE launch configurations you may have configured.

Feedback

We know everyone can have a slightly different development environment, so if yours is broken by this change, you can disable hot reload with the flag --no-web-experimental-hot-reload for now. If you discover any issues, please file a bug using Dart’s web hot reload issue template. For more information, see the hot reload on the web documentation.

What’s next?

Current active work will bring hot reload to more development environments, including -d web-server. We expect this will unlock more of your productivity while developing on the web, so keep an eye out for future releases!

Framework

A more inclusive and accessible experience

Making applications accessible to all users is a cornerstone of the Flutter framework. This release continues our commitment with a host of improvements that give developers more control and refine the out-of-the-box experience for users of assistive technologies.

Richer semantics on the web

We’ve made significant strides in how Flutter web apps communicate with screen readers and other tools. For international users, we’ve added support for semantics locales (#171196), ensuring that accessibility features are presented in the user’s preferred language.

New tools for building accessible widgets

Developers now have more powerful tools to create sophisticated accessible experiences. The new SemanticsLabelBuilder widget (#171683) simplifies the process of combining multiple data points into a single, coherent announcement without messy string concatenation.

For complex scrollable views, the new SliverEnsureSemantics widget (#166889) can be used to wrap slivers, ensuring they are always represented in the semantics tree, even when scrolled out of view.

Core widget and platform polish

This release is packed with fixes that polish the accessibility of core widgets.

On iOS, the CupertinoSliverNavigationBar now correctly respects accessible text scaling (#168866), and VoiceOver tab activation behavior now works correctly (#170076).
For Android, Talkback issues now work when using platform views (#168939), a critical fix for apps that embed native components.
Semantics properties for CustomPainter (#168113) are now backfilled, empowering you to make your custom-drawn UI fully accessible.
The text selection toolbar is now correctly aligned for right-to-left (RTL) languages, improving the experience for a global audience (#169854).

Material and Cupertino: More power and polish

The Material and Cupertino libraries continue to evolve, giving you more control over your app’s look and feel.

New and enhanced components

We’ve added brand new, highly requested components and shipped significant enhancements to existing ones.

Introducing DropdownMenuFormField (#163721): You can now easily integrate the M3 DropdownMenu directly into your forms.
Scrollable NavigationRail (#169421): The NavigationRail can now be configured to scroll for cases where you have more destinations than can fit on the screen.
NavigationDrawer header and footer (#168005): You can now add a header and footer to the NavigationDrawer, providing more layout flexibility.
Introducing CupertinoExpansionTile (#165606): Create expandable and collapsible list items with the new CupertinoExpansionTile widget.

Higher fidelity and interactivity

A key theme for this release was polishing our widgets to be as pixel-perfect as we can make them and behaviorally cohesive as their native counterparts.

Many Cupertino widgets have been updated to use the RSuperellipse shape (#167784), giving them the signature continuous-corner look that iOS users expect.
To make apps feel more alive and native, we’ve added haptic feedback to key interactive components like the CupertinoPicker (#170641) and CupertinoSlider (#167362).
The Slider’s value indicator can now be configured to be always visible (#162223).

More from the framework

This release includes a number of powerful new features and refinements for some of the framework’s most essential parts, giving you more granular control over complex UI.

More powerful slivers

For developers building sophisticated scrolling experiences, you can now explicitly control the paint order (or z-order) of slivers (#164818), making it possible to correctly implement advanced effects like “sticky” headers that overlap other slivers without visual glitches.

Finer-grained control over navigation and forms

We’ve added several new features to give you more control over your app’s navigation and routing.

Fullscreen dialogs (#167794): The property fullscreenDialog was added to ModalRoute (plus all its descendants) and to showDialog. This enables customizing navigation behavior to and from dialog routes.
Form Improvements (#167060): FormField now includes an onReset callback, making it easier to handle form clearing logic.

Multi-window support (engine)

Our friends at Canonical continue to make excellent progress on adding support for multi-window applications! In this release, they landed the foundational logic to create and update windows in Windows and macOS (#168728). Subsequent releases will update Linux and introduce experimental APIs to expose multi-window functionality. Stay tuned!

Text input and selection refinements

Text input is a fundamental part of the user experience, and this release brings several refinements to make it more powerful and predictable.

A more unified gesture system: The introduction of the PositionedGestureDetails interface (#160714) unifies the details for all pointer-based gestures and allows you to write more generic gesture-handling code.
iOS single-line scrolling (#162841): To better align with native iOS behavior, single-line text fields are no longer scrollable by the user.

Android home/end key support (#168184): We’ve added support for the Home and End keyboard shortcuts on Android.

Looking forward: Decoupling Flutter’s design libraries

As the Flutter ecosystem continues to grow and mature, so too must the core framework. A key part of this maturation is ensuring that all parts of Flutter can evolve at the pace that best serves the community.

To that end, we are beginning the process of moving the Material and Cupertino libraries out of the core Flutter framework and into their own standalone packages. We are just getting started on this work and, as always, are doing so openly and in collaboration with our contributor community.

Why is this changing?

This evolution will allow the Material and Cupertino libraries to innovate and release updates more frequently, independent of the quarterly Flutter release cycle. It also empowers the community to contribute more directly to the UI libraries they use every day. For the core framework, this change will lead to a more focused and stable foundation.

What does this mean for you?

There are no immediate changes to your workflow. This is the start of a long-term project, and we are committed to making the eventual transition as smooth as possible. We invite you to follow our progress, learn more about the plan, and share your feedback.

To read the detailed vision and rationale, see: Decoupling Design in Flutter.
To provide feedback and help coordinate the work, please join the discussion on GitHub.

This is a natural evolution for a mature and thriving ecosystem. We believe this change will lead to stronger and more agile Material and Cupertino libraries, with an even greater opportunity for community collaboration.

iOS

iOS 26 and Xcode 26 beta compatibility

We are actively working on Flutter’s compatibility with the iOS 26 betas. Please help us by testing your apps and plugins on the latest beta releases and filing any new issues you discover. You can track our progress and see a list of known issues in this GitHub project.

Android

Sensitive content protection

On Android, you can now protect sensitive user content during media projection by using the SensitiveContent widget in your Flutter app. With API 35 and later, you can use this widget to obscure the entire screen during a screen share and help prevent data theft. For more details on this feature and how to use it, check out Protect sensitive content.

Engine

General engine updates

3.35 continues to focus on improving Impeller performance and compatibility. Investments have also been made to adopt UISceneDelegate for iOS and to introduce additional tooling improvements. Some notable additions are below.

Engine

Optimization: App startup time has been reduced by performing initialization on a new thread.

Impeller

Optimization: Removed MSAA from intermediate targets.
Fidelity: Removed lossy texture compression default.
Fix: Fixed stuck MaskFilter in subsequent draws.
Optimization: Path rendering.
New: Added Vivante GPU support.
Optimization: DrawImageNine now use fast Porter Duff blends.
Fix: Fixed memory leak in VideoPlayer
Fidelity: Increased blur radius calculation for cleaner blurs with large sigmas.

iOS

Fix: Resolved crash in WebView wrapped with ClipRSuperellipse.
Fix: Image decoding now works when launching apps in the background from a remote notification.
Revival: Brought back Live Text (OCR) option to text fields.

Android

Migration: template project migrated to Android 24.
Fix: Fixed crash on Android <= 14 from background image readers.
Fix: Fixed uniform arrays in fragment shaders for OpenGLES Impeller.
Fix: Fixed upside down fragment shader passes in OpenGLES Impeller.
Fix: Fixed crash in FlutterEngineGroup.

macOS

Fix: Fixed Display P3 colors.

DevTools and IDEs

The Dart and Flutter MCP Server is now in the stable channel

The experimental Dart and Flutter MCP Server is now available on the stable channel of the Dart SDK. This marks a major step forward in our vision for a highly productive, AI-assisted development experience for every Dart and Flutter developer.

Enhanced Dart and Flutter context for AI coding assistants

The Dart and Flutter MCP Server acts as a bridge, giving AI coding assistants access to even more of your project’s context via the Dart and Flutter toolchain. Instead of just suggesting code, your AI assistant can now understand your project deeply and take action on your behalf. This allows you to stay focused on your goals while the AI handles the mechanics.

With the Dart and Flutter MCP Server, you can ask your AI assistant to:

Fix runtime errors: Inspect the live widget tree, identify a Flutter RenderFlex overflow, and apply the correct fix automatically.
Manage dependencies: Find the best package on pub.dev for a specific task, add it to your pubspec.yaml, and run pub get.
Write and correct code: Generate the boilerplate for a new feature, and then self-correct any analysis errors it introduces along the way.
And more….

Connect to your favorite AI tools

By connecting your favorite AI tools like Gemini Code Assist, Firebase Studio, Gemini CLI, GitHub Copilot, and Cursor to the Dart and Flutter MCP Server, you can unlock a new level of productivity.

For a comprehensive guide on what the Dart and Flutter MCP Server can do and how to configure it in your editor of choice, check out our detailed blog post Supercharge Your Dart & Flutter Development Experience with the Dart and Flutter MCP Server, and the documentation.

\"\" — *Fixing a layout issue, enabled by the Dart and Flutter MCP Server (Note: For brevity, parts of this recording have been sped up.)*

DevTools updates

We’ve continued to make general, UX, and performance updates to DevTools. To learn more about all the updates included in Flutter 3.35, check out the release notes for DevTools 2.46.0, 2.47.0 and 2.48.0.

Experimental Widget Previews are here!

A highly-requested feature from the community is the ability to preview widgets in isolation, similar to tools available in other modern UI toolkits. We’ve heard you, and today, we’re thrilled to take the first step in addressing this with an early experimental version of Flutter Widget Previews, now available in the stable channel!

Flutter’s stateful hot reload is already best-in-class for iterating quickly on a running application. Widget previews complements this by allowing you to visualize and test your widgets in a sandboxed environment, completely separate from a full app. This is invaluable when building out a design system or testing a component across a matrix of different configurations, such as various screen sizes, themes, and text scales, all at once and side-by-side.

\"\" — *Experimenting with theming in Widget Previews*

This is an early, experimental release, and your feedback is critical in shaping its future. The APIs and user experience are not yet stable and will change as we learn from you. Based on early feedback, we are already planning future enhancements, including:

Tighter IDE integration: We plan to move beyond the current separate browser window to offer an optional, embedded preview pane directly within VS Code, Android Studio and IntelliJ IDEA.
Generic theming support: As we move forward with our plan mentioned earlier in this blogpost to decouple the Material and Cupertino design libraries from the core framework, Widget Previews will evolve to support custom and generic design systems more effectively.

We are incredibly excited to get this into your hands. To get started, check out the documentation and let us know what you think!

Read the docs: Getting Started with Flutter Widget Previewer (Experimental)
Give feedback: File issues and feature requests in the Flutter GitHub repository.
Learn more: For a technical deep-dive, see the Flutter Widget Previews Architecture document.

Analysis Server speed improvements

The dart command-line tool commands that use the analysis server now run the AOT-compiled analysis server snapshot. These include dart analyze, dart fix, and dart language-server.

There is no functional difference when using the AOT-compiled analysis server snapshot, but various tests indicate that there is a significant speedup in the time to analyze a project. Check out the change in stats when we ran some common commands on a sample package after this update:

Results vary depending on the source code, but in general, some short commands like formatting now complete in a fraction of the time and longer running ones like analysis got nearly 50% faster. This should make your everyday use of the tool feel much more responsive, and could make a big difference in common test workflows running in CI systems.

Android Studio and Jetbrains IDE plugin updates

With the release of the Flutter IntelliJ Plugin version M87, there is now support for Android Studio Meerkat and Narwhal. With this version, the Flutter plugin can now additionally be installed on CLion, GoLand, PyCharm, and several other JetBrains IDEs! For the full list, see the supported products here. Thank you to Alex Li (Flutter and Dart GDE) whose PR #7949 and diligent collaboration with our team was a driving force to expand the number of Jetbrains IDEs supported by the plugin.

For a list of all the updates and fixes, see our changelog and file issues here. To get the latest update: Settings > Plugins > Flutter > Update.

Consider subscribing to the dev channel to test the latest updates as they are released weekly. Find instructions are here.

\"\" — *The full set of IDEs supported by the Flutter IntelliJ Plugin version M87.*

Breaking changes and deprecations

This release includes several important deprecations and breaking changes that are part of our ongoing effort to modernize and improve the Flutter framework.

Component theme normalization: This release marks the completion of a significant, long-term project to normalize component themes. To make theming more consistent and align with Material 3, component themes like AppBarTheme, BottomAppBarTheme, and InputDecorationTheme have been refactored to be based on new, data-oriented …ThemeData classes.
Radio widget redesign: The Radio, CupertinoRadio, and RadioListTile widgets have been redesigned to improve accessibility. The groupValue and onChanged properties have been deprecated in favor of a new RadioGroup widget that manages the state for a set of radio buttons.
Form widget and slivers: The Form widget can no longer be used directly as a sliver. To include a Form in a CustomScrollView, it should be wrapped in a SliverToBoxAdapter.
Semantics elevation and thickness removal: The elevation and thickness properties on SemanticsConfiguration and SemanticsNode have been removed. These properties were unimplemented and their removal simplifies the API.
DropdownButtonFormField value deprecation: The value parameter on DropdownButtonFormField has been deprecated and renamed to initialValue to more accurately reflect its behavior.

For more details and migration guidance, see our breaking changes page.

Deprecated 32-bit x86 architecture on Android

Flutter has deprecated the 32-bit x86 architecture on Android. For most developers this will have no impact, as it mainly affects older x86-based Android emulators and a small number of physical devices. 32-bit ARM and 64-bit x86_64 emulators and devices are still supported. The full technical breakdown is available on the Dart GitHub deprecation issue.

Deprecated IDE support for older Flutter SDKs

With this release, we are deprecating IDE support for Flutter SDKs before 3.13.

In our next stable release, Flutter SDKs before 3.16 will be deprecated.

To learn more about Flutter’s deprecation policy, visit the Flutter compatibility page. To learn more about the deprecation policy regarding IDEs, visit SDK support for Flutter developer tools.

If you are a user of an older Dart or Flutter SDK that is no longer supported, please be sure to download a compatible version.

Minimum Android SDK has changed

The minimum Android SDK supported by Flutter, provided by flutter.minSdkVersion, is now API 24 (Android 7). If you have modified this value to something other than flutter.minSdkVersion you need to bump it to at least 24.

Also, Flutter’s minimum required values for some Android specific dependencies has increased. The Flutter tool will inform you if you need to increase any of these values, as well as provide guidance on how to upgrade (if the tool doesn’t print any warnings, no action is required).

You must now at least have:

Gradle version: 8.7.0
Android Gradle Plugin (AGP): 8.6.0
Java: 17

To address AGP and Gradle issues, either run the AGP Upgrade Assistant in Android Studio or run it from the command line.

Deprecation of pluginClass: none

Support for pluginClass: none in plugin pubspec.yaml files will be removed in future versions of Flutter, and any plugin using this field should remove it to ensure forward compatibility. All recent versions of Flutter support having no pluginClass: entry when there is no native code for that platform.

Conclusion

Flutter 3.35 is the result of a collective effort to build a better developer experience for everyone. We’re grateful for the contributions and feedback from our community including teams such as Canonical, that helped make features like web hot reload and Widget Previews a reality. Your passion is what drives Flutter forward, and we’re excited to see the amazing things you’ll create with these new tools.

For a complete list of all the changes, be sure to check out the detailed release notes and changelog. To get started, with everything in Flutter 3.35, run flutter upgrade. We can’t wait to see what you build!

$\"\"$

What’s new in Flutter 3.35 was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/c58ef72e3766","What’s new in Flutter 3.35",{"_2445":13},{"_8":2473,"_30":2474,"_2456":2457,"_2458":2475,"_2445":21,"_2460":2476,"_36":2477,"_2463":2478},765,"2025-08-06T21:01:41+00:00","

Canary Channel, Agentic AI in Android Studio, 16 KB Pages, Policy Changes, Compose Tips, Play Games

Welcome to Now in Android, your ongoing guide to what’s new and notable in the world of Android development.

This edition features the Android platform Canary Channel, the first release of Agentic AI in Android Studio, Play updates including 16 KB Page Size requirements and other policy changes, new capabilities around one-time purchases, Play Games Services v2, and Google Play Games on PC, I/O recaps on AI and dev productivity, next gen Samsung devices running Android 16, Compose tips, and more.

Most of the content of this post is available in the form of a video or podcast, so feel free to watch or listen rather than read on. (Or do all three to help you remember! There won’t be a quiz.)

Evolving Android’s early-access programs: Introducing the Canary channel 🐦

Android has introduced a new Canary release channel for its early-access programs, replacing the previous developer preview model. This channel provides earlier and more consistent access to in-development platform features throughout the year.

The new Canary channel offers continuous, rolling over-the-air (OTA) updates for supported Pixel devices, addressing previous limitations where previews required manual flashing and the preview program ended once a platform version reached Beta, requiring manual flashing to enter it again for the next cycle.

You can use the Canary channel to:

Access new features and potential behavior changes in their earliest stages.
Integrate builds into your Continuous Integration (CI) systems to identify app compatibility issues early.
Download Canary SDKs through the SDK Manager and access builds via the Android Studio Canary channel for development and testing.

The Canary channel operates in parallel with the existing Beta program. Canary builds are bleeding-edge and may contain bugs or breaking changes, making them best suited for exploring and trying out apps, rather than primary device use. The Beta channel remains as the place to focus your testing to make sure you’re ready for the next platform launch.

You can get started by flashing your supported Pixel device using the Android Flash Tool or configuring the Android Emulator with a Canary image. You can provide feedback and bug reports through the Google Issue Tracker.

Evolving Android's early-access programs: Introducing the Canary channel

Agentic AI takes Gemini in Android Studio to the next level 🤖

The latest Android Studio Narwhal Feature Drop Canary release includes “Agent Mode,” a new capability that enables the AI to handle complex development tasks. This feature allows you to describe a goal in natural language, and the agent formulates an execution plan that can span multiple project files, utilizing IDE tools for code changes, building, and searching.

You interact with it by describing tasks and then reviewing, accepting, or rejecting the proposed changes, with an option for auto-approve.

Additionally, you can enhance Agent Mode by adding your own Gemini API key, which expands the context window to 1 million tokens with Gemini 2.5 Pro. This expanded context allows Gemini to process more instructions and code. Business tier subscribers automatically receive this benefit through their Gemini Code Assist license.

Agent Mode also supports the Model Context Protocol (MCP), providing a standardized way to integrate with external tools. In this initial release, MCP supports stdio transport for tool interaction. You configure MCP servers via an mcp.json file in your Studio configuration directory.

Agentic AI takes Gemini in Android Studio to the next level

Transition to using 16 KB page sizes for Android apps and games using Android Studio 🚀

Android is transitioning to 16 KB memory page sizes to enhance app performance. Beginning November 1, 2025, new and updated apps developed against the NDK and targeting Android 15+ submitted to Google Play must support 16 KB page sizes. Apps developed exclusively with Kotlin or Java are already compatible.

Devices configured for 16 KB page sizes may see overall performance improvements of 5–10%, including faster app launch times, reduced battery consumption, and quicker camera starts. Since 4KB pages are also aligned to 16KB boundaries, a single application binary can run on both 4 KB and 16 KB devices once updated.

Android Studio provides tools to assist with this transition:

Detection: APK Analyzer identifies native libraries and their 16 KB compatibility. Alignment Checks and Lint warn about non-compliant prebuilt libraries.
Building: Android Gradle Plugin (AGP) 8.5.1+ and Android NDK r28+ enable 16 KB alignment by default.
Code Adjustments: Developers should replace hard coded 4 KB page size assumptions with runtime queries like getpagesize() or sysconf(_SC_PAGESIZE).
Testing: An Android Studio 16 KB emulator is available. Compatible physical devices running Android 15 QPR1+ offer a developer option to switch between 4 KB and 16 KB page sizes for testing.

Transition to using 16 KB page sizes for Android apps and games using Android Studio

New tools to help drive success for one-time products ⚙️

Google Play is updating how you manage one-time products, introducing a new three-level hierarchy for defining and selling digital items.

The new model consists of:

One-time product: Defines the item being purchased (e.g., “Diamond sword”).
Purchase option: Dictates how the item is granted, its price, and availability. You can now use “buy” or “rent” options.
Offer: Modifies a purchase option, enabling features like discounts or pre-orders.

This allows you to sell the same product in multiple ways. New capabilities include configuring rental periods, setting up pre-orders with defined dates and discounts, and managing regional pricing and availability for individual purchase options and offers. The concept of a default product price has been removed.

To utilize these new features, you must upgrade to Play Billing Library 8.0 and use the new monetization.onetimeproducts service of the Play Developer API or the updated Play Developer Console. You also need to integrate with the queryProductDetailsAsync API. Existing SKUs can be migrated, but new features are not supported by the older querySkuDetailsAsync API or inappproducts service. Products created via the Play Console UI will be normalized within the new system. Pre-order functionality is currently available through an Early Access Program.

New tools to help drive success for one-time products

Start building for the next generation of Samsung devices 📱

Samsung unveiled the Galaxy Z Fold7, Z Flip7, and Galaxy Watch8 series, offering you new opportunities to build for adaptive experiences. The foldables run Android 16 with an enhanced desktop windowing experience, and you can create adaptive apps for them with Compose Adaptive Layouts, Jetpack Navigation 3, and Window Size Classes. The Galaxy Watch 8 series is the first device to feature Wear OS 6.

Start building for the next generation of Samsung Galaxy devices

Level up your game: Google Play’s Indie Games Fund in Latin America returns for its 4th year 🎮💰

Google Play’s Indie Games Fund in Latin America returns for its fourth year, committing another $2 million to support ten indie game studios in the region. This new round of funding will bring the total investment in Latin American indie games through this program to $8 million USD.

Selected studios will receive between $150,000 and $200,000, along with support from the Google Play team. The program is open to indie game developers who have already launched a game on any platform (mobile, PC, or console).

Applications closed on July 31, 2025, with priority given to submissions received by July 15, 2025.

Level up your game: Google Play's Indie Games Fund in Latin America returns for its 4th year

Upcoming changes to Wear OS watch faces 🔄

Wear OS watch face development is changing to exclusively support the Watch Face Format. As of January 27, 2025, you cannot publish new AndroidX or Wearable Support Library (WSL) watch faces to the Play Store. By January 14, 2026, existing legacy watch faces will no longer be installable from the Play Store, nor will you be able to update them or continue monetizing them. To continue offering your watch faces, you must migrate them to the Watch Face Format and resubmit them to the Play Store by January 14, 2026. Watch Face Studio users should resubmit using version 1.8.7 or newer. The blog post lists resources that are available to assist with migration.

Upcoming changes to Wear OS watch faces

Articles 📚

#WeArePlay: With over 3 billion downloads, meet the people behind Amanotes 🎶

Amanotes, a mobile game company founded by Bill and Silver, has surpassed 3 billion downloads for its rhythm-based music games like Magic Tiles 3. The company aims to make musical performance accessible by combining mobile gaming with rhythm-based taps. Amanotes leveraged tools such as Firebase for A/B testing and Play Console for analytics and custom pricing for its global growth on Google Play.

#WeArePlay: With over 3 billion downloads, meet the people behind Amanotes

Top announcements to know from Google Play at I/O ’25 📈

At I/O ’25, Google Play introduced several updates to help you streamline subscriptions and maximize revenue.

Subscriptions with add-ons enable multi-product checkout, allowing you to sell subscription add-ons with base subscriptions in a single transaction and aligned payment schedule. You can learn more about creating add-ons here.
Showcasing benefits in more places across Play, including the Subscriptions Center, reminder emails, and during purchase and cancellation processes, has reduced voluntary churn by 2%. You can enter your subscription benefit details in Play Console.
New grace period and account hold durations aim to decrease involuntary churn. You can now customize a grace period of up to 30 days and an account hold period of up to 60 days, with the total recovery period not exceeding 60 days. Developers extending their decline recovery period have seen an average 10% reduction in involuntary churn for renewals. You can adjust these settings in Play Console.

Additional initiatives include prompting users to set up payment methods, expanding payment options and market availability, optimizing in-app transactions with AI, and using cart abandonment reminders.

Top announcements to know from Google Play at I/O '25

Get ready for the next generation of gameplay powered by Play Games Services 🚀

Play Games Services (PGS) is updating its features to enhance game discovery and player retention on Google Play. You must migrate from PGS v1 to PGS v2 by May 2026, as games using the v1 SDK will no longer be publishable or updatable after this date, and v1 APIs will be fully deprecated by Q3 2028.

Key updates and features include:

Achievements: Now deeply integrated across the Play Store, achievements are discoverable via search and game detail pages, and can drive engagement with Play Points. You should configure at least 15 incremental achievements, with 5 achievable within the first two hours of gameplay. Bulk configuration is available in Play Console.
Promotional Content: Audience targeting capabilities have been enhanced. You can use the Play Grouping API to create custom segments based on gameplay context for tailored re-engagement promotions.
Sign-in: PGS offers seamless sign-in and progress syncing across Android devices. The Recall API helps you manage links between PGS and your in-game accounts.

Future developments include AI-powered avatars that you can integrate into player profiles within your game.

Get ready for the next generation of gameplay powered by Play Games Services

How Mecha BREAK is driving PC-only growth on Google Play Games 🤖

Amazing Seasun Games is launching its action shooting game, Mecha BREAK, on Google Play Games on PC as part of its multiplatform PC and console release.

The game uses Google Play Games on PC for its launch strategy, including pre-registration campaigns that attracted over 3.5 million players during beta. You can access the native PC program to receive up to 15% in additional earnback, along with support for PC game development, distribution, and growth. This support includes managing PC builds, releases, and store listings through Play Console, and accessing PC-specific sales reports.

The platform provides a secure infrastructure with tools like Play Integrity API, offering malware protection and anti-cheat capabilities. Mecha BREAK itself delivers a high-fidelity PC experience with a proprietary 3D engine, offering diverse combat styles such as 6v6 hero battles, 3v3 matches, and a PvPvE “Mashmak” extraction mode.

How Mecha BREAK is driving PC-only growth on Google Play Games

Top 3 Updates for Android Developer Productivity @ Google I/O ’25 🤖

Here are the top 3 updates for Android developer productivity from Google I/O 2025:

Gemini in Android Studio: Gemini-powered AI is now available to simplify building and testing code, with features like “Journeys for Android Studio,” a “Version Upgrade Agent,” and “Agent Mode” for complex tasks. It can also generate Jetpack Compose previews and transform UI code using natural language.
New Jetpack Compose release: The latest stable version includes Navigation 3 for more flexibility, a Material 3 Expressive update to enhance user experience, and new features like autofill support and auto-sizing text, along with performance improvements.
Kotlin Multiplatform (KMP) shared module template: A new template in Android Studio helps developers share business logic between Android and iOS apps, reducing development time. This is supported by updated Jetpack libraries and new codelabs.

Top 3 updates for Android developer productivity at Google I/O '25

Top 3 things to know for AI on Android at Google I/O ’25 🤖

Google I/O ’25 announced three key updates for AI on Android development.

Gemini Nano for on-device AI experiences: New ML Kit GenAI APIs powered by Gemini Nano are available for tasks like text summarization, proofreading, and image description directly on devices.
Google AI Edge for custom models: The Google AI Edge platform now offers improved support for on-device hardware accelerators and a new AI Edge Portal for benchmarking. You can also manage custom model downloads efficiently with Play for On-Device AI, now in beta.
Firebase AI Logic for cloud AI: For advanced generative AI use cases, Firebase AI Logic provides a simplified, secure way to integrate larger models like Gemini Flash, Gemini Pro, and Imagen, including support for conversational AI with Gemini Live API and visual asset generation with Imagen.

Additionally, the open-source Androidify app demonstrates building AI-driven experiences with these new APIs, and more examples are available in the Android AI Sample Catalog.

Top 3 things to know for AI on Android at Google I/O '25

Videos 📹

Enrich your app with live updates and widgets

Ash and Aaron cover the new capabilities for Widgets and Live Updates.

Widgets now offer Canonical Layouts for faster development and Generated Previews (enhanced in Glance 1.2 for Android 15+) that display real user data, requiring careful management of memory and rate limits.

For Live Updates & Notifications, a new ProgressStyleTemplate streamlines progress indicators for time-sensitive, user-initiated journeys (e.g., delivery, ride-share) — not for ads or spam. Developers can programmatically determine if notifications meet Live Update criteria and customize a new prominent status chip for quick user access.

Reaching billions: Multiplatform strategies and performance tools for Android

Google Play now enables multi-platform Android game distribution from a single Android App Bundle, reaching billions of users across phones, tablets, foldables, and PCs. Google Play Games on PC is nearing general availability, offering automatic keyboard-to-touch translation for existing games and optional native mouse support (via a manifest flag) for an enhanced PC experience.

Navigating the future with Jetpack Navigation 3 — Core Concepts

Jetpack Navigation 3 is now in Alpha, offering a new state-based approach specifically designed to align with Jetpack Compose’s declarative nature.

Key newsworthy points for Android app developers:

Decoupled Logic: It provides a strong separation between navigation logic and UI, improving testability and flexibility.
State as Single Source of Truth: Advocates for your app’s state (including navigation) as the single source of truth, moving away from event-based navigation issues.
Developer-Owned Backstack: Developers now own the backstack state, giving more control and simplifying complex scenarios like type-safety across modules and multi-pane layouts.
Flexible Building Blocks: Provides building blocks that integrate better with Compose’s patterns, allowing a more robust and developer-controlled navigation solution.

Developers are encouraged to explore the Alpha and provide feedback.

Compose Preview | Jetpack Compose Tips

Compose Previews in Android Studio significantly accelerate UI development by allowing you to test Jetpack Compose UI changes instantly without full builds.

Key features include:

Interactive Mode for real-time UI interaction.
Animation Preview for fine-tuning animations.
UI Check Mode for critical accessibility analysis (contrast, speakable text).
Run Preview to deploy specific previews to a device/emulator without a full app build.

Crucial best practices include:

Avoiding direct ViewModel instantiation in previews.
Using @PreviewParameter for efficient data provision.
Creating a “sticker sheet” with multiple @Preview annotations for visual component documentation and faster team onboarding.

Embedded Layout Inspector | Jetpack Compose Tips

The Embedded Layout Inspector in Android Studio is a crucial tool for debugging Jetpack Compose UIs, allowing you to inspect layout hierarchy. It’s accessed via the Running Devices Tool Window while your app is running.

Build a Runtime-Enabled SDK

Android 14 introduced SDK Runtime, a new technology enhancing privacy and security by isolating third-party SDKs (called Runtime-enabled SDKs or RE SDKs) in a secure sandbox. Apps/SDKs (called Runtime-aware SDKs or RA SDKs) interact with these RE SDKs via automatically generated “shims,” with backward compatibility provided by Jetpack.

For SDK developers, building an RE SDK requires significant changes: a specific project structure using Android SDK Bundles (ASB), new Gradle configurations (including Privacy Sandbox plugins and specialized Jetpack dependencies), and declaring APIs with new annotations (@PrivacySandboxService, @PrivacySandboxInterface). Special considerations apply for UI and launching activities, and a specific entry point must be implemented. This marks a fundamental shift in how SDKs will be built and integrated on Android.

Google Play PolicyBytes — July 2025 policy updates

Key Takeaways:

Body Sensor Permissions are Evolving: Starting with Android 16, Google is replacing broad body sensor permissions with new, specific, privacy-focused ones (e.g., android.permission.health.READ_HEART_RATE). Apps accessing sensitive health data (heart rate, oxygen, skin temp) will need to adapt to these new permissions, requiring approved, user-benefiting use cases.
Blockchain/Crypto Apps — Country-Specific Rules: A new Help Center article provides country-specific requirements for apps offering blockchain content (crypto exchanges/wallets). Developers in this space should be aware of potential location-specific forms.
AI-Generated Content Best Practices: New guidance is available on best practices for apps that include AI-generated content, focusing on protecting users and apps.
Content Ratings & Ads: Content ratings only reflect your app’s internal content, not ads. Ensure ad content displayed within your app is not significantly more mature than your app’s content rating.
Upcoming Deadlines: Remember to review 2025 deadlines for various policies, including Photo/Video Permissions, Lines of Credit, News/Magazines, and Health Content & Services.

Policy announcement: July 10, 2025

Attention Personal Loan developers targeting Pakistan!

Google Play has updated its policy for personal loan apps targeting Pakistan: Apps promoting short-term personal loans (repayment within 60 days or less) are now generally prohibited. If you have such apps, make sure to review your compliance.

Blockchain-based content policy help center

For Android apps dealing with blockchain content (like crypto exchanges or software wallets), Google Play now provides a Blockchain-based Content Policy Help Center. This resource details country-specific compliance requirements, including potential location-specific forms. If your app targets a location not explicitly listed, you must declare it as a crypto exchange or software wallet in the Financial Features declaration. See goo.gle/blockchain-policy for full details.

Broadening audiences through expansions (Playtime 2024)

Facing declining mobile gaming growth in 2023, Google Play highlights ‘genre expansion’ as a crucial strategy for developers. This involves integrating gameplay, monetization, or aesthetics across genres to acquire broader audiences, deepen engagement, and boost monetization (e.g., 4X games adding casual mini-games). You should focus on early UA testing, understanding player motivations, ensuring seamless integration, and utilizing Play Console tools like store listing experiments and staged rollouts for effective iteration.

Unlock the full potential of your game with Vulkan and ADPF

Google’s Android team highlights Vulkan and the Adaptive Performance Framework (ADPF) as crucial for modern Android game development. Vulkan is an advanced graphics API offering increased efficiency and access to advanced GPU features, enabling you to maximize your games’ potential on contemporary hardware.

AndroidX Releases 🚀

Here’s a summary of the recent AndroidX changes:

Critical Bug Fixes & Stability Improvements:

Paging (3.4.0-alpha01): Several critical bugs affecting UI stability and data loading have been fixed:

Resolved IndexOutOfBoundsException when scrolling while updating RecyclerView.
Fixed issues preventing more loads from triggering when refreshing while scrolling.
Addressed crashes occurring when scrolling while refreshing Paging items.

Room (2.8.0-alpha01): Fixed a deadlock that could occasionally occur when using suspending transactions with the AndroidSQLiteDriver.

Significant New Features & API Enhancements:

WebKit (1.15.0-alpha01): Major enhancements for WebView control:

HTTP Header Control: A new API (Profile.setOriginMatchedHeader) to set HTTP header name-value pairs on requests to specific origins within WebViews and service workers.
Improved Cookie Handling: Developers can now include Cookie headers in WebResourceRequest.getRequestHeaders() and process Set-Cookie values from WebResourceResponseCompat.setCookies within shouldInterceptRequest callbacks. This greatly improves control over cookie management in intercepted WebView requests.
Renderer Warm-up: An experimental API to warm up the WebView renderer process for a Profile, improving performance for complex WebView lifecycles.

Room (2.8.0-alpha01): Introduced androidx.room:room-sqlite-wrapper and the RoomDatabase.getSupportWrapper() extension function. This allows developers adopting SQLiteDriver to still obtain a SupportSQLiteDatabase wrapper, easing incremental migration for codebases that have extensive SupportSQLite API usages.

Expanded Kotlin Multiplatform (KMP) Support (Medium Priority, High for KMP Developers):

Paging (3.4.0-alpha01): Adds more KMP targets, including watchos, tvos, mingwX64, watchosDeviceArm64, and linuxArm64.
Room (2.8.0-alpha01) & SQLite (2.6.0-alpha01): Both libraries now add KMP targets for Watch OS and TV OS.

Wear OS Specific Updates (Medium Priority, High for Wear Developers):

Wear Remote Interactions (1.2.0-alpha01): RemoteActivityHelper.startRemoteActivity now uses a new public Wear SDK API (Wear 6+) when available.
Watch Face Push (1.0.0-alpha01): The watchfacepush library introduces an API that allows a Wear OS app to programmatically install a watch face on a watch.

Other Notable Changes (Lower Priority for general app development, but important for specific use cases):

SQLite (2.6.0-alpha01): Adds an API (SQLiteConnection.hasActiveTransaction()) to check if a SQLiteConnection has an active transaction, which can aid in managing complex transaction logic.
Test UI Automator (1.0.0-alpha01): A new uiautomator-shell library allows executing shell commands as a shell user, backporting UiAutomation#executeShellCommandRwe (from API 34) for testing and instrumentation purposes.

Android Developers Backstage

The Android Developers Backstage podcast is back with two more episodes.

Bot to the future: Two years later

AI-powered Gemini features in Android Studio have significantly evolved, offering comprehensive developer support from design to maintenance. Key advancements include intelligent code completion, design tool integrations (e.g., composable previews), and unit test scenario generation.

Newsworthy features:

Version Upgrade Assistant: Automates dependency updates and fixes compilation errors, reducing developer “toil.”
Agent Mode (public preview): Allows Gemini to directly modify code within the IDE based on instructions, with developer approval required for changes.
Privacy: Gemini operates within the IDE, keeping code private without external transmission for model training, with enhanced privacy options for businesses.

Back it up, bring it back: No data left behind

Android Studio now automates app data backup and restore testing, eliminating cumbersome manual ADB commands. This significantly simplifies validating your app’s data persistence (settings, game states, permissions) across devices and emulators. Developers can configure backup scope via the manifest, differentiating between cloud (25MB) and device-to-device (1–2GB) transfers. Customization of backup descriptors is possible for complex scenarios, though sensitive data is excluded for security. This new tooling streamlines testing for reliable data transfer and a seamless user experience.

Now then… 👋

That’s it for this edition of Now in Android, including the Android platform Canary Channel, the first release of Agentic AI in Android Studio, Play updates including 16 KB Page Size requirements and other policy changes, new capabilities around one-time purchases, Play Games Services v2, and Google Play Games on PC, I/O recaps on AI and dev productivity, next gen Samsung devices running Android 16, and Compose tips.

Check back soon for your next update from the Android developer universe!

$\"\"$

Now in Android #120 was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/76eb908b9a8c","Now in Android #120",{"_2445":21},{"_8":2480,"_30":2481,"_2456":2457,"_2458":2482,"_2445":13,"_2460":2483,"_36":2484,"_2463":2485},763,"2025-07-23T05:02:36+00:00","

Flutter development just got a lot smarter in Firebase Studio! At I/O Connect India, we unveiled new AI-powered features designed to give you a more automated and productive workflow. In this post, we’ll dive into the new AI enhancements specifically for Flutter in Firebase Studio, and show you how you can use them to build powerful applications like the demo we showcased on stage.

Upgraded AI-optimized Flutter template

The Flutter template in Firebase Studio received a significant upgrade. With its new AI capabilities, you can optimize your workspace for an AI-first experience. For example, when building the I/O Connect India demo with this new template, Firebase Studio generated a multi-screen, e-commerce app complete with state management, Firebase authentication, products, a cart, and checkout. The AI-optimized template defaults to autonomous Agent mode, allowing Gemini to make changes directly without waiting for approval. We’ve also incorporated rules for Gemini into an (automatically generated) airules.md file to further refine the code Gemini generates, enabling you to add features or generate an entire Flutter app in a more streamlined flow.

\"\" — The Flutter template in Firebase Studio has been upgraded for an AI-first experience

Autonomously make changes

Previously, when working on a Flutter project in Firebase Studio, you would manually approve each code change in Agent mode. This workflow has evolved significantly and can make edits autonomously (independently and automatically). With the new Agent (Auto-run) mode, Gemini can now autonomously make changes, generate entire apps, and add features in a streamlined flow. For instance, when developing an app similar to our I/O Connect India demo, you can use Agent (Auto-run) mode to seamlessly integrate Firebase backend services and implement complex navigation patterns in a single interaction. Given Gemini’s robust support for Dart and Flutter, this autonomous mode keeps you in the development flow. And if a change isn’t exactly what you intended, rest assured that Firebase Studio leverages Git, allowing you to quickly revert your changes to a previous commit.

\"\" — Agent (Auto-run) mode with a Flutter project in Firebase Studio

AI rules

With the upgraded Flutter template, we’ve incorporated AI instructions into a new file: airules.md. This file (located at the root of your project), contains explicit rules for Gemini to follow as it generates code, enhancing the quality and relevance of the output. You have the flexibility to either use the default AI rules or customize them to fit your project’s specific needs. While there are numerous rules, here are a few examples:

Act as a Flutter co-developer
Writes unit tests
Proactively look for and fix errors
Choose which themes, tools, extensions, and startup commands to use
Add and remove Flutter packages
Adhere to Flutter and Dart best practices for code quality
Set up complex navigation

\"\" — Overview of the default Flutter AI rules (airules.md) in Firebase Studio

Compatible with Dart MCP Server

Firebase Studio now includes foundational support for the Model Context Protocol (MCP), and we’re excited to share that it works with our Dart MCP Server. When integrated within Firebase Studio, the Dart MCP Server empowers Gemini in Firebase Studio to analyze and automatically fix Dart and Flutter-specific errors in your project’s code. You can also efficiently search pub.dev for optimal packages, manage dependencies in pubspec.yaml, run tests, and much more. For example, when building a Flutter app similar to the one we demoed on stage at I/O Connect India, Gemini should identify and autonomously correct both static and runtime errors. Currently, Dart MCP Server is in beta.

To learn how you can use the Dart MCP Server while building your Flutter app in Firebase Studio, see the Supercharge Your Dart & Flutter Development Experience with the Dart MCP Server blog post.

\"\" — Dart MCP Server configuration for a Flutter app in Firebase Studio

Build with us

We have ambitious plans for the continued integration of Firebase Studio with Flutter, and we’re eager to hear your feedback on using Flutter in Firebase Studio as you explore these new capabilities. We’re incredibly excited to see what you create!

$\"\"$

Unleash new AI capabilities for Flutter in Firebase Studio was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/9a8c94564635","Unleash new AI capabilities for Flutter in Firebase Studio",{"_2445":13},{"_8":2487,"_30":2488,"_2456":2457,"_2458":2489,"_2445":13,"_2460":2490,"_36":2491,"_2463":2492},764,"2025-07-23T05:02:33+00:00","

By Ander Dobo — Product Manager, and Kenzie Davisson — Engineer

The landscape of AI development is rapidly evolving, with powerful agents capable of assisting developers across a myriad of tasks. To truly unlock their potential, these agents need to access context and tools beyond their inherent capabilities. This is where the Model Context Protocol (MCP) comes in, acting as a standardized plugin system that connects AI models to external systems and data sources. The Dart MCP Server is our implementation of this standard for the Dart and Flutter ecosystem.

This article explores how you can leverage the Dart MCP Server to enhance your Dart and Flutter development experience. We’ll cover useful tools provided by the Dart MCP Server and show how you can configure the server for use in popular tools like the Gemini CLI, Gemini Code Assist in VS Code, Cursor, and GitHub Copilot in VS Code.

This approach is part of a rapidly growing ecosystem. For instance, the Firebase team recently announced their own experimental Firebase MCP Server, which gives AI assistants tools to manage Firebase Authentication, query a Firestore database, and understand the types of application crashes impacting your application in production.

Introducing the Dart MCP Server

The Dart MCP Server (which requires the Dart SDK 3.9/Flutter 3.35 beta or later) is a powerful tool that bridges the gap between AI coding assistants and the Dart/Flutter development ecosystem. It allows AI models to interact with your development environment and your running Dart or Flutter application, providing intelligent insights, and using tooling normally only accessible from your IDE or from Dart & Flutter DevTools.

What can the Dart MCP Server do for you?

The Dart MCP Server provides a growing list of tools that grant AI assistants deep insights into your project. It can:

Analyze and fix errors in your project’s code.
Introspect and interact with your running application (such as trigger a hot reload, get the selected widget, fetch runtime errors).
Search pub.dev for the best package for your use case.
Manage package dependencies in your pubspec.yaml.
Run tests and analyze the results.
…and more!

See the official documentation for the most up-to-date list of tools.

The Dart MCP Server in action

The true power of the Dart MCP Server is how it enables AI assistants and agents to not only reason about your project’s context, but take action with tools. The Large Language Model (LLM) decides what tools to use and when, so you can focus on describing your goal in natural language. Let’s see this in action with a couple of examples using GitHub Copilot’s Agent mode in VS Code.

Fixing a runtime layout error

We’ve all been there: you build a beautiful UI, run the app, and are greeted by the infamous yellow-and-black stripes of a RenderFlex overflow error. Instead of manually debugging the widget tree, you can now ask your AI assistant for help.

Prompt: “Check for and fix static and runtime analysis issues. Check for and fix any layout issues.” (Note: For brevity, parts of this recording have been sped up.)

Behind the scenes, the AI agent uses the Dart MCP Server’s tools to:

See the error: It uses a tool to get the current runtime errors from the running application.
Inspect the UI: It accesses the Flutter widget tree to understand the layout that is causing the overflow.
Applies a fix: Armed with this context, it applies a fix and checks once more for any remaining errors.

You can then keep or undo the code changes.

Adding new functionality with package search

Imagine you need to add a chart to your app. Which package should you use? How do you add it and write the boilerplate? The Dart MCP Server streamlines this entire process.

Prompt: “Find a suitable package to add a line chart that maps the number of button presses over time.” (Note: For brevity, parts of this recording have been sped up.)

The AI agent now acts as a true assistant:

Find the right tool: It uses the pub_dev_search tool to find popular and highly-rated charting libraries.
Manage dependencies: After you confirm its choice (for example, syncfusion_flutter_charts), it uses a tool to add the package to your pubspec.yaml and runs pub get.
Generate the code: It generates the new widget code, complete with boilerplate for a line chart that it places in the UI. It even self-corrects syntax errors introduced during the process. You can customize further from there.

What used to be a multi-step process of research, reading documentation, editing pubspec.yaml, and writing the appropriate code in your app, is now a single request.

Configuring with popular AI development tools

Since the Model Context Protocol is rapidly becoming the standard for integrating toolchains and LLMs, there is an ever-growing list of tools that can use MCP servers. The Dart MCP Server can be integrated with any MCP client*. Check out the MCP user guide for a list of example clients.

First, the Dart MCP Server requires Dart SDK 3.9/Flutter 3.35 beta or later, so switch to the beta channel and run flutter upgrade to ensure you have the latest versions.

*To access all the features of the Dart MCP Server, an MCP client must support Tools and Resources. For the best development experience with the Dart MCP Server, an MCP client should also support Roots.

Gemini CLI

The Gemini CLI is an open-source AI agent that brings the power of Gemini directly into your terminal, providing a direct path from your prompt to the model. While it excels at coding, the Gemini CLI is a versatile, local utility that you can use for a wide range of tasks, from content generation and problem solving to deep research and task management.

Follow the quickstart instructions to install the Gemini CLI on your machine.

Ensure your environment is running Dart SDK 3.9/Flutter 3.35 beta or later. Switch channels and run flutter upgrade if you need to.

To configure the Gemini CLI to use the Dart MCP Server, edit the .gemini/settings.json file in your local project (this only enables the server for this project) or edit the global ~/.gemini/settings.json file in your home directory (this enables the server for all projects).

{
  "mcpServers": {
    "dart": {
      "command": "dart",
      "args": [
        "mcp-server",
        "--experimental-mcp-server"
      ]
    }
  }
}

Pro tips:

If you prompt the Gemini CLI with /mcp, you will be able to see the set of MCP tools available for use.
If your project has specific guidelines or rules that you’d like the LLM to be aware of, you can document those by adding a GEMINI.md file to the root of your project.

Gemini Code Assist

Note: this currently requires the Gemini Code Assist “Insiders” channel. Follow the Gemini Code Assist instructions to enable the Insiders build.

The underlying technology of the Gemini CLI has also been integrated into Gemini Code Assist in VS Code, a powerful AI assistant providing chat and agent capabilities directly in your IDE. In Agent mode, you can write a prompt in the chat window and watch as Gemini goes to work to meet your request. Follow the set up guide to get started with Gemini Code Assist.

Ensure your environment is running Dart SDK 3.9/Flutter 3.35 beta or later. Switch channels and run flutter upgrade if you need to.

To configure Gemini Code Assist to use the Dart MCP Server, use the following instructions:

Install and configure the Gemini CLI first.
Follow the same instructions as those above to configure the Gemini CLI to use the Dart MCP Server, which also enables it for Gemini Code Assist.

You can verify the MCP server has been configured properly by entering /mcp in the chat window in Agent mode.

Firebase Studio

Firebase Studio is an agentic, cloud-based development environment that helps you build and ship production-quality full-stack AI apps, including APIs, backends, frontends, mobile, and more.

To add an MCP server in Firebase Studio

Create a .idx/mcp.json file in your project (if it doesn’t exist already) and add the same Dart MCP Server configuration to the file, as with Gemini CLI instructions above,
Ensure your environment is running Dart SDK 3.9/Flutter 3.35 beta or later. Switch channels and run flutter upgrade if you need to.
Rebuild your workspace to complete setup by opening the Command Palette (Shift+Ctrl+P) and entering Firebase Studio: Rebuild Environment.

For more information about MCP server configuration in Firebase Studio, see Customize your Firebase Studio workspace.

GitHub Copilot in VS Code

GitHub Copilot is an AI-powered coding assistant integrated into VS Code. The Dart VS Code extension provides a simple integration for Copilot by registering the Dart MCP Server with VS Code. Copilot, or any other AI agent that supports the VS Code MCP API, automatically configures the Dart MCP Server on your behalf so that you don’t have to do it manually.

Ensure your environment is running Dart SDK 3.9/Flutter 3.35 beta or later. Switch channels and run flutter upgrade if you need to.

To configure the Dart MCP Server, add the following to your VS Code user settings:

"dart.mcpServer": true

You might also consider adding"chat.mcp.discovery.enabled": true to your VS Code user settings to automatically discover servers configured in other tools like Claude Desktop or Cursor.

Cursor

Cursor is a popular AI-powered code editor based on VS Code. The Dart and Flutter VS Code extensions can be installed in Cursor to provide a similar development experience to what you’d expect in VS Code, with additional AI-centric features provided by Cursor.

Ensure that your environment is running Dart SDK 3.9/Flutter 3.35 beta or later. Switch channels and run flutter upgrade if you need to.

To configure Cursor to use the Dart MCP Server, you can either click the Add to Cursor button in the Dart MCP Server README file (easiest method), or follow the instructions to install MCP servers from the official Cursor documentation. After configuring the Dart MCP Server, you should end up with the following in your .cursor/mcp.json file, which can either be a project file or a global file depending on where you want the MCP server to be enabled:

{
  "mcpServers": {
    "dart": {
      "command": "dart",
      "args": [
        "mcp-server",
        "--experimental-mcp-server", // Can be removed for Dart 3.9.0 or later
        "--force-roots-fallback" // Workaround for a Cursor issue with Roots support
      ]
    }
  }
}

Other tools

The Dart MCP Server can be used anywhere that MCP is supported*. Follow the instructions provided by your MCP client of choice to configure the Dart MCP Server.

*Not all tools are supported since some require access to specific IDE services.

What’s coming next?

This experimental release is just the first step. Our vision is to enable Dart and Flutter developers to reach peak productivity with AI-driven experiences that meet you where you work. Here are some of the key areas we’re investing in next:

Deeper, seamless IDE integration: We’re working closely with the teams behind Firebase Studio, Gemini in Android Studio, Gemini Code Assist, and others to make using the Dart MCP Server effortless.
AI-powered DevTools features: We plan to bring AI-assistance directly into Dart and Flutter DevTools. Instead of manually sifting through complex data, you could simply ask your AI assistant questions like, “Why did my app stutter here?” while looking at a timeline trace, “What’s causing this memory leak?” when inspecting a memory snapshot, or even “Help me fix this layout issue” directly from the Flutter Inspector.
An ever-growing toolbox: We will continue to expand the MCP server’s capabilities, for example by supporting more complex refactorings.

While our roadmap is guided by our vision, your feedback is critical in helping us prioritize what matters most to you.

In conclusion

By giving your coding assistant the context of your project and access to the official toolchain, you can move faster, solve problems more efficiently, and focus on what matters most: building beautiful, high-quality applications. The Dart MCP Server represents a significant leap forward in AI-powered development for Dart and Flutter, and is a continuation of our team’s dedication to delivering a productive developer experience.

This is just the beginning. As the Model Context Protocol becomes more widespread and the Dart MCP Server gains more capabilities, the collaboration between you and your AI-powered development tools and agents will only get smarter and more seamless.

This feature is still experimental, and your feedback is invaluable. Try it out today by enabling it in your favorite editor, and let us know what you think by filing an issue on our GitHub repository. Embrace the future of AI-assisted development and unlock new levels of productivity in your Dart and Flutter projects. We can’t wait to see what you build!

$\"\"$

Supercharge Your Dart & Flutter Development Experience with the Dart MCP Server was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/2edcc8107b49","Supercharge Your Dart & Flutter Development Experience with the Dart MCP Server",{"_2445":13},{"_8":2494,"_30":2495,"_2456":2457,"_2458":2496,"_2445":21,"_2460":2497,"_36":2498,"_2463":2499},762,"2025-07-09T17:02:38+00:00","

Android 16, Desktop Experiences, Adaptive Apps, Testing Videos, AndroidX and more!

Welcome to Now in Android, your ongoing guide to what’s new and notable in the world of Android development. In this edition we will cover Android 16, Desktop Experiences, Adaptive Apps, Testing Videos, AndroidX and more!

Most of the content of this post is available in the form of a video or podcast, so feel free to watch or listen rather than read on. (Or do all three to help you remember! There won’t be a quiz.)

Android 16 is here 🤖

Android 16 is released and available on supported Pixel devices, with new devices to follow. The source code is available at the Android Open Source Project.

Key updates include:

Enhanced camera and media APIs for pro users, with night mode scene detection, hybrid auto exposure and precise color temperature adjustments. Improved UltraHDR image support with HEIC encoding and an embedded photo picker.
Apps targeting Android 16 can no longer opt-out of going edge-to-edge
Changes to how the system manages orientation, resizability, and aspect ratio restrictions.
System animations for back-to-home, cross-task, and cross-activity by default. In addition, this release extends predictive back navigation to three-button navigation, meaning that users long-pressing the back button will see a glimpse of the previous screen before navigating back.
Progress style notifications which lets you create progress-centric notifications that can denote states and milestones in a user journey using points and segments.
RuntimeColorFilter and RuntimeXfermode, allowing you to author complex effects like Threshold, Sepia, and Hue Saturation in AGSL and apply them to draw calls.

Android 16 is here

Top 3 updates for building excellent, adaptive apps at Google I/O ’25 🤖

At Google I/O 2025, several advancements were announced for Android, including the rollout of Android 16, a Developer Preview for enhanced Android desktop experiences, and updates for Android users across Google apps.

Key announcements for developers:

Adaptive apps: Build a single, adaptive application that functions across various form factors using Jetpack Compose Adaptive Libraries, Navigation 3 library, and updates to the Window Manager Library in AndroidX.window 1.5.
Performance Optimization: Use the redesigned UiAutomator API for benchmarking, macrobenchmarks and App Startup Insights to improve app performance, and leverage R8 for troubleshooting and performance optimization.
Enhanced Media Experiences: Use CameraX and Media3Effects for capturing high-quality video and Google Low-Light Boost for real-time camera brightness adjustment in low light. Explore new camera and media samples.

Top 3 updates for building excellent, adaptive apps at Google I/O '25

Developer preview: Enhanced Android desktop experiences with connected displays 🖥️

With the Android 16 QPR1 Beta 2 release, you can now access connected displays support on compatible Android devices. By connecting an external display to your Android device, you can transform it into a workstation. This gives users the ability to move apps beyond a single screen to unlock Android’s full productivity potential on external displays.

Desktop windowing is now stable as well. We’ve made improvements in the stability and performance of desktop windowing in Android 16 and added some new features:

Flexible window tiling: Users can more easily arrange multiple app windows side by side or in various configurations, making it simpler to work across different applications simultaneously on a large screen.
Multiple desktops: Users can set up multiple desktop sessions to match their distinct productivity requirements and switch between the desktops using keyboard shortcuts, trackpad gestures, and Overview.
Enhanced app compatibility treatments: New compatibility treatments ensure that even legacy apps behave more predictably and look better on external displays by default.
Multi-instance management: Users can manage multiple instances of supporting applications (for example, Chrome or, Keep) through the app header button or taskbar context menu.
Desktop persistence: Android can now better maintain window sizes, positions, and states across different desktops.

You can try out these features today on your connected display with the Android 16 QPR1 Beta 2 on select Pixel devices.

Developer preview: Enhanced Android desktop experiences with connected displays

A product manager’s guide to adapting Android apps across devices 📱

In Android 16, adaptive apps are essential to provide a consistent user experience across various devices. Product managers should prioritize adaptive design for your apps to meet user expectations on foldables, tablets, Chromebooks, and other form factors.

By building adaptive apps, you can improve user engagement, increase app discoverability on Google Play, and ensure accessibility for users with disabilities. You can start by checking how your app currently looks on large screens, addressing common UI issues, and incrementally optimizing your app screen by screen.

A product manager's guide to adapting Android apps across devices

Videos

We have a few new testing videos for you to check out!

Android Testing Strategies

Automated testing is crucial for scalable and efficient quality assurance as apps grow in complexity. However, the traditional testing pyramid might not be the best approach. Learn more about using a strategy that considers both the scope (test size) and the size (code executed) of different test categories: release candidate, application, feature, component, and unit tests. This helps ensure reliable results and faster execution times.

Goodbye manual testing, hello automated testing

Android app developers should embrace automated testing (unit, smoke, hermetic, screenshot) to replace time-consuming and error-prone manual testing. Learn more about how automation improves app quality, provides fast feedback, catches bugs, and prevents feature regressions, ultimately increasing developer productivity and freeing up time for critical tasks.

Tools and patterns for scalable Android app testing

Android app developers should be aware of the tools and patterns used in scalable app testing: Learn more about using screenshot tests, robolectric, device emulation, management for flaky tests, and gradle managed devices in this video.

AndroidX Releases 🚀

Here’s a summary of the AndroidX changes, prioritized for app developers:

New PhotoPicker Library: This is a major addition, providing a straightforward way to integrate with the system’s embedded photo picker. It includes both View-based and Compose-based components, along with utilities for state management and testing. This simplifies image selection for users and improves the user experience.
Lifecycle ViewModel Navigation3 Integration: This new library offers better integration between ViewModels and the Navigation3 library. The key component is ViewModelStoreNavEntryDecorator, which ensures each NavEntry has its own ViewModelStoreOwner. This helps to properly scope and manage ViewModels within your navigation graph, especially when using config changes.
Emoji2 Library Update: The update to emoji2 includes updates to emoji 16.0 and uses JSpecify nullness annotations which require Kotlin developers to use specific compiler arguments to enforce correct usage: -Xjspecify-annotations=strict, -Xtype-enhancement-improvements-strict-mode.

Now then… 👋

That’s it for this week’s episode, with Android 16, Desktop Experiences, Adaptive Apps, Testing, AndroidX and more!

Check back soon for your next update from the Android developer universe!

$\"\"$

Now in Android #119 was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/7b86ad2b3e81","Now in Android #119",{"_2445":21},{"_8":2501,"_30":2502,"_2456":2457,"_2458":2503,"_2445":21,"_2460":2504,"_36":2505,"_2463":2506},761,"2025-06-18T17:01:42+00:00","

Now in Android #118 — Google I/O 2025 Part II

Compose, Camera and Media, Accessibility ,KMP, Tools, Maps, AndroidX, Google Home, integrating the web, Google Play, and more

Welcome to part two of a special Google I/O 2025 edition of Now in Android, your ongoing guide to what’s new and notable in Android development.

This second edition covers the latest from Jetpack Compose, Camera and Media, Accessibility ,Kotlin Multiplatform, Android development tools, Google Maps, AndroidX, Google Home with Gemini, integrating web functionality, Google Play, and more.

Part one included coverage of Material Expressive, watches, cars, tablets, laptops, connected displays, the latest in adaptive app development, XR development, taking advantage of on-device and cloud based AI, and Android 16.

Now in Android: 118 - What's new in Android development at Google I/O 2025 (part 2)

Most of the content of this post is available in the form of a video or podcast, so feel free to watch or listen rather than read on. (Or do all three to help you remember! There won’t be a quiz.)

Jetpack Compose 💻

Jetpack Compose introduced new features, including autofill support, auto-sizing text, visibility tracking, the animate bounds modifier, and accessibility checks in tests, and that’s just the beginning of what’s new:

animateBounds provides automatic animations of a Composable’s position and size within a LookaheadScope, while visibility tracking is used when you need high-performance information on a composable’s position in its root container, screen, or window.
For more on autofill, autosize, and the new state based TextField, check out the “Mastering text input in Compose” talk.

Navigation 3 is a brand new, Compose-first navigation library, now in alpha that’s designed to give you greater control while simplifying building complex navigation flows.

Announcing Jetpack Navigation 3

Compose support for CameraX and Media3 makes it easier to integrate camera capture and video playback into your UI.
Android Studio tools have been improved for creating Compose UIs. The latest Narwhal canary includes resizable previews, preview navigation improvements, and Gemini integration for Compose preview generation and UI transformation.
The “Accessible UIs with Jetpack Compose” talk covers how Compose facilitates accessibility and how you can use it to build apps that are usable by everyone.

Read about What’s new in Jetpack Compose or watch the talk.

What's New in Jetpack Compose

CameraX and Media3 🎬

The “Seamless video capture, editing and playback with CameraX and Media3” session covers how you can use CameraX and Media3 together with LiteRT to create video capture, sharing, and editing apps with custom effects.

CameraX simplifies camera integration (preview, capture, analysis), while Media3 Transformer handles video editing and transcoding. Media3 ExoPlayer provides flexible video playback options.

In the “Building delightful Android camera and media experiences” blog, the Android Developer Relations Camera & Media team shared learnings from creating sample media code and demos, including:

Jetpack Media3 Transformer APIs to arrange input video sequences into different layouts using a custom video compositor.
Jetpack Compose: Migrate your app to Jetpack Compose and use the supporting pane adaptive layout, so the UI dynamically adapts to the screen size.
CameraX’s Media3 effect integration allows you to easily add filters and effects. You can define your own effects by implementing the GlEffect interface.
Media3 can be used with AI to analyze video content and extract meaningful information. You can convert textual information derived from the video into spoken audio, enhancing accessibility.
Oboe Audio API: Starting in Android 16, the new audio PCM Offload mode reduces the power consumption of audio playback in your app.

Building delightful Android camera and media experiences

Androidify: AI-driven experiences with Jetpack Compose, Gemini and CameraX 🤖

The Androidify app is an open-source project showcasing how to build AI-driven Android experiences, using Jetpack Compose, Gemini, CameraX, and Navigation 3.

The first article, “Androidify: Building powerful AI-driven experiences with Jetpack Compose, Gemini and CameraX” is a thorough introduction into how the app was architected, tested, and how many of the features were created.

The app uses the Gemini API through the Firebase AI Logic SDK to access Imagen and Gemini models. It uses Gemini models for image validation, text prompt validation, image captioning, a “help me write” feature, and image generation from the generated prompt. The UI is built with Jetpack Compose, and it adapts to different devices using WindowSizeClass. CameraX is integrated for photos, and Media3 APIs are used to load an instructional video. Screen transitions are handled using the new Jetpack Navigation 3 library.

Androidify: Building powerful AI-driven experiences with Jetpack Compose, Gemini and CameraX

The “Android Developers Blog: Androidify: Building delightful UIs with Compose” post focuses on how the user experience was built using Material 3 expressive with the MaterialExpressiveTheme and MotionScheme.expressive. The app uses the HorizontalFloatingToolbar for prompt type selection and MaterialShapes.

It leverages Jetpack Compose 1.8 to automatically adjust the font size of text composables, and uses the new onLayoutRectChanged to help make fun animation.

Androidify: Building delightful UIs with Compose

The “Androidify: How Androidify leverages Gemini, Firebase and ML Kit” post covers how Google AI is powering the new Androidify with Gemini AI models, Imagen, and the Firebase AI Logic SDK to enhance the app experience.

The app uses Gemini 2.5 Flash via Firebase to validate uploaded images, ensuring they contain a person who is in focus and that the image is safe. The app also uses Gemini 2.5 Flash with structured output to caption the image.

The detailed description of your image is used to enrich the prompt for image generation. A fine tuned version of the Imagen 3 model is called to create the bot.

The app uses the ML Kit Pose Detection API to detect when a person is in the camera view, triggering the capture button and adding visual indicators.

Androidify: How Androidify leverages Gemini, Firebase and ML Kit

Google I/O 2025: What’s new in Android development tools 🤖

The “What’s new in Android development tools” talk covered the Narwhal Feature Drop (2025.2.1) of Android Studio, bringing lots of new AI assistance features, Compose dev improvements, and more. Here are many of the highlights:

You can now access Gemini 2.5 Pro in Android Studio
Android Studio is getting a new Gemini-powered Version Upgrade Agent to automate upgrading dependencies.

Journeys in Android Studio lets you use natural language to describe actions and assertions for user journeys you want to test in your app, and Gemini performs the tests for you.

Gemini can automatically generate compose previews for you. The Compose preview has navigation improvements that let you jump to the preview definition or function. While in focus mode, you can resize the preview window to see how the UI adapts. You can also transform UI code in the preview using natural language, like “Center align these buttons.”
You can attach image files along with your prompt, such as UI mock-ups.
You can access the latest Android Studio AI features in stable release channels with AI features in Studio Labs.
The App Quality Insights panel now has crash insights that analyze your app’s source code, offering explanations and source code fixes.
The Android XR Emulator now launches by default in the embedded state, so you can deploy your application and navigate the 3D space directly inside Android Studio.
You can now also trigger app backups on connected devices directly from the Running Devices window.
Android Studio now offers warnings when building APKs or Android App Bundles that are incompatible with 16 KB page sized devices.
Also, when you sign in with your Google account or a JetBrains account, you can sync your customizations and preferences across all installs.
New Android Studio KMP project templates, updated Jetpack libraries, and new codelabs (Get Started with KMP and Migrate Existing Apps to Room KMP) have been released.
Android Studio Cloud is now available as an experimental public preview through Firebase Studio.
Android Studio will soon be able to offer richer insights and guidance on Google Play policies that might impact your app available in the form of lint checks.

Google I/O 2025: What's new in Android development tools

I/O 2025: What’s new in Google Play 📊

At Google I/O 2025 we highlighted new Play Console tools, updates to app discovery, changes to subscriptions, updates for games, and more:

Tools and APIs

Overview pages in the Play Console for “Test and release” and “Monitor and improve” bring together metrics, features, and contextual advice.
You will soon be able to halt fully-live releases through Play Console and the Publishing API.
The Play Integrity API has stronger abuse detection, device security update checks, and a public beta for device recall.
An asset library is available for uploading, editing, and viewing visual assets, and open metrics provide deeper insights into listing performance.
The Play Billing Library release 8 is planned to be available to integrate with at the end of June.

App discovery updates

New topic browse pages feature timely and relevant content, debuting in the US with Media & Entertainment.
“Where to Watch” is expanding to more markets to help users find and deep-link into subscribed apps for movies and TV.
Starting this July, everyone can now add a hero content carousel and a YouTube playlist carousel to their store listings.
Audio samples are launching on Apps Home for apps best experienced through sound.
Engage SDK content is coming to the Play Store this summer, with new content categories and Collections rolling out globally. Try the codelab!
You can learn more about how to grow your business on Google Play in the following talk:

Subscription updates

Multi-product checkout for subscriptions lets you sell subscription add-ons alongside base subscriptions.
Subscription benefits are showcased in more places across Play.
You can now choose a grace period or an account hold instead of immediate cancellation when payment methods decline.

Game updates

Play Games on PC has expanded support, with more native PC games coming alongside the Android game catalog, and an earnback up to 15%
Google Play Games Services is adding new features to boost player engagement, including bulk achievement creation via CSV upload and generative AI avatars for player profiles.

Check out the I/O talk or the blog post to learn more with more in-depth coverage.

I/O 2025: What's new in Google Play

Kotlin Multiplatform at Google I/O and KotlinConf 25 📱💻

At Google I/O and KotlinConf 2025, several Kotlin Multiplatform (KMP) updates were announced:

Kotlin Multiplatform Shared Module Template — Android Studio introduced a Kotlin Multiplatform Shared Module Template that is available when you create a new module in Android Studio, supporting Jetpack libraries like Room, SQLite, and DataStore.

Announcing Kotlin Multiplatform Shared Module Template

Demystify KMP builds and structure — Is an I/O talk that acts as a primer for Kotlin Multiplatform (KMP), covering how it enables sharing code across platforms (Android, iOS, web) resulting in faster feature delivery (e.g., StoneCo ships features 40% faster).

More Jetpack Libraries now have KMP support — Collection. ViewModel, SavedState, and Paging are now supported alongside Room, and DataStore.
Two new codelabs: “Getting started with Kotlin Multiplatform” and “Migrating your Room database to KMP” provide additional guidance for using KMP.

Also in Kotlin-related news:.

Android Studio now supports Kotlin K2 mode for Android-specific features.
Kotlin Symbol Processing (KSP2) is stable for better support of new Kotlin language features and performance.
Google Workspace is using KMP in production in the Google Docs app on iOS.
Google team members presented talks and live workshops at KotlinConf, covering topics such as deploying KMP at Google Workspace, the lifecycle of a Kotlin/Native object, APIs, Compose for Desktop, JSpecify, and decoupling Architecture Components.
In Kotlin Multiplatform: Have your code and eat it too 🎂 on Android Developers Backstage, Dustin Lam and Yigit Boyar joined host Tor Norbye to chat all about Kotlin Multiplatform (KMP), which allows you to write Kotlin code and run it just about anywhere. Learn about how to make sure your code is KMP ready, avoiding platform-specific assumptions.

You can read all of the KMP updates in the blog.

Android's Kotlin Multiplatform announcements at Google I/O and KotlinConf 25

Articles 📚

And those weren’t the only highlights from the I/O season worth talking about.

Announcing Jetpack Navigation 3 🧭

As mentioned in the Compose highlights, we announced Jetpack Navigation 3 (Nav3) a Compose-first navigation library that enables you to build scalable navigation experiences.

The Nav3 display observes changes to the developer-owned back stack.

With Nav3, you own the back stack, which is backed by Compose state. Nav3 provides building blocks and helpful defaults that you can use to create custom navigation behavior.

Key features:

Built-in transition animations and a flexible API for custom animations.
Contains Scenes, a flexible layout API that allows you to render multiple destinations in the same layout.
Enables state to be scoped to destinations on the back stack, including optional ViewModel support via a dedicated Jetpack lifecycle library.
Allows navigation code to be split across multiple modules.

You can navigate to the developer documentation and a recipes repository to get started.

Announcing Jetpack Navigation 3

Zoho Achieves 6x Faster Logins with Passkey and Credential Manager Integration 🔑

Zoho integrated passkeys and Android’s Credential Manager API into their OneAuth Android app. As a result, they achieved up to 6x faster logins and a 31% month-over-month growth in passkey adoption. Zoho’s implementation involved both client and server-side adjustments, including adapting their credential storage system and handling requests from Android devices. Based on their experience, consider leveraging Android’s Credential Manager API, optimizing error handling, educating users on passkey recovery, and monitoring adoption metrics as you implement passkeys in your apps.

Zoho Achieves 6x Faster Logins with Passkey and Credential Manager Integration

Android Studio Meerkat Feature Drop is stable 💻

The Android Studio Meerkat Feature Drop (2024.3.2) is now stable, offering features such as the Gemini Prompt Library, improved Kotlin Multiplatform (KMP) integration, and device management enhancements.

Key updates:

Gemini Integration: Use Gemini to analyze crash reports in App Quality Insights, generate unit test scenarios, and save/share prompts with the new Prompt Library.
Compose and UI Development: Preview themed icons and use improved zoom and collapsible groups in Compose previews.
Build and Deploy: Add shared logic with the KMP Shared Module template and use the updated Device Manager UX. Receive warnings for deprecated SDKs from the Google Play SDK Index. The Build menu has also been refined.
IntelliJ Platform Update: Includes the IntelliJ 2024.3 platform release with a feature complete K2 mode and debugger improvements.

Download the latest stable version of Android Studio to explore these features.

Android Studio Meerkat Feature Drop is stable

#WeArePlay: How My Lovely Planet is making environmental preservation fun through games 🌳

Clément, founder of Imagine Games, created My Lovely Planet, which combines mobile gaming with real-world action to make environmental preservation fun. In the game, planting a tree results in planting a real tree via partnerships with NGOs. According to Clément, 70% of the game’s players come through Google Play, and Google Play’s flexibility, responsiveness, and powerful testing tools improve their velocity when launching and scaling the game.

#WeArePlay: How My Lovely Planet is making environmental preservation fun through games

#WeArePlay | Google Play Console

Videos 📹

Android Accessibility Updates

“Android accessibility updates” highlights the latest Android key accessibility features and APIs, including updates to products such as Talkback and Live Captions, best practices for developing more accessible apps, and accessibility API changes in Android 16.

Key takeaways include:

Accessibility Test Framework: The accessibility test framework can identify potential issues and throw exceptions, failing tests. Developers can customize this behavior by providing their own accessibility validator instances, allowing them to configure severity levels for failures and suppress known issues.
Composable Previews in Android Studio: Android Studio’s composable previews can now render UI with accessibility features like dark theme, and various display and font sizes. This helps identify issues such as low contrast, non-scaling, or truncated text, and works with UI check mode to quickly identify common UI issues across different configurations.
Automated Checks: Automated accessibility checks accelerate the detection of various accessibility barriers and complement manual testing. Developers are strongly encouraged to test apps with Android’s assistive technologies to understand user experience.
API Changes and Best Practices: The video discusses changes in APIs and best practices related to vision, hearing, and dexterity. It emphasizes the importance of building a single adaptive mobile app that provides the best experiences across various Android surfaces and form factors.

Best practices for using web in your Android apps

“Best practices for using web in your Android apps” covers what you should do when embedding web content in your Android apps using WebView, Custom Tabs, and Trusted Web Activities (TWA). WebView allows inline display of web content with full customization, while Custom Tabs provide an in-app browsing experience powered by the user’s preferred browser (handling permissions, cookies, etc.). TWAs offer similar web features/APIs but are launched as a standard Android activity. The choice depends on the level of control and integration needed within your app.

Next-gen Android experiences with photorealistic 3D maps

“Next-gen Android experiences with photorealistic 3D maps “ introduces the new Kotlin-first Google Maps 3D SDK for Android, allowing you to create immersive map experiences with 3D capabilities. Topics covered include:

Map 3D View: The fundamental building block for 3D maps.
LatLngAltitude class: Used for precise positioning with altitude data.
Camera class: For controlling the camera’s position and view, including limiting camera views to specific areas.
Adding elements: You can add markers, 3D models, polygons, and polylines to highlight areas, define routes, or convey spatial information. Polygons are closed, filled shapes that can have holes, while polylines are not closed.

Google Home APIs, tools, and Gemini capabilities for your apps

Announcements include:

Camera Support in the Home API: Apps will soon be able to access Gemini camera feeds for intelligent notifications (person detection, package delivery).
Enhanced Automations: The Home API now supports suggested automations, and date/weather-based settings for greater customization.
Gemini Integration: You will be able to integrate devices with Gemini’s AI capabilities via Google Home.

Sign up for the Developer Newsletter to be among the first to explore these cutting-edge capabilities and to stay updated on the latest developments.

Bringing Gemini intelligence to Google Home APIs

AndroidX Releases 🚀

Here’s a summary of some of the most impactful AndroidX changes. Key takeaways:

Compose Navigation: The new Navigation3 library and its ViewModel integration are a significant shift for Compose-based apps, offering better control and lifecycle management.
Media Enhancements: The Media3 ExoPlayer updates are extensive, improving performance, stability, and adding requested features like scrubbing mode and partial downloads.
Passkey Improvements: Support for passkey conditional creation provides a more seamless user experience.

Navigation 3 related changes:

androidx.navigation3:navigation3: A new navigation library specifically designed for Jetpack Compose in-app navigation. It provides core building blocks (navigation3-runtime) and a UI layer via the NavDisplay API (navigation3-ui). You control navigation by updating the state passed to NavDisplay, making it a powerful tool for Compose-based apps.
androidx.lifecycle:lifecycle-viewmodel-navigation3: Integrates ViewModels with the new Navigation3 library. ViewModelStoreNavEntryDecorator gives each NavEntry its own ViewModelStoreOwner, ensuring ViewModels are scoped to the correct navigation destination. Crucial for managing UI state within Compose navigation.
androidx.navigationevent:navigationevent: Provides a KMP-first API for handling system back and Predictive Back. This library serves as a replacement for Activity APIs.
androidx.activity:activity-*:1.12.0-alpha01: Integrated with NavigationEvent 1.0.0-alpha01 via NavigationEventDispatcherOwner, allowing you to manage back navigation using NavigationEventDispatcher and NavigationEventCallback. Existing OnBackPressedDispatcher usages should continue working because it has been rewritten on top of the new library.

Media:

androidx.media3:media3-*:1.8.0-alpha01: Significant updates to ExoPlayer, including a new scrubbing mode for frequent seeks, improvements to audio timestamp smoothing, various bug fixes (memory leaks, subtitle issues), and partial download support for both progressive and adaptive streams. Also adds PreCacheHelper to allow apps to pre-cache a single media with specified start position and duration.

Car App Library:

androidx.car.app:app-*:1.8.0-alpha01: Adds a Media category for custom media apps, a Playback Template for controlling actions during media playback, and full support for Sectioned Item Template for complex layouts. Also introduces an extra-large grid item size.

App Functions:

androidx.appfunctions:appfunctions-* :`1.0.0-alpha01: New library to expose app functionality to the Assistant.

Credentials:

androidx.credentials:credentials-*: 1.6.0-alpha01 & androidx.credentials.providerevents:providerevents:1.0.0-alpha01: Supports Passkey conditional create, allowing passkeys to be created without requiring typical UI interaction from the user. Also added a new service, CredentialProviderEventsService, that credential providers can support to receive events from Credential Manager APIs.

Glance Widgets:

androidx.glance:glance-*:1.2.0-alpha01: Adds APIs for generated previews in Glance widgets and multiprocess configurations support. Adds a new API to specify alpha for the glance Image composable and the background image modifier.

Other Updates:

androidx.health:health-services-client:1.0.0: Stable release of the Health Services Client library for Wear OS 3 emulators and upcoming devices, with additional platforms supported in the future. Three top level API surfaces are included in this initial release: The ExerciseClient, PassiveMonitoringClient, and MeasureClient.
androidx.hilt:hilt-*:1.3.0-alpha01: Updates the library and annotation processor to target Kotlin 2.0 to support newer Kotlin toolchain including KSP2.
androidx.recyclerview:recyclerview-selection:1.2.0: Fixes for mouse drags and key/position mapping.

Android Developers Backstage

This was covered in the previous Kotlin Multiplatform section, but just in-case you missed it, Android Developers Backstage is back with another episode.

Kotlin Multiplatform: Have your code and eat it too 🎂

Dustin Lam and Yigit Boyar joined host Tor Norbye to chat all about Kotlin Multiplatform (KMP), which allows you to write Kotlin code and run it just about anywhere. Learn about how to make sure your code is KMP ready, avoiding platform-specific assumptions.

Now then… 👋

That’s it for part two of our I/O season coverage, with the latest around Jetpack Compose, Camera and Media, Accessibility ,Kotlin Multiplatform, Android development tools, Google Maps, AndroidX, Google Home with Gemini, integrating web functionality, Google Play, and more.

Check back soon for your next update from the Android developer universe!

$\"\"$

Now in Android #118 — Google I/O 2025 Part II was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/0176766c2061","Now in Android #118 — Google I/O 2025 Part II",{"_2445":21},{"_8":2508,"_30":2509,"_2456":2457,"_2458":2510,"_2445":21,"_2460":2511,"_36":2512,"_2463":2513},760,"2025-06-10T18:06:14+00:00","

Posted by Fahd Imtiaz, Product Manager, Android Developer Experience

This article is also shared on the Android Developers Blog

Today, Android is launching a few updates across the platform! This includes the start of Android 16’s rollout, with details for both developers and users, a Developer Preview for enhanced Android desktop experiences with connected displays, and updates for Android users across Google apps and more, plus the June Pixel Drop. We’re also recapping all the Google I/O updates for Android developers focused on building excellent, adaptive Android apps.

With new form factors emerging continually, the Android ecosystem is more dynamic than ever.

From phones and foldables to tablets, Chromebooks, TVs, cars, Wear and XR, Android users expect their apps to run seamlessly across an increasingly diverse range of form factors. Yet, many Android apps fall short of these expectations as they are built with UI constraints such as being locked to a single orientation or restricted in resizability.

With this in mind, Android 16 introduced API changes for apps targeting SDK level 36 to ignore orientation and resizability restrictions starting with large screen devices, shifting toward a unified model where adaptive apps are the norm. This is the moment to move ahead. Adaptive apps aren’t just the future of Android, they’re the expectation for your app to stand out across Android form factors.

Why you should prioritize adaptive now

Prioritizing optimizations to make your app adaptive isn’t just about keeping up with the orientation and resizability API changes in Android 16 for apps targeting SDK 36. Adaptive apps unlock tangible benefits across user experience, development efficiency, and market reach.

Mobile apps can now reach users on over 500 million active large screen devices: Mobile apps run on foldables, tablets, Chromebooks, and even compatible cars, with minimal changes. Android 16 will introduce significant advancements in desktop windowing for a true desktop-like experience on large screens, including connected displays. And Android XR opens a new dimension, allowing your existing apps to be available in immersive environments. The user expectation is clear: a consistent, high-quality experience that intelligently adapts to any screen — be it a foldable, a tablet with a keyboard, or a movable, resizable window on a Chromebook.
“The new baseline” with orientation and resizability API changes in Android 16: We believe mobile apps are undergoing a shift to have UI adapt responsively to any screen size, just like websites. Android 16 will ignore app-defined restrictions like fixed orientation (portrait-only) and non-resizable windows, beginning with large screens (smallest width of the device is >= 600dp) including tablets and inner displays on foldables. For most apps, it’s key to helping them stretch to any screen size. In some cases if your app isn’t adaptive, it could deliver a broken user experience on these screens. This moves adaptive design from a nice-to-have to a foundational requirement.

Increase user reach and app discoverability in Play: Adaptive apps are better positioned to be ranked higher in Play, and featured in editorial articles across form factors, reaching a wider audience across Play search and homepages. Additionally, Google Play Store surfaces ratings and reviews across all form factors. If your app is not optimized, a potential user’s first impression might be tainted by a 1-star review complaining about a stretched UI on a device they don’t even own yet. Users are also more likely to engage with apps that provide a great experience across their devices.
Increased engagement on large screens: Users on large screen devices often have different interaction patterns. On large screens, users may engage for longer sessions, perform more complex tasks, and consume more content.

Concepts saw a 70% increase in user engagement on large screens after optimizing.

Usage for 6 major media streaming apps in the US was up to 3x more for tablet and phone users, as compared to phone only users.

More accessible app experiences: According to the World Bank, 15% of the world’s population has some type of disability. People with disabilities depend on apps and services that support accessibility to communicate, learn, and work. Matching the user’s preferred orientation improves the accessibility of applications, helping to create an inclusive experience for all.

Today, most apps are building for smartphones only

“…looking at the number of users, the ROI does not justify the investment”.

That’s a frequent pushback from product managers and decision-makers, and if you’re just looking at top-line analytics comparing the number of tablet sessions to smartphone sessions, it might seem like a closed case.

While top-line analytics might show lower session numbers on tablets compared to smartphones, concluding that large screens aren’t worth the effort based solely on current volume can be a trap, causing you to miss out on valuable engagement and future opportunities.

Let’s take a deeper look into why:

The user experience ‘chicken and egg’ loop: Is it possible that the low usage is a symptom rather than the root cause? Users are quick to abandon apps that feel clunky or broken. If your app on large screens is a stretched-out phone interface, the app likely provides a negative user experience. The lack of users might reflect the lack of a good experience, not always necessarily lack of potential users.
Beyond user volume, look at user engagement: Don’t just count users, analyze their worth. Users interact with apps on large screens differently. The large screen often leads to longer sessions and more immersive experiences. As mentioned above, usage data shows that engagement time increases significantly for users who interact with apps on both their phone and tablet, as compared to phone only users.
Market evolution: The Android device ecosystem is continuing to evolve. With the rise of foldables, upcoming connected displays support in Android 16, and form factors like XR and Android Auto, adaptive design is now more critical than ever. Building for a specific screen size creates technical debt, and may slow your development velocity and compromise the product quality in the long run.

Okay, I am convinced. Where do I start?

For organizations ready to move forward, Android offers many resources and developer tools to optimize apps to be adaptive. See below for how to get started:

1: Check how your app looks on large screens today

Begin by looking at your app’s current state on tablets, foldables (in different postures), Chromebooks, and environments like desktop windowing. Confirm if your app is available on these devices or if you are unintentionally leaving out these users by requiring unnecessary features within your app.

2: Address common UI issues

Assess what feels awkward in your app UI today. We have a lot of guidance available on how you can easily translate your mobile app to other screens.

a) Check the Large screens design gallery for inspiration and understanding how your app UI can evolve across devices using proven solutions to common UI challenges.

b) Start with quick wins. For example, prevent buttons from stretching to the full screen width, or switch to a vertical navigation bar on large screens to improve ergonomics.

c) Identify patterns where canonical layouts (e.g. list-detail) could solve any UI awkwardness you identified. Could a list-detail view improve your app’s navigation? Would a supporting pane on the side make better use of the extra space than a bottom sheet?

3: Optimize your app incrementally, screen by screen

It may be helpful to prioritize how you approach optimization because not everything needs to be perfectly adaptive on day one. Incrementally improve your app based on what matters most — it’s not all or nothing.

a) Start with the foundations. Check out the large screen app quality guidelines which tier and prioritize the fixes that are most critical to users. Remove orientation restrictions to support portrait and landscape, and ensure support for resizability (for when users are in split screen), and prevent major stretching of buttons, text fields, and images. These foundational fixes are critical, especially with API changes in Android 16 that will make these aspects even more important.

b) Implement adaptive layout optimizations with a focus on core user journeys or screens first.

i. Identify screens where optimizations (for example a two-pane layout) offer the biggest UX win

ii. And then proceed to screens or parts of the app that are not as often used on large screens

c) Support input methods beyond touch, including keyboard, mouse, trackpad, and stylus input. With new form factors and connected displays support, this sets users up to interact with your UI seamlessly.

d) Add differentiating hero user experiences like support for tabletop mode or dual-screen mode on foldables. This can happen on a per-use-case basis — for example, tabletop mode is great for watching videos, and dual screen mode is great for video calls.

While there’s an upfront investment in adopting adaptive principles (using tools like Jetpack Compose and window size classes), the long-term payoff may be significant. By designing and building features once, and letting them adapt across screen sizes, the benefits outweigh the cost of creating multiple bespoke layouts. Check out the adaptive apps developer guidance for more.

Unlock your app’s potential with adaptive app design

The message for my fellow product managers, decision-makers, and businesses is clear: adaptive design will uplevel your app for high-quality Android experiences in 2025 and beyond. An adaptive, responsive UI is the scalable way to support the many devices in Android without developing on a per-form factor basis. If you ignore the diverse device ecosystem of foldables, tablets, Chromebooks, and emerging form factors like XR and cars, your business is accepting hidden costs from negative user reviews, lower discovery in Play, increased technical debt, and missed opportunities for increased user engagement and user acquisition.

Maximize your apps’ impact and unlock new user experiences. Learn more about building adaptive apps today.

$\"\"$

A product manager’s guide to adapting Android apps across devices was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/b2e9b8bfe5f1","A product manager’s guide to adapting Android apps across devices",{"_2445":21},{"_8":2515,"_30":2516,"_2456":2457,"_2458":2517,"_2445":21,"_2460":2518,"_36":2519,"_2463":2520},759,"2025-06-05T17:28:56+00:00","

Now in Android #117 — Google I/O 2025 Part I

Design, Watches, Cars, Tablets, Adaptive Apps, Android XR, Gemini, and Android 16

Welcome to part one of a special two-part Google I/O 2025 edition of Now in Android. This first post will cover a bunch of changes related to the latest evolution of Material Design, watches, cars, tablets, laptops, and connected displays, the latest in adaptive app development, XR development, how to take advantage of on-device and cloud based AI, and Android 16.

Most of the content of this post is available in the form of a video or podcast, so feel free to watch or listen rather than read on. (Or do all three to help you remember! There won’t be a quiz.)

The Android Show: I/O Edition — what Android devs need to know! 🤖

We began the I/O season with a special edition of The Android Show, where we introduced the latest evolution of Material Design, Material 3 Expressive.

The Android Show: I/O Edition - what Android devs need to know!

Material 3 Expressive adds a new motion physics system, new type styles for variable and static fonts, an expanded shape library with morphing animations, and an expanded range of colors. Fifteen new or updated components now feature more configuration capabilities, shape options, emphasized text, and other expressive updates. The Material team has a post where you can read all about it, including design tactics.

M3 Expressive: Engaging UX Design

At I/O Build next-level UX with Material 3 Expressive covered how to use the new expressive design patterns; breaking down the research, explaining new guidelines, and including new design files + code.

The first beta of the Q3 Android 16 update contains much of the new visual polish associated with Material Expressive, and you can get the Q3 beta today on your supported Pixel device.

The Android Design at Google I/O 2025 post covered how to use new emotional design patterns to boost engagement, usability, and desire, while making sure your app is updated with the latest Android 16 accessibility features like enhanced dark themes and increased text contrast. It covers designing across Android form factors with Gemini in-car and the new Car UI Design Kit. Learn new ways Google TV helps users engage with content and explore bringing 3D models to Android XR. WearOS is also releasing an updated design kit and learning Pathway.

New Android design guidance includes in-app settings, help and feedback, widget configuration, and edge-to-edge design. You can also find new and updated resources at figma.com/@androiddesign.

Android Design at Google I/O 2025

The Android Show also covered how we’re bringing Material 3 expressive to watches with Wear OS 6, and at I/O we launched the Wear OS 6 developer preview, allowing you to test your apps using the Wear OS 6 emulator.

The What’s New in WearOS 6 post from I/O covers lots more, including new tile components, the new Edge Hugging button, The TransformingLazyColumn, a new ScrollIndicator, and ProgressIndicator, CredentialManager for WearOS, and Richer Wear Media Controls.

What's new in Wear OS 6

Wear OS 6 introduces Watch Face Format v4 with a new Watch Face Push API, designed to support watch face marketplaces.

Version 4 also brings new features like the Photos element for user-selectable photos and transitions when exiting and entering ambient mode. Color Transforms are extended to more elements, with new functions for manipulating color. The Reference element lets you refer to any transformable attribute from one part of your watch face scene in other parts of the scene tree, and all that’s detailed in the What’s new in Watch Faces post.

What's new in Watch Faces

New in-car app experiences 🚗

Google announced the latest advancements for in-car experiences at I/O.

Gemini is coming to vehicles. Navigation apps can integrate with Gemini using three core intent formats, allowing you to start navigation and display relevant search results. Gemini for cars will be rolling out in the coming months.
The Weather app category has graduated from beta, so you can now publish weather apps to production tracks on both Android Auto and cars with Google Built-in.
You can use the Car App Templates Design Kit on Figma to design templated apps.
SectionedItemTemplate and MediaPlaybackTemplate are now available in the Car App Library 1.8 alpha release.
Android Auto now supports media apps, communications apps, and games in beta.
It’s now possible for apps in the parked categories to distribute in the same APK or App Bundle to cars with Google built-in as to phones.
To help you test Android Automotive OS apps, Android Automotive OS on Pixel Tablet is now generally available.
Video apps will be supported on Android Auto, starting with phones running Android 16 on select compatible cars.
Work is being done to enable thousands of adaptive mobile apps for Android Automotive OS cars running Android 14+ with Google built-in.
Updated design documentation will visualize car app quality guidelines and integration paths to simplify designing your app for cars.
Google Play Services for cars with Google built-in are expanding to bring them on-par with mobile, including Passkeys/Credential Manager APIs and Quick Share.
Work is being done with OEMs to enable audio-only listening for video apps while driving for cars with Google built-in.
Firebase Test Lab is adding Android Automotive OS devices to its device catalog
Pre-launch reports for Android Automotive OS are coming soon to the Play Console.

New in-car app experiences

Engage users on Google TV with excellent TV apps 📺

Google TV has over 270 million monthly active devices. New platform features and developer tools are available to help you increase app engagement.

Gemini capabilities are coming to Google TV, allowing users to speak naturally to find content and answers, including relevant content from your apps.
Compose for TV 1.0 is now stable, expanding on core and Material Compose libraries. The latest release improves app startup, with internal benchmarking showing a 20% improvement compared to the March 2024 release. Check out the updated Jetcaster audio streaming app sample for guidance on using Compose across form factors.
Partner enrollment is open for the Video Discovery API, which optimizes Resumption, Entitlements, and Recommendations across Google TV. With the API, you can display a user’s paused video in the ‘Continue Watching’ row and streamline entitlement management. Personalized content recommendations based on watched content are also highlighted.
A codelab is available that reviews how you can set initial focus, prepare for unexpected focus traversal, and efficiently restore focus.
A comprehensive guide on memory optimization is also released, including memory targets for low RAM devices.
The In-App Ratings and Reviews API is extended to TV. The API allows you to prompt users for ratings and reviews directly from Google TV.
With Android 16 for TV, you’ll be able to access features such as the MediaQualityManager, platform support for the Eclipsa Audio codec, improvements to media playback speed, and HDMI-CEC reliability and performance optimizations.

Engage users on Google TV with excellent TV apps

The In-App Ratings and Reviews for TV article covers integrating the newly-available Google Play In-App Review API for TV.

In-App Ratings and Reviews for TV

Updates to the Android XR SDK: Introducing Developer Preview 2 🥽

The Android XR SDK Developer Preview 2 is now available, featuring updates to Jetpack XR, Jetpack Compose, Material Design, ARCore, and the Android XR Emulator.

Key updates include:

Jetpack XR SDK: You can now play back 180° and 360° videos.
Jetpack Compose for XR: You can define layouts that adapt to different XR display configurations.
Material Design for XR: You have access to more component overrides for TopAppBar, AlertDialog, and ListDetailPaneScaffold.
ARCore for Jetpack XR: You can track hands after requesting the appropriate permissions, enabling hand gestures in your apps.
Android XR Emulator: You’ll see stability improvements, AMD GPU support, and full integration within the Android Studio UI.

Android XR will be available first on Samsung’s Project Moohan, launching later this year. Soon after, our partners at XREAL will release the next Android XR device, codenamed Project Aura.

Unity developers can upgrade to Pre-Release version 2 of the Unity OpenXR: Android XR package, which includes support for Dynamic Refresh Rate and SpaceWarp.

The Google Play Store will list supported 2D Android apps on the Android XR Play Store when it launches later this year. If you are building an Android XR-differentiated app, you can prepare it for launch by testing your app in the Android XR Emulator and learning how to package and distribute apps for Android XR. You can make your XR app stand out from others on the Play Store with preview assets such as stereoscopic 180° or 360° videos.

Updates to the Android XR SDK: Introducing Developer Preview 2

You can learn more about building for Android XR with the “Building differentiated apps for Android XR with 3D content” session covering Jetpack SceneCore and ARCore for Jetpack XR, while “The Future is now with Compose and AI on Android XR” covers creating XR-differentiated UI and our vision on the intersection of XR with cutting-edge AI capabilities.

Google I/O 2025: Build adaptive Android apps that shine across form factors 📱

In today’s multi-device world, users expect their favorite applications to work flawlessly and intuitively, whether they’re on a smartphone, tablet, or Chromebook. At Google I/O 2025, we explored adaptive app development as a fundamental strategy to make sure your same mobile app runs well across phones, foldables, tablets, Chromebooks, connected displays, XR, and cars.

The article covers tools and libraries to help build adaptive apps:

The Compose Adaptive Layouts library implements canonical layout patterns like list-detail and supporting pane that automatically reflow as your app is resized, flipped or folded. New adaptation strategies like “Levitate” and “Reflow” were introduced in the 1.2 alpha release.
Jetpack Navigation 3 (Alpha) simplifies defining user journeys across screens with less boilerplate code, especially for multi-pane layouts in Compose.
Jetpack Compose input enhancements in Compose 1.9 include right-click context menus and enhanced trackpad/mouse functionality.
Use Window Size Classes for top-level layout decisions, along with our design guidance.
Compose previews visualize your layouts across a wide variety of screen sizes and aspect ratios for quick feedback.
Testing adaptive layouts is crucial and Android Studio offers various tools for validation — including previews for different sizes and aspect ratios, a resizable emulator, screenshot tests, and instrumented behavior tests. Journeys with Gemini in Android Studio, allow you to define tests using natural language for even more robust testing across different window sizes.

Note, beginning in Android 16 manifest and runtime restrictions on orientation, resizability, and aspect ratio will be ignored on large displays (displays that are at least 600dp in both dimensions) for apps targeting SDK 36. Your apps will need support runtime resizing, with layouts that work for both portrait and landscape windows.

There’s a temporary opt-out manifest flag at both the application and activity level to delay these changes until targetSdk 37.
These changes do not currently apply to apps in the “Games” category

The article and I/O talk covers all this and more in additional detail.

Google I/O 2025: Build adaptive Android apps that shine across form factors

See how Peacock used Jetpack Compose and the WindowSizeClass API to adapt its Android app for various screen sizes, including foldables and future Android XR devices.

Peacock built adaptively on Android to deliver great experiences across screens

The “Unlock user productivity with desktop windowing and stylus support” talk covers how to make sure your app is ready to be productive on Android, including support for multiple instances of an app, drag-and-drop, connected displays, and styluses.

On-device GenAI APIs as part of ML Kit help you easily build with Gemini Nano 🤖

ML Kit now includes on-device GenAI APIs:

New APIs: Summarization, Proofreading, Rewriting, and Image Description APIs built with Gemini Nano, LoRA adapters, optimized inference parameters, and a quality evaluation pipeline. The feature-specific fine-tuning increases the benchmark scores for each API.
On-Device Focus: The on-device processing ensures data privacy, offline functionality, and eliminates API call costs.
Future Expansion: Expect multilingual support and multimodal text/image input capabilities.
Resources: Check out goo.gle/mlkit-genai and d.android.com/ai for more details.

On-device GenAI APIs as part of ML Kit help you easily build with Gemini Nano

While the Android announcements were focused on on-device AI, Google I/O had sessions about leveraging cloud models as well as hybrid approaches.

Finding the perfect Gemini fit on Android is an overview of AI offerings, with guidance around considering the modality, complexity, and context window of your app’s AI needs to choose the right models and infrastructure.

Enhance your Android app with Gemini Pro and Flash, and Imagen covers how you can integrate Google’s generative AI models, Gemini Pro and Flash, into your apps using the Firebase SDK. This provides access to functionalities like text, image, audio, and video processing. The Gemini Developer API offers a no-cost tier and scalable plans. Additionally, Imagen 3 is available via Firebase for generating visuals and enhancing existing screens (currently in public preview). You are encouraged to use App Check to protect app assets and traffic monitoring in the Firebase console.

What’s new in Android

What’s new in Android spans both this and the next episode of Now in Android. This episode focuses on top Android 16 developer updates.

Minor SDK releases

With Android 16, we’ve added the concept of a minor SDK release to allow us to iterate our APIs more quickly, reflecting the rapid pace of the innovation Android is bringing to apps and devices.

New features

Live Updates notify users of important ongoing user-facing progress and come with a new ProgressStyle standardized template.
Digital credentials and restore credentials APIs in credential manager.
Privacy Sandbox updates, including a new learning pathway
Advanced Protection Mode and Identity Check
Medical Records in Health Connect along with new permissions and support for background reads of health data.

Changes

Even if you aren’t yet targeting Android 16:

JobScheduler: JobScheduler quotas are enforced more strictly in Android 16; enforcement will occur if a job executes while the app is on top, when a foreground service is running, or in the active standby bucket. setImportantWhileForeground is now a no-op. The new stop reason STOP_REASON_TIMEOUT_ABANDONED occurs when we detect that the app can no longer stop the job.
Broadcasts: Ordered broadcasts using priorities only work within the same process. Use another IPC if you need cross-process ordering.
ART: If you use reflection, JNI, or any other means to access Android internals, your app might break. This is never a best practice. Test thoroughly.
Intents: Android 16 has stronger security against Intent redirection attacks. Test your Intent handling, and only opt-out of the protections if absolutely necessary.
16KB Page Size: If your app isn’t 16KB-page-size ready, you can use the new compatibility mode flag, but we recommend migrating to 16KB for best performance.
Accessibility: announceForAccessibility is deprecated; use the recommended alternatives. Make sure to test with the new outline text feature.
Bluetooth: Android 16 improves Bluetooth bond loss handling that impacts the way re-pairing occurs.

Once your app targets Android 16:

User Experience: Changes include the removal of edge-to-edge opt-out, required migration or opt-out for predictive back, and the disabling of elegant font APIs.
Core Functionality: Optimizations have been made to fixed-rate work scheduling.
Large Screen Devices: Orientation, resizability, and aspect ratio restrictions will be ignored. Ensure your layouts support all orientations across a variety of aspect ratios to adapt to different surfaces.
Health and Fitness: Changes have been implemented for health and fitness permissions.

Get your app ready for the future:

Local network protection: Consider testing your app with the upcoming Local Network Protection feature. It will give users more control over which apps can access devices on their local network in a future Android major release.

16 things to know for Android developers at Google I/O 2025 🤖

In honor of Android 16, Google I/O ’25 featured 16 key announcements for Android developers:

Generative AI: Use ML Kit GenAI APIs with Gemini Nano for tasks like summarization and image description. You can use Gemini Pro, Gemini Flash, and Imagen via Firebase AI Logic for more complex tasks, and you can also use the new AI sample app, Androidify.
Adaptive Apps: Build a single mobile app that works across devices to reach 500 million devices. Use Compose Layouts library and Jetpack Navigation updates.
Material 3 Expressive: Use Material 3 Expressive to enhance your product’s appeal by harnessing emotional UX.
Widgets: Personalize widget previews with Glance 1.2. Use Live Updates to notify users of important ongoing notifications.
Camera & Media: Use software low light boost for improved photography in dim lighting and native PCM offload for battery conservation.
Cars: Build in-car experiences using Gemini integrations, support for more app categories, and enhanced capabilities for media and communication apps. Use testing tools like Android Automotive OS on Pixel Tablet and Firebase Test Lab access.
Android XR: Use Developer Preview 2 of the Android XR SDK, and build for the expanding ecosystem of devices.
Wear OS: Wear OS 6 features Material 3 Expressive, a new UI design with personalized visuals and motion for user creativity.
Google TV: Compose for TV stable release empowers you to build adaptive UIs. Use the Video Discovery API.
Jetpack Compose: The latest stable BOM release provides the features, performance, stability, and libraries that you need to build beautiful adaptive apps faster.
Kotlin Multiplatform: Use the new Android Studio KMP shared module template, updated Jetpack libraries, and new codelabs.
Gemini in Android Studio: Use the new agentic AI experiences, Journeys for Android Studio and Version Upgrade Agent.
Android Studio: The latest release has AI-driven tools like Gemini in Android Studio.
Google Play: Use enhanced personalization and fresh ways to showcase your apps and content.
Play Games Services: Migrate PGS v1 features to v2.
Android 16: Test your apps with the latest Beta of Android 16.

In this part one of the I/O 2025 edition of Now in Android, we’ve covered Generative AI, Adaptive Apps, Material 3 Expressive, Cars, TV, Wear, and Android 16 from this list, and the next part will cover Jetpack Compose, Android Studio, and more.

16 things to know for Android developers at Google I/O 2025

Now then… 👋

That’s it for part one of our I/O coverage in Now in Android, with Material Expressive, watches, cars, tablets, laptops, connected displays, the latest in adaptive app development, XR development, AI, and Android 16. Part two of our coverage will include the latest from Android Jetpack, Jetpack Compose, Android Studio, so be sure to tune in.

Remember to like, subscribe, share, and stay safe, and come back here soon for more of Now in Android.

$\"\"$

Now in Android #117 — Google I/O 2025 Part I was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/fd20a09a2299","Now in Android #117 — Google I/O 2025 Part I",{"_2445":21},{"_8":2522,"_30":2523,"_2456":2457,"_2458":2524,"_2445":13,"_2460":2525,"_36":2526,"_2463":2527},758,"2025-05-21T18:00:57+00:00","

Today at the Google I/O conference, hosted at Shoreline Amphitheatre in Mountain View, California, we shared how Flutter continues to gain momentum as a production-grade app framework trusted by some of the world’s largest brands.

First, according to the JetBrains State of the Developer Ecosystem survey, Flutter has been the most used multi-platform app framework, since 2021.

Second, according to app intelligence provider AppTopia, Flutter accounts for nearly 30% of all new free iOS apps.

“Apptopia tracks millions of apps in the Apple AppStore and Google Play Store, and analyzes and detects which developer SDKs were used to create the apps. Flutter is one of the most popular SDKs we track: In the Apple AppStore it has grown steadily in usage from around 10% of all tracked free apps in 2021 to nearly 30% of all tracked free apps in 2024!”

— Apptopia Inc.

Customer updates

Here are a few of the brands and apps that exemplify this growth, and the unique power of Flutter and its ability to target any platform from a single, shared source code base.

NotebookLM: A new AI-powered research and writing assistant, made by Google Labs, just launched their mobile apps built with Flutter. Previously, this was only available as a website, but the team received many requests for mobile apps. With development speed and time-to-market being critical, Flutter was a natural choice. We’re excited about its public release this week.
Google Cloud: The Google Cloud team took their existing iOS/Android apps, and switched to Flutter for building a range of new features like their new Cloud Assist, with the goal of writing once and deploying everywhere. They found tremendous value in the UI and logic consistency they get from having a single, shared codebase and felt Flutter offers native-like performance and feel without compromises.
Universal: We announced last year how Universal Destinations & Experiences uses Flutter for their iOS and Android Apps at their parks in Orlando, Hollywood, and Osaka. At their newest theme park, Universal Epic Universe in Orlando, they are now also using Flutter to power their guest-facing self-service dining kiosks. They were able to take their app, and reimagine it as a kiosk interface — with rich animations and smooth transitions. This is a great showcase of just how flexible and powerful Flutter really is.
Reflection.app: Powered by a complete Google stack — Flutter, Firebase, and Gemini — to deliver a thoughtful journaling experience to their users.
teamLab: Based in Tokyo, teamLab creates solutions for digital content production, urban planning, and architectural space design. Their museum apps allow visitors to read more about the exhibits, and even interact digitally with the pieces on the phone. So far they have seen 35 million users of this new experience.
1080 Motion: Another example is 1080 Motion, out of Sweden, who offer state-of-the-art training and rehabilitation for professional athletes around the world. Their customers receive real time performance feedback on hardware that delivers individualized workouts tailored for that athlete, on that day.
GE Appliances: GE Appliances is using Flutter to revolutionize the UIs on small screens found on modern appliances equipped with an LCD screen. Their team, comprising many embedded and JavaScript developers, found Dart easy to learn, which accelerated adoption and allowed them to become productive quickly. In the future, they plan to expand on its embedded starting point by building user-facing mobile apps with Dart and Flutter.

Evolving the Dart language

Dart is a key ingredient to Flutter’s success. Our ability to evolve Dart and Flutter together is a core enabler of Flutter’s industry leading developer experience and production quality.

We continue to evolve the Dart language — here’s a visualization of all the improvements we’ve made, since our major null safety feature, back in 2021.

Null-aware elements

Today in Dart 3.8, we’re adding null-aware elements, which allows you to include an element in a collection only if its runtime value is non-null. You can use this feature to rewrite code like this:

// Code without null-aware elements.
var listWithoutNullAwareElements = [
if (promotableNullableValue != null)
  promotableNullableValue,
if (nullable.value != null)
  nullable.value!,
if (nullable.value case var value?)
  value,
];

With null-aware elements, remove all those if statements:
// Code with null-aware elements.
var listWithNullAwareElements = [
  ?promotableNullableValue,
  ?nullable.value,
  ?nullable.value,
];

Dot shorthands

We also shared the news that we’re working on a new language feature called dot shorthands — projected to release later this year — for addressing duplication in Flutter code with a new shorter syntax for selecting a member on a type that is known based on the context:

// Code without dot shorthands.
Column(
  crossAxisAlignment: CrossAxisAlignment.stretch,
  mainAxisSize: MainAxisSize.min,
  children: […],
);

// Code with dot shorthands.
Column(
  crossAxisAlignment: .stretch,
  mainAxisSize: .min,
  children: […],
);

Updating the developer experience

We take the Dart and Flutter developer experience very seriously and have several updates.

Property editor

One of the trickiest parts of any framework is learning what all the available APIs are. This can be overwhelming at first. Great developer tooling can really help here — today we’re announcing a new property editor feature, available today in Flutter 3.32.

When you select a widget in your IDE, it shows the primary layout properties without having to read docs or go to declaration. You can then easily change them directly in the property editor, and have those changes propagate to the source code.

Pub.dev improvements

We’ve also made several improvements to pub.dev, the Dart package manager: We added dark mode support for better contrast, a new download counts feature that helps you understand how much a package is used, and how that use is distributed over the available versions.

A brand new feature we’re announcing this week is Trending Packages, which shows packages that have a significant recent uptick in usage. This can be used for discovering new packages that might be of interest.

Improved formatting

The Dart formatter is used by most Dart developers. Earlier this year, we added new functionality to make it automatically manage trailing commas. Based on your feedback, we made a number of adjustments in this week’s Dart 3.8 release, and added a new configuration option to tell the formatter to never remove trailing commas if you prefer to manually maintain these.

Dart cross-compilation

Next, we’ve also improved the Dart compiler with the ability to compile Dart executables for Linux from Windows or macOS. This is particularly useful when targeting smaller embedded devices, like a Raspberry Pi. Before this, if you didn’t have a Linux machine, you had to compile Dart on the Raspberry Pi itself.

Integrating more deeply with platforms

Direct native interoperability

Last year we announced a new initiative — direct native interop — with a vision of eventually allowing you to access native APIs as easily as you access your own Dart code. Today we shared several updates:

Thread merge: Historically, the Flutter engine has used two separate threads — the platform thread and the UI thread. The vast majority of platform APIs must be accessed on the platform thread, but the Dart code was running on the UI thread, making calling platform API directly from Dart cumbersome. This work is now completed in stable for Android & iOS, and in Flutter 3.33 beta for Windows and macOS. Work to merge threads on Linux is underway. For details see the tracking issue.
Native assets/build hooks: Sometimes you need to talk to third party libraries written in another language — for example, a machine learning library written in C. Build hooks (formerly known as native assets) support bundling native code with Dart packages, and as of today, is available in preview in the main channel.
ffigen/jnigen: We continue to improve the ffigen & jnigen wrapper generators, and hope to share more news about these in the second half of the year.

Great on Android

Impeller: As of 3.29, Android has joined iOS in using Impeller as its default renderer, with the exception being a small set of nearly 10 year old Android devices which have a very old graphics stack. To support these devices, we will continue to use Skia on Android API-level 28 and lower.
Edge-to-edge: As of Flutter 3.27, we made Android’s edge-to-edge UI system Flutter’s default. This support opens up the entire height of the display to Flutter apps running on devices that have no system bars at the top or bottom of the display. This had delicate implications on how Flutter thinks about things like SafeAreas and system UI.
Scribe: This year we also added support for Android’s “Scribe” feature, which converts raw handwriting into actual text.
Material updates: We’ve delivered numerous updates to Material, including supporting new page transitions, updated progress indicators and sliders, and other areas of polish.

Great on iOS

We want developers building for iOS to be able to deliver beautiful, feature-rich apps, so this year we’ve been hard at work improving fidelity for iOS and improving Flutter’s integration with the Apple developer ecosystem:

Cupertino update: A large investment in the Cupertino library has been made to improve its fidelity and expand its coverage. We revisited spring and scrolling physics, landed numerous updates to widgets such as our bottom sheets, collapsible widgets, navigation bars, (especially those with search fields), and more.
Swift Package Manager: We are migrating from Cocoapods to Swift Package Manager to simplify our dev setups. This transition is ongoing, but over 150 plugins have added Swift Package Manager support and we’re happy to announce that that includes all Firebase plugins. We aim to complete the transition to Swift Package Manager soon!
Squircles: And, one more thing… We’re added new support for one of Apple’s unique shapes, known as a squircle, which blends the arcs of several different shapes! The precise algorithm to the iOS squircle remains a mystery to many, but that hasn’t stopped us from creating our take on it, to the highest possible fidelity. You can find this in the stable channel today as the RSuperellipse class and we’re already including it in our Cupertino widgets where appropriate.

Great on web

WebAssembly: Last year we announced support for compiling Flutter web apps WasmGC — to make apps start faster, and render frames up to twice as fast in complicated scenarios.
Accessibility: We’ve done a lot of work on our accessibility system, both in terms of performance, and have added an entire new Semantics Roles system that Flutter converts to standard aria labels on the web.
Stateful hot reload: If you’ve built Flutter apps for mobile and wanted to take those experiences to the web, you’ve probably felt the absence of Flutter’s flagship feature — stateful hot reload — when working on Flutter web apps. Today, we announced that stateful hot reload for Flutter web is available in preview in all channels. One place you can experience it right away is in DartPad.

Expanding the ecosystem

Google is proud to support Flutter, but so much of the value for Flutter developers comes from our larger community.

Canonical

One big contributor is Canonical, the folks behind Ubuntu. They use Flutter themselves for Ubuntu’s first-party app marketplace, and have been excited to contribute toward Flutter’s overall quality on desktop, including contributing feature work for multi-window support.

\"\" — Multi-window support running on Linux

They have also contributed to the desktop implementation of Flutter’s significant thread merge. And they have fixed many issues related to accessibility, text input, focus, and keyboard & mouse events.

LG

Another company with a business-critical interest in Flutter is LG. Last year, LG announced plans to rewrite many of their core webOS system apps in Flutter. This year, LG is excited to announce a significant expansion of their investment in Flutter, aiming to complete the development of a new webOS-Flutter SDK, which will allow developers to release Flutter apps to the LG Content Store. They are targeting an official launch in the first half of next year.

Embracing AI

We have lots of news in the exciting and fast-paced field of AI, both for AI-powered applications and AI-powered development.

Introducing Firebase AI Logic

Vertex AI in Firebase is now known as Firebase AI Logic. And among many new things, it now allows you to use Vertex AI Gemini API (billing required with the pay-as-you-go Blaze pricing plan), or the newly added Gemini Developer API (billing optional with the no-cost Spark pricing plan) all from one single Dart SDK. For more details, see the Firebase blog.

DartPad and Gemini

We’ve added Gemini support directly into DartPad, which brings the power of Gemini code assistance right to your finger-tips with no setup or installation necessary.

\"\" — Gemini-powered code generation in DartPad

That feature was built using the Gemini API. Its full source code is available in the DartPad GitHub repo and serves as a demonstration of how you can create AI-powered development tools.

Android Studio, VSCode, IntelliJ IDEA and Gemini

Another place that now has Gemini support is Android Studio. The Flutter and Android Studio teams collaborated on this so, as of the most recent Android Studio release (Meerkat Feature Drop), Gemini support for Dart and Flutter is now first-class.

And if you’re a VSCode or IntelliJ IDEA user, rest easy. The Gemini Code Assist extension and a Google account brings Gemini-powered code assistance to your workflows right in VS Code.

MCP

MCP is an exciting new open protocol that is gaining a lot of momentum for enabling AI agents to access and interact with various data sources and tools in a standardized way.

We are currently experimenting to see if it can enable us to provide more accurate and relevant code generation and allow tooling for complex tasks like fixing layout issues, managing dependencies, or even resolving runtime errors.

Wrap up

A big thank you to all of you who have made Flutter what it is. We’re proud to continue the journey with you all to build the world’s best app framework.

Have a great I/O, check out the great session videos, and have fun with Flutter!

$\"\"$

Dart & Flutter momentum at Google I/O 2025 was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/4863aa4f84a4","Dart & Flutter momentum at Google I/O 2025",{"_2445":13},{"_8":2529,"_30":2530,"_2456":2457,"_2458":2531,"_2445":13,"_2460":2532,"_36":2533,"_2463":2534},756,"2025-05-20T18:03:41+00:00","

Today, we’re excited to announce an early access program for Flutter plugin authors who are ready to build/re-build a plugin leveraging the codegen solutions. This is the next phase of development in our work to make it easier for Flutter developers to access native platform APIs by using FFIgen and JNIgen. There are a limited number of slots available by application to those who are ready to engage with us directly on a first wave of production plugins using FFIgen and JNIgen.

This blog post covers more on what we hope to achieve with direct native interoperability, how we plan to get there, as well as more about the early access program and how you can join us on the journey.

The fundamental challenge

Developers often need to call APIs that are native to the host-platform the app is running on, like iOS or Android. Currently, Flutter developers can do that using method channels. Method channels rely on message passing between Dart code and native code (such asKotlin or Swift) to call the native APIs. That is, Dart code sends native code a message and the native code does something and then responds by sending the result back in a message.

The fundamental challenge with method channels is that they can be time consuming to implement and maintain. They require a lot of hand-written code. Maintenance requires manually updating their implementation to call the latest API version. They can also be error-prone, as they rely on encoding & decoding messages into strings, which can lead to runtime errors if APIs change. Finally method channels only support asynchronous calls which ensure the UI remains responsive, but can add code complexities in managing async results, handling errors, and dealing with potential latency waiting for results.

We’ve addressed some of the pain points of using method channels with Pigeon, a tool that generates skeleton code for Dart and native APIs to handle messages that you would then manually write with method channels. While Pigeon reduces the time spent wrapping methods and writing message handlers between Dart and native code, APIs with large surface areas still require tedious code to be written. For example, the iOS in-app purchase plugin interacts with a lot of StoreKit objects and, since they are nested within other native objects, it takes a lot of manual coding to convert them to Pigeon serializable classes on the Objective-C side and convert those Pigeon classes back to wrapper classes on the Dart side.

Additionally, interoperability between two plugins is a challenge and there is no way to pass a non-serializable object like an Android Image through Dart to another plugin without each of them having a dependency on each other.

Flutter’s vision for interoperability

Like Michael Thompson said during #FlutterInProduction, “We’re investing a lot in a new approach for this, which we call direct native interop.”

Our vision for interoperability is to ultimately make accessing platform APIs more effortless for developers with a simple and seamless developer experience. The goal is to enable Flutter developers to focus more time on the experience they are trying to build and less time trying to leverage the power of the underlying platform.

The solution

We plan on solving the fundamental interop challenge with codegen solutions called FFIgen and JNIgen that handle bridging Dart and native code for each platform directly. FFIgen will generate bindings to wrap Objective-C and Swift APIs, while similarly JNIgen will do the same for Java and Kotlin APIs.

Unlike method channels, FFIgen and JNIgen will enable APIs to be called synchronously, will support tree-shaking (removal of unused code during compilation), and allow more data to live in the platform layer.

The ideal user

In this early stage, the ideal users of the new direct interop are Flutter developers who are deeply knowledgeable about native platforms (iOS, Android, or both) with a strong desire to access any platform API they need more directly and with less toil. With FFIgen and JNIgen they can spend significantly less time bridging Dart with native platform code and making it easier to build and maintain plugins for the ecosystem.

As the tools become more robust over time, we imagine any Flutter developer who is well versed in native platforms will be able to access any platform API (such as one not yet available for Flutter in production or through a package on pub.dev) to generate the code they need to directly call the API with Dart code within their Flutter app.

Our hope is to land a solution significantly better than what exists today through a simplified developer experience — one that is magical in the right places without forcing developers to give up control.

Join Interop Early Access Program

We are looking for candidates well versed in building Flutter plugins and in using Flutter tools to try an early access program, where you’d rewrite existing plugins to use direct interop, and provide detailed feedback and issues to guide the future development. Like any preview program, there will inevitably be rough edges along the way, but we’re ready to provide support and early access to overcome any obstacles that you experience.

Indicate your interest by completing this form. We’ll likely not be able to include all who apply to this early program. Selected candidates will hear from us after June 20th, 2025.

We’re looking forward to hearing from you!

$\"\"$

Flutter’s path towards seamless interop was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/4bf7d4579d9a","Flutter’s path towards seamless interop",{"_2445":13},{"_8":2536,"_30":2537,"_2456":2457,"_2458":2538,"_2445":13,"_2460":2539,"_36":2540,"_2463":2541},755,"2025-05-20T18:03:09+00:00","

By Ander Dobo, Product Manager, Flutter &
Sandhya Mohan, Product Manager, Gemini in Android Studio

We’re thrilled to announce a major leap forward for Flutter developers creating Android apps in Android Studio. Gemini in Android Studio now offers first-class support for Dart and Flutter development! This means that you can leverage the power of Gemini directly within your favorite IDE to build beautiful, high-performance Flutter apps faster and easier than ever before.

For years, Flutter has empowered developers to create stunning multi-platform experiences from a single codebase. Android Studio has been a cornerstone of that journey, providing a powerful and familiar environment for many Flutter developers.

We know you’re always looking for ways to boost your productivity and streamline your workflow. You’ve told us you want smarter tools, better code completion, and help tackling those tricky layout challenges. That’s why the Flutter and Android Studio teams partnered to ensure that Gemini understands the unique nuances of Flutter development. This is due to our continued commitment to making development across platforms easier for developers.

This isn’t just generic AI assistance. Gemini in Android Studio recognizes Dart syntax, understands Flutter widgets and layouts, and can provide context-aware suggestions tailored specifically to your Flutter projects. Imagine:

Generating UI code with a simple prompt: Describe the UI you want, and Gemini can generate the corresponding Flutter code. Need a list view with rounded corners and a specific data source? Just ask!
Fixing layout errors instantly: No more wrestling with overflowing pixels or misaligned widgets. Gemini can analyze your layout, identify the problem, and suggest (or even automatically apply) the fix.
Explaining complex widgets: Unsure how a particular widget works? Gemini can provide clear explanations and point you to relevant documentation.
Refactoring Dart code with confidence: Gemini can help you modernize your codebase, improve readability, and apply best practices.
Generating Unit and Widget tests: Speed up testing with AI-generated tests.

Explaining Code with Gemini in Android Studio

We’ve seen incredible progress in AI’s ability to understand and generate code, and we’re excited to bring these capabilities to the vibrant Flutter community in Android Studio. Our goal is for Gemini to provide relevant, accurate, and helpful assistance throughout the entire development lifecycle. Key features include:

Context-aware chat: Ask Gemini questions about your Flutter project, and get answers that are tailored to your currently open files.
Smart code completion: Get intelligent suggestions for Dart code, Flutter widgets, and even pubspec.yaml dependencies.
Actionable insights: Gemini can analyze your code and provide insights to help you improve performance, identify potential bugs, and follow best practices.
Prompt Library: Access and create a library of your common Flutter-specific prompts for Gemini in Android Studio.

Using the Prompt Library

This is just the beginning. We’re committed to continuously improving Gemini’s capabilities and expanding its support for Flutter. We’re actively collecting feedback from the community to guide our future development.

Get started for free today!

Ready to experience the power of Gemini in Android Studio for Flutter development?

Download the latest Android Studio: Make sure you’re running the latest version of Android Studio.
Enable Gemini: Open a Flutter project and look for the Gemini icon in the toolbar. Follow the prompts to enable Gemini.
Start Chatting: Ask Gemini anything! Experiment with different prompts and see how it can help you.
Consider Gemini in Android Studio for businesses: To enable enterprise-grade privacy and security features backed by Google Cloud, you can purchase a Gemini Code Assist Standard or Enterprise license. Read this blog post to learn more.
Give us the gift of feedback: We want to hear from you! To help us improve, rate the generated output with a thumbs up or thumbs down. If you get an AI response that you feel is unsafe, not helpful, inaccurate, or bad for any other reason, let us know by submitting feedback using the Provide Feedback option that appears when you select thumbs down.

We’re incredibly excited to see what you build with Gemini in Android Studio!

$\"\"$

Gemini in Android Studio now speaks fluent Flutter! was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/915dfec98274","Gemini in Android Studio now speaks fluent Flutter!",{"_2445":13},{"_8":2543,"_30":2544,"_2456":2457,"_2458":2545,"_2445":13,"_2460":2546,"_36":2547,"_2463":2548},757,"2025-05-20T18:02:25+00:00","

Hot reload on web, native fidelity, and deeper integrations

Introduction

Welcome to Flutter 3.32! This release is packed with features designed to accelerate your development and enhance your apps. Get ready for hot reload on the web, stunning Cupertino squircles for native fidelity, and powerful new AI integrations with Firebase. With 1024 commits from 156 unique contributors, including 39 first time contributors, Flutter 3.32 is a testament to our community’s incredible work. Let’s explore what’s new!

Web

Hot reload on the web (Experimental)

We’re excited to announce that you can now hot reload on the web! Web support for hot reload is the #2 most voted issue on the Flutter tracker. We’re excited to give you a chance to try it out on your own projects! We want your help to make sure this exciting new feature has everything developers want from it.

If you discover any issues, file a bug using Dart’s Web Hot Reload issue template. You can find a list of known issues on the Web Hot Reload Known Issues GitHub project.

Now the fun part: how to use the feature

We’ve added a simple command line flag --web-experimental-hot-reload that you can pass to Flutter anywhere you invoke flutter run.

Running from VS Code

If you use debug configurations in VS Code, you can add this extra configuration to your launch.json file:

"configurations": [
…
  {
    "name": "Flutter for web (hot reloadable)",
    "type": "dart",
    "request": "launch",
    "program": "lib/main.dart",
    "args": [
      "-d",
      "chrome",
      "--web-experimental-hot-reload",
    ]
  }
]

For best results, we recommend enabling the “Dart: Flutter Hot Reload On Save” setting in VS Code. A hot reload can also be triggered with the ⚡icon in the Run/Debug panel. Hot restarts can still be triggered by using the ⟳ button.

Running from the command line

If you use “flutter run” on the command line, you can now run hot reload on the web with the following:

flutter run -d chrome --web-experimental-hot-reload

When hot reload is enabled, you can reload your application by pressing “r” in the running terminal, or “R” to hot restart.

Reloading in DartPad

Hot reload is also now available on DartPad with a new Reload button. The feature is only available if Flutter is detected in the running application. You can try it using a sample app provided by DartPad.

Thanks for taking the time to help us make Hot Reload on the web amazing!

Framework

We have continued our effort to move logic from the Material library to the widgets library.

This release introduces a new Expansible widget that makes it easier to create widgets that expand and collapse with different visual themes. This new widget serves as the underlying building block for the Material-styled ExpansionTile.

Another valuable addition in this release is RawMenuAnchor, contributed by community member @davidhicks980. This widget now serves as the underlying building block for the Material-styled MenuAnchor, paving the way for the creation of menus with diverse visual themes. Furthermore, RawMenuAnchor can be used independently as an unstyled menu, granting you full control over its appearance.

Refactors like these add better support for core widgets to be used in the implementation of design languages like Cupertino and Material (and more!) with more consistent surfaces and code sharing.

Cupertino

Squircles

We’re pleased to introduce a significant new addition to Flutter’s shape capabilities: the rounded superellipse.

Often referred to as the “Apple squircle”, this shape is a cornerstone of the iOS design language, known for its smoother and more continuous curves compared to traditional rounded rectangles. Support for this shape was a frequent request from the Flutter community. Its inclusion represents another step in our efforts to provide high-fidelity UI with native look and feel on Apple platforms.

Both CupertinoAlertDialog and CupertinoActionSheet have been updated to use this new shape!

You can add rounded superellipses to your applications using these new APIs:

RoundedSuperellipseBorder for painting or as a widget shape
ClipRSuperellipse for clipping.
Canvas.drawRSuperellipse, Canvas.clipRSuperellipse, and Path.addRSuperellipse for lower-level APIs that offer more direct control.

Please note that the rounded superellipse is under active development. Currently, it’s only supported on iOS and Android, otherwise the behavior falls back to a standard rounded rectangle. Performance optimizations are also ongoing. We encourage you to explore this new feature with these considerations in mind, and we look forward to enhancing its capabilities in future updates!

Sheet

There were also several issues addressed with the Cupertino sheet, including fixing how the sheet sets the system UI theme when it opens on Android.

The sheet was adjusted to fix the navigation bar’s height and ensure content isn’t cut off at the bottom. The following screenshot demonstrates before and after this change.

Other fixes in this release include an issue where the sheet transition was incompatible with PopupMenuButton, and the rounded corner transition of the sheet was improved to look correct on more devices. Previously, it looked incorrect on some screens with different corner radii.

You can also now use the new enableDrag argument on CupertinoSheetRoute and showCupertinoSheet to disable the Cupertino bottom sheet’s drag-down-to-dismiss behavior. (#163923)

Navigation bars

CupertinoSliverNavigationBar.search sees fidelity improvements to its animation while opening or closing the search view, as well as correct alignment of the search field’s prefix and suffix icons.

Finally, the transition between routes with CupertinoNavigationBars or CupertinoSliverNavigationBars has been updated to match the latest iOS transitions (#164956).

Material

This release brings a range of feature enhancements and bug fixes to the Material library, improving both functionality and developer experience.

The feature enhancements include:

The CarouselController provides a more convenient animateToIndex method, enabling a smooth, index-based navigation for carousels, whether with fixed- or dynamically-sized items using flexWeights.

TabBar now has onHover and onFocusChange callbacks, giving you more control over the widget’s appearance in different states.

SearchAnchor and SearchAnchor.bar now include viewOnOpen and onOpen callbacks respectively, allowing for better observation and handling of open/close events.

CalendarDatePicker now accepts a calendarDelegate to enable the integration of custom calendar logic beyond the Gregorian Calendar System. The example demonstrates a hypothetical calendar system where even-numbered months have 21 days, odd-numbered months have 28 days, and every month starts on a Monday, showcasing the flexibility this delegate offers.

Other minor enhancements include adding animationStyle to showDialog, showAdaptiveDialog, and DialogRoute to customize the animation when the dialog is opened and closed; Divider now accepts a borderRadius to allow customizing the border of the divider, especially when the divider is thick.

Beyond the new features, this release also addresses several bugs related to DropdownMenu and Sliders in the Material library:

The DropdownMenu widget now allows its menu width to be smaller than the text field. The example has been updated to resolve a previous RenderFlex overflow error. The default width of DropdownMenu now respects the width of the text label in the text field.
When hovering over a RangeSlider thumb, only the overlay of the hovered thumb appears. Previously, both overlays would incorrectly show up. The Slider thumb can now reach both ends of the track when the track color is transparent, overcoming a prior limitation where it could not.

Accessibility

Optimized semantics tree compiling

This feature reduced semantics compilation time by ~80%. In Flutter for web, this translates to 30% reduction in frame time when semantics is enabled.

Introducing finely-grained semantics roles

A new SemanticsRole API has been integrated into the Semantics widget and its associated components, offering developers more precise control over how UI elements are interpreted by assistive technologies. This enhancement allows for the assignment of specific roles to an entire subtree of widgets by simply wrapping it with a Semantics widget configured with the desired role.

A list of available roles is detailed in the official API documentation. Currently, this advanced semantics role functionality is available for web-based applications, with support for other platforms coming in future releases.

For more information, see Enhancing accessibility with semantic roles.

Other accessibility improvements

Improved user experience for widgets and screen readers: Better accessibility support and user experience across various widgets, including text fields, focus handling, menus, sliders, and dropdowns. Screen readers now provide more descriptive feedback when users interact with these elements.
Smoother web-focus navigation with semantics: Refined web focus behavior when semantics are enabled, significantly reducing abrupt focus jumps between widgets for a more intuitive navigation experience.
Improved link recognition for Android TalkBack: Android TalkBack now correctly identifies and announces links defined using Semantics.linkUrl or the Link widget from the url_launcher package.
Windows high-contrast mode support in Flutter for web: Introduced support for Windows’ “forced colors” mode (often used in high contrast scenarios). Developers can now set the useSystemColors boolean in ThemeData to automatically apply system colors to Flutter themes, enhancing visibility for users who rely on these settings.
Refined iOS Voice Control experience: Improved the user experience for iOS Voice Control by ensuring that non-actionable widgets no longer display unnecessary labels, leading to a cleaner and more focused interaction for users.

Text input

Text input had several improvements in this release:

The system text selection context menu was launched on iOS, which is referenced in the iOS section below.
The layout of the Autocomplete widget’s options were ported to OverlayPortal, improving performance and fixing layout bugs.
It’s now possible to customize onTapUpOutside behavior in text fields (#162575).
Developers can now generate any widget they want as an error message for FormField instead of just error text (#162255).
Selectable text in Flutter became less buggy (#162228) and more performant on web (#161682).

Progress on multi-window support

Contributors from Canonical have made excellent progress towards allowing desktop applications to have multiple windows!

Canonical fixed several features that were broken when an app has multiple windows:

Accessibility: #164577
App lifecycle notifications: #164872
Focus: #164296
Keyboard events: #162131, #163962
Text input: #163847, #164014
Mouse events: #163855

Canonical also added a feature that lets Dart code FFI communicate directly to the Flutter engine (#163430). This lays the foundation for Flutter’s future windowing APIs.

Finally, Canonical introduced a raster thread on Linux (#161879). This improves frame throughput, ensuring Flutter Linux remains buttery smooth even if you have multiple windows.

Desktop thread merging

Canonical also updated Windows and macOS to allow apps to merge the UI and platform threads (#162883, #162935).

Merged threads let you use Dart FFI to interoperate with native APIs that must be called on the platform thread. For example, if you enable merged threads on Windows you can use Dart FFI to resize your app’s window using win32 APIs!

On Windows, you can turn on merged threads by adding the following to your windows/runner/main.cpp file, inside the wWinMain method:

project.set_ui_thread_policy(UIThreadPolicy::RunOnPlatformThread)

On macOS, you can turn on merged threads by adding the following to your macos/Runner/Info.plist file, inside the <dict> element:

<key>FLTEnableMergedPlatformUIThread</key>
<true />

In a future release, we will turn on merged threads by default on Windows and macOS. Please try this out and create issues if you run into any bugs!

iOS

We’ve enhanced the pasting experience in Flutter apps on iOS! For basic text fields without custom actions, users will no longer see a confirmation dialog when they paste content from other apps. This is now enabled by default on all Flutter iOS apps. Note, if your app uses custom actions (for example, “Send Email” in context menus), this feature is not yet supported.

Android

Kotlin language rewrite of Gradle tooling

Flutter’s Gradle plugin has been converted from Groovy to Kotlin. This transition to Kotlin makes the codebase easier to contribute to, and also facilitates the introduction of unit tests for the plugin. The added tests, as well as the conversion from a dynamically typed and executed language to a statically typed one, should result in a more stable and reliable build process for Flutter developers. We don’t expect any behavior changes as a result of the rewrite, so please file an issue if you notice Android builds behaving differently than you expect.

Scribe / Stylus support

You can now use your stylus to write into text fields on Android, in the same way that Apple Pencil handwriting input already works on Flutter iOS apps. Users can start writing directly on top of any Flutter text input field, and the handwriting will appear as text in the field. Not all gestures are supported yet, but we are working to close those gaps. This feature is supported on Android 14 and above and can be disabled, if needed, with theTextField.stylusHandwritingEnabled or CupertinoTextField.stylusHandwritingEnabled parameters.

Engine

Impeller on Android

Beginning from the 3.29.3 release, on devices running Android API level 28 (Android 9) and older, Flutter apps will use the legacy Skia renderer. This change improves the stability of Flutter on older Android devices. Impeller continues to be the default renderer on devices running API level 29 (Android 10) and newer.

As we get more feedback from users using different devices, we have adjusted which devices use Impeller’s Vulkan versus OpenGLES backend. In particular, in this release the following devices will use OpenGLES instead of Vulkan: the Android emulator, MediaTek devices with API version less than 31, PowerVR devices older than CXT, and older versions of Samsung’s XClipse GPUs that don’t support Vulkan 1.3.

As in prior releases, you can opt-out of Impeller by following these instructions. Due to our increasing confidence in Impeller’s stability and performance, the ability to opt-out of Impeller on newer Android devices will be removed in an upcoming stable release.

Finally, Flutter 3.27 has a number of rendering bugs and crashes related to Impeller rendering on Vulkan capable devices that are fixed in 3.29 and later versions. We do not plan to hotfix any of these changes into 3.27 and we highly recommend updating to 3.29 or later. If your application is unable to do so, we recommend opting out of Impeller on Android devices.

Other Impeller updates

This release improves Impeller’s text rendering. Notably, text animations are smoother with less jitter thanks to higher resolution glyphs in Impeller’s glyph atlas, and fixing rounding errors in floating point calculations. More details can be found in flutter#149652.

This release also includes a variety of other fidelity and performance improvements, including:

Conic curves are no longer approximated but tessellated directly
Partial repaint has been optimized to avoid frequent memory allocation
Blur speed has been improved by removing redundant attachments
Fixed orientation of text rotated exactly 180 degrees.

DevTools and IDEs

[New] Flutter Property Editor

Easily edit widget properties and read documentation from the new Property Editor tool, which is accessible from the Flutter Property Editor sidebar panel (VS Code) or tool window (Android Studio / IntelliJ).

Changes to the on-device Widget Inspector

The on-device Widget Inspector has a new button that can be used to toggle the widget selection behavior on or off while in Select Widget mode. This allows you to both interact with your app (for example, navigate to a new page) and select widgets while in Widget Selection mode.

DevTools improvements

Additional improvements have been made across DevTools, including new offline support for the Network screen, bug fixes for issues related to hot restart, text focus, the Deep Links tool, and data improvements for the CPU Profiler and Memory screens. This release also includes several performance and memory improvements for DevTools, which will result in faster data load times and fewer memory-related crashes.

These are just a few highlights from this release. To learn more about all the updates included in Flutter 3.32, check out the release notes for DevTools 2.44.0, 2.45.0 and 2.46.0.

Analyzer improvements

We have continued to make improvements to the Dart Analyzer, and hence the developer experience. This includes adding “doc imports,” a new comment-based syntax that enables external elements to be referenced in documentation comments without actually importing them. Check out the details on dart.dev. We’ve also made several quick fix, assist, and renaming improvements.

Gemini in Android Studio now speaks fluent Flutter and Dart

Gemini in Android Studio now offers first-class support for Dart and Flutter development! This means you can leverage the power of Gemini directly within your favorite IDE to build beautiful, high-performance Flutter apps faster and easier than ever before.

Read this blog post to learn more.

Dart and Flutter support for the Model Context Protocol (MCP) is on the way

Support for the Model Context Protocol (MCP) and the recently published Dart MCP SDK, is actively underway. A new Dart Tooling MCP Server, also under development, will expose Dart and Flutter static, runtime, and ecosystem tooling to MCP clients, such as IDEs.

This will drive the following benefits for Dart and Flutter developers:

More accurate and relevant code generation.
Complex tasks — like fixing layout issues, managing dependencies, or even resolving runtime errors — becomes feasible as the MCP protocol exposes semantic information from the actual Dart and Flutter tools.

Watch this space!

Build with AI

Introducing Firebase AI Logic

You might have heard of, or even used Vertex AI in Firebase, our client SDK for directly integrating Gemini API-driven functionality into your Flutter app.

Many of you asked to use the Gemini Developer API, instead of Vertex AI, to take advantage of the generous free tier and to start adding generative AI at no cost. We heard you! From today, we are evolving Vertex AI in Firebase to Firebase AI Logic that provides access to both Gemini API providers with just one Flutter SDK. It enables you to use Gemini and Imagen models directly from your Flutter app rather than needing a server-side SDK.

Check out the firebase_ai package for the new functionality. If you’re already using the firebase_vertexai package, it will continue to work as-is for now, but we encourage you to migrate to the new package.

Gain Actionable Insights with AI Monitoring dashboard

The new AI Monitoring dashboard in the Firebase console provides detailed, actionable insights into your Gemini API usage. This includes comprehensive visibility into consumption patterns, performance metrics, and potential issues. This enables data-driven decisions and ensures that you’re using the Gemini APIs in the most efficient way. AI Monitoring also helps you to debug your Gemini API usage, and identify and address any unexpected behaviors.

Breaking changes and deprecations

Android accessibility announcements

On Android, semantic announcement events are now deprecated, as of API 36. Instead, use “polite” implicit announcements by configuring a SemanticProperties.liveRegion. Currently, there is a known limitation when announcing text that should not be focusable. See issue #165857 for details on this limitation and the plans to resolve this issue. To see alternative solutions, check the documentation on SemanticService.announce.

Discontinued support for 6 packages

As we planned and shared in our Flutter 3.29 release blog post we have discontinued support for the following packages:

flutter_markdown; see flutter_markdown planned to be discontinued #162966
ios_platform_images; see ios_platform_images planned to be discontinued #162961
css_colors; see css_colors planned to be discontinued #162962
palette_generator; see palette_generator planned to be discontinued #162963
flutter_image; see flutter_image discontinued #162964
flutter_adaptive_scaffold; see flutter_adaptive_scaffold planned to be discontinued #162965

We encourage members of the community to refer to the discussion in each of the issues for alternatives.

iOS and macOS minimum versions

Flutter will deprecate support for iOS 12 and macOS 10.14 (Mojave) in the next stable release, and will target a minimum of iOS 13 and macOS 10.15 (Catalina). This means that apps built against future versions of Flutter won’t run on iOS 12 or macOS 10.14.

Other breaking changes

Other breaking changes and deprecations in this release include:

Deprecated the ExpansionTileController in Material in favor of the new reusable ExpansibleController in the Widgets layer.
Renamed SelectionChangedCause.scribble (which is deprecated), to SelectionChangedCause.stylusHandwriting, as Apple’s Scribble feature is now unified with Android’s Scribe.
As part of our continuing work to normalize Material theming, ThemeData.indicatorColor is deprecated in favor of TabBarThemeData.indicatorColor, while the component theme types for cardTheme, dialogTheme, and tabBarTheme will need to be migrated to CardThemeData, DialogThemeData, and TabBarThemeData, respectively.
The formula for SpringDescription in some behaviors has been corrected. This change fixes the problem where the behavior for some parameter combinations would not match expected real-world physics and exhibit discontinuity near the critical damping point. This breakage affects underdamped springs (damping ratio less than 1) with mass values other than 1. Such springs created prior to this change might exhibit different bouncing behaviors after upgrading. To restore previous animation behavior, update your spring parameters according to the Spring Description Underdamped breaking change guide, where you can also find a tool that calculates the parameter adjustments.

To see migration guides for all deprecations or breaking changes in this release, see the breaking changes page. Running dart fix after updating will automatically migrate some of these changes for you.

Conclusion

Flutter 3.32 marks another step forward, powered by the incredible dedication of our community. We’re thrilled to bring you features like web hot reload and continued platform improvements. Your contributions are invaluable, and we can’t wait to see what you build. For a comprehensive overview, check out the detailed release notes and changelog. To get started, simply run flutter upgrade and dive into the latest version!

$\"\"$

What’s new in Flutter 3.32 was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/40c1086bab6e","What’s new in Flutter 3.32",{"_2445":13},{"_8":2550,"_30":2551,"_2456":2457,"_2458":2552,"_2445":21,"_2460":2553,"_36":2554,"_2463":2555},754,"2025-05-09T15:58:03+00:00","

Google IO program lineup, Jetpack Compose 1.8, Play Console insights Android Vitals Metrics, Testing at Scale blog series and AndroidX!

Welcome to Now in Android, your ongoing guide to what’s new and notable in the world of Android development.

In this edition, we’ll cover the Google IO program lineup, what’s new in Jetpack Compose 1.8, the redesigned Play Console app dashboard, new Android Vitals Metrics, the launch of the Testing at Scale blog series, and the latest in AndroidX.

Most of the content of this post is available in the form of a video or podcast, so feel free to watch or listen rather than read on. (Or do all three to help you remember! There won’t be a quiz.)

Articles 📚

Get ready for Google I/O: Program lineup revealed 🗓️

The Google I/O agenda is now available, and you can register to explore sessions on AI, Android, Web, and Cloud, taking place May 20–21. The Google Keynote will be on May 20th at 10:00 AM PT, with the Developer Keynote at 1:30 PM PT. You can join online for livestreams May 20–21, with on-demand sessions and codelabs on May 22. Sessions will cover AI advancements using Gemini models, building apps for multiple devices using Google AI, and new features for web development.

Get ready for Google I/O: Program lineup revealed

What’s new in the Jetpack Compose April ’25 release 🚀

Jetpack Compose 1.8 is out with new features, API updates, and bug fixes. You can upgrade your Compose BOM version to 2025.04.01 to use the new release.

Here are some of the key updates:

You can now integrate Autofill functionality into your Compose applications.
The new autoSize parameter lets the text size adapt to the container size
The onLayoutRectChanged modifier solves many use cases that the existing onGloballyPositioned modifier does; however, it does so with much less overhead.
LookaheadScope is stable and includes numerous performance and stability improvements, and includes a new modifier, animateBounds

Check out the post to learn everything new in Jetpack Compose 1.8.

What's new in the Jetpack Compose April '25 release

The Fourth Beta of Android 16 🤖

Android 16 Beta 4 is out, marking the final scheduled update and platform stability. The developer APIs and app-facing behaviors are finalized.

Apps targeting Android 16 can now be made available in Google Play. This release includes the latest fixes and optimizations. Consider testing your apps against behavior changes around JobScheduler, broadcasts, ART, intents, 16KB page size, accessibility, and Bluetooth.

Note that if you develop an SDK, library, tool, or game engine, it’s even more important to prepare any necessary updates now to prevent your downstream app and game developers from being blocked by compatibility issues and allow them to target the latest SDK features.

While the API and behaviors are final and we are very close to release, we’d still like you to report issues on the feedback page. The earlier we get your feedback, the better chance we’ll be able to address it in this or a future release.

The Fourth Beta of Android 16

From dashboards to deeper data: Improve app quality and performance with new Play Console insights 📱

The Google Play Console has a redesigned app dashboard that centralizes quality-focused metrics, helping you improve app performance and user experience. The dashboard groups metrics into four core developer objectives:

test and release
monitor and improve
grow users
monetize with Play

A new notification center helps you stay up to date with your account and apps. New metrics include:

pre-review checks for incorrect edge-to-edge rendering
a low memory kill metric
excessive wake locks in Android vitals

To stay informed about all the latest Play Console enhancements and easily find updates relevant to your workflow, explore our new What’s new in Play Console page, where you can filter features by the four developer objectives.

From dashboards to deeper data: Improve app quality and performance with new Play Console insights

Boost app performance and battery life: New Android Vitals Metrics are here 🔋

The Android Developers blog announced new Android Vitals metrics aiming to help you improve app performance and battery life. The new metrics provide fleet-wide visibility into performance and battery life, equipping you with the data needed to diagnose and resolve performance bottlenecks. We just launched the first of these new metrics in beta: excessive wake locks. This metric directly addresses one of the most significant frustrations for Android users — excessive battery drain. By optimizing your app’s wake lock behavior, you can significantly enhance battery life and user satisfaction.

We launched the excessive wake lock metric documentation to provide clear guidance on interpreting the metrics. Please check out this page and provide feedback with your use case on this new metric. Your input is invaluable in refining these metrics before their general availability.

Boost app performance and battery life: New Android Vitals Metrics are here

Introducing Testing at Scale blog series

Android Developers Blog launches “Testing at Scale” series, featuring real-world testing strategies and tips from large apps. This series complements the new “Testing Strategies” documentation and offers opportunities for developers to contribute their own experiences. Check out the first two parts posted below:

Netflix App Testing At Scale

In part 1 of the “Testing at Scale” series Ken Yee, Senior Engineer at Netflix, tells us about the challenges of testing a playback app at a massive scale and how they have evolved the testing strategy.

Netflix’s Android app development prioritizes comprehensive testing, especially on physical devices due to wide device support. They’ve moved to native and are adopting Jetpack Compose. Their large team uses unit tests (Strikt, Turbine, Mockito, Hilt, Robolectric), screenshot tests (Paparazzi, Espresso accessibility), and device tests (Espresso, UIAutomator). Minimizing flakiness (state, async code) is key. They use a dedicated device lab and are exploring emulators, Roborazzi, and modular “demo apps” to improve testing efficiency. The team has created a custom toolchain to isolate and notify engineers of flaky tests. Feature developers own all aspects of testing.

Netflix App Testing At Scale

How Dropbox leverages testing to maintain high level of trust at scale

In part 2 of the “Testing at Scale” series Ryan Harter, Staff Engineer at Dropbox, shares how the shape of Dropbox’s testing pyramid changed over time, and what tools they use to get timely feedback.

Dropbox’s Android app development team utilizes a multi-faceted testing approach, emphasizing unit tests with tools like JUnit and Paparazzi for screenshot testing. They’re reinvesting in end-to-end tests, leveraging their own Dropshots library for full instrumentation testing and are experimenting with Compose Preview Screenshot Testing. They also integrate manual testing with web-based tools and third-party services for scenarios difficult to automate. They are expanding Dropshots to support multiple device configurations.

How Dropbox leverages testing to maintain high level of trust at scale

AndroidX Releases 🚀

Key Highlights for Compose Developers:

We have a bunch of new Compose APIs in alpha:

Compose Animation Version 1.9.0-alpha01

TabRow and ScrollableTabRow have been deprecated in favor of Primary and Secondary variants of each which are more performant and accurate to spec.
We added LocalResources composition local to query Resources. Calling LocalResources.current will recompose when the configuration changes, so calls to APIs such as stringResource() will return updated values.

Compose Foundation Version 1.9.0-alpha01

Breaking change: clickable, combinedClickable, selectable, toggleable, and triStateToggleable overloads without an Indication parameter now only support IndicationNodeFactory instances provided using LocalIndication. This change will apply when you recompile your usages of these modifiers using this version of Compose and is needed to enable improved performance, and allow Composable functions using these modifiers to skip during recomposition.

Compose Material Version 1.9.0-alpha01

Text field decoration box APIs are no longer experimental
runWithTimingDisabled is deprecated in favor of runWithMeasurementDisabled, which more clearly describes the behavior — all metrics are paused.

Compose Runtime Version 1.9.0-alpha01

currentCompositeKeyHash is deprecated. Use currentCompositeKeyHashCode instead.
@Stable, @Immutable, and @StableMarker have been moved to runtime-annotation (in a compatible way). You can now depend on runtime-annotation if you want to use these annotations from libraries that do not depend on compose.
@RememberInComposition was added — this is an annotation that can mark constructors, functions, and property getters, to indicate that they must not be called directly inside composition, without being remembered.

Compose UI Version 1.9.0-alpha01

androidx.compose.ui.LocalSavedStateRegistryOwner is deprecated in favor of androidx.savedstate.compose.LocalSavedStateRegistryOwner.
Modifier.keepScreenOn was added to set the display to not sleep while present

CustomView Version 1.2.0, CustomView-Poolingcontainer Version 1.1.0, Leanback Leanback-Preference, Version 1.2.0, Leanback-Grid Version 1.0.0, Leanback-Paging Leanback-Tab Version 1.1.0, and Print Version 1.1.0 are all released in stable.

Recent Release Notes | Android Developers

Now then… 👋

That’s it for this edition, with Google IO program lineup, Jetpack Compose 1.8, Play Console insights Android Vitals Metrics, Testing at Scale blog series, and the latest in AndroidX!

Check back soon for your next update from the Android developer universe!

$\"\"$

Now in Android #116 was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/d442393ebeb3","Now in Android #116",{"_2445":21},{"_8":2557,"_30":2558,"_2456":2457,"_2458":2559,"_2445":13,"_2460":2560,"_36":2561,"_2463":2562},753,"2025-04-24T16:23:03+00:00","

The way we build applications is evolving. Imagine apps that don’t just respond to user input but proactively assist, automate tasks, and create entirely new kinds of experiences. Welcome to the world of agentic apps!

Today, we’re thrilled to announce the launch of starter kits for our latest learning series, Building Agentic Apps, running from today, April 23rd to May 14th, 2025! It’s three weeks of new resources, livestreams, and questions & answers, all aimed at giving Angular and Flutter developers the chance to spend a couple weekends hacking on AI tech and in the process gain an understanding of the building blocks of AI, know where and when to put them to work, and build a completed example worth showing off.

What are agentic apps?

An agentic app includes user experiences powered by an agent — a combination of a large language model (LLM), a goal, and the tools (like APIs or functions) needed to achieve the goal. Picture a Flutter travel app that doesn’t just show destinations but also can generate a personalized packing list based on the weather forecast and planned activities, or an app that automatically summarizes your unread emails into a prioritized to-do list. With agents, apps can offer more help, be more proactive, and be easier to use than ever before.

Why now?

Because there’s no better time to become acquainted with the latest AI tools and see where they can (or can’t) help you deliver value to your users. By the end of three weeks, you’ll have built out an agentive experience and have a good handle on the terminology, the design patterns, and which user journeys are the most suited to AI, even if you’re a new developer!

What to Expect During the Campaign (April 23 — May 14):

Starter Kits: We’re releasing four open-source starter projects for Angular and Flutter developers, combining both with Genkit and Vertex AI in Firebase. They’re designed to give you the structure of an agentic experience that you can easily understand, modify, and repurpose.
Expert Guidance: Join livestreams and online events featuring engineers from the Flutter and Angular developer communities, Firebase, and Google AI teams. Ask questions, see live coding, and learn best practices.
Community: Connect with fellow developers, share your progress, and see what amazing things the community builds. We’re partnering with Google’s Build With AI series to make sure their in-person events have access to the new resources.

Get Started Today!

Register now by heading to goo.gle/BuildingAgenticFlutter or goo.gle/BuildingAgenticAngular. We can’t wait to see what you build!

$\"\"$

Learn how to build agentic apps with Flutter, Angular, Firebase, and Vertex AI was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/ad46b38b1adb","Learn how to build agentic apps with Flutter, Angular, Firebase, and Vertex AI",{"_2445":13},{"_8":2564,"_30":2565,"_2456":2457,"_2458":2566,"_2445":21,"_2460":2567,"_36":2568,"_2463":2569},752,"2025-04-23T21:39:22+00:00","

Android 16 Beta 3, Gemini in Studio for Business and Multimodal, Widgets, GDC, safety and security, Android XR, Media, Camera

Welcome to Now in Android, your ongoing guide to what’s new and notable in the world of Android development.

In this episode we’re covering the third beta of Android 16, Gemini in Android Studio for Business and Gemini Multimodal, Widgets, GDC announcements, safety and security updates on Play, Android XR, Media, Camera, and so, so much more.

Most of the content of this post is available in the form of a video or podcast, so feel free to watch or listen rather than read on. (Or do all three to help you remember! There won’t be a quiz.)

The Third Beta of Android 16 🤖

Android 16 has reached Platform Stability with Beta 3. The API surface is locked, app-facing behaviors are final, and you can now push Android 16-targeted apps to the Play Store.

The Android 16 beta now supports Auracast broadcast audio with compatible LE Audio hearing aids on Pixel 9 devices, It introduces outline text, replacing high contrast text, which draws a larger contrasting area around text to greatly improve legibility for users with low vision, and adds the ability to test the Local Network Protection feature, which gives users more control over which apps can access devices on their local network.

Make sure to test your apps for compatibility now, as the release is coming to non-beta users soon with changes to JobScheduler, broadcasts, ART, Intents, accessibility, Bluetooth, and more.

The Third Beta of Android 16

Gemini in Android Studio for businesses 🤖

Android Studio now has Gemini in Android Studio for businesses through Gemini Code Assist to meet the privacy, security, and management needs of organizations.

With Gemini Code Assist, your code remains secure with a data governance policy, you retain control and ownership of your data and IP, and you benefit from generative AI IP indemnification, safeguarding against copyright infringement claims related to AI-generated code.

With a Code Assist Enterprise license, you can connect to your GitHub, GitLab, or BitBucket repositories to get assistance customized to your organization’s codebases. Gemini in Android Studio also provides tailored assistance for Android developers, with features like build and sync error support, Gemini-powered App Quality Insights, and help with Logcat crashes.

Gemini in Android Studio for businesses: Develop with confidence, powered by AI

Multimodal image attachment is now available for Gemini in Android Studio 🖼️

Gemini in Android Studio now supports multimodal inputs, allowing you to attach images directly to prompts. To try this out, download the latest Android Studio canary.

With the image attachment icon in the Gemini chat window, you can attach JPEG or PNG files to prompts. You can convert wireframes or mockups into Jetpack Compose code, gain insights into architecture or data flow diagrams, and troubleshoot UI bugs by uploading screenshots and asking Gemini for solutions.

Multimodal image attachment is now available for Gemini in Android Studio

Widgets Take Center Stage with One UI 7 📱

Samsung’s One UI 7 offers greater personalization and an optimized, more prominent widget experience. Widgets put your brand and key features front and center on the user’s device, leading to better user engagement and more. Google Play now has a dedicated widgets search filter to help more easily identify apps with widgets, new widget badges on App Detail Pages and a curated widgets editorial page to help apps with widgets gain visibility and reach a wider audience.

Widgets take center stage with One UI 7

Spotlight Week: Design and Develop Widgets 🔦

We just finished the Widget Spotlight week, covering our new widget Quality Tiers, Canonical Layouts, the new Figma Widget Design Kit, Jetpack Glance, and the Coding Widgets layout video plus codelab to help you design and build amazing widgets.

Spotlight Week: Design and develop widgets

Google at GDC 🎮

Android and Google Play had a bunch of announcements at the annual Game Developers Conference (GDC) last month in San Francisco.

Building excellent games with better graphics and performance 🎮

Android announced that Vulkan is now the official graphics API, unlocking features like ray tracing and multithreading. If your game uses OpenGL, Android will use ANGLE to translate OpenGL to Vulkan.

The Android Dynamic Performance Framework (ADPF) has been updated to provide longer and smoother gameplay sessions. ADPF is designed to work across a range of devices and offers built-in support with game engines.

Play Console will include Low Memory Killers (LMK) in Android Vitals, providing insights into memory constraints that can cause your game to crash.

There is a pilot program to simplify bringing PC games to mobile, with games such as DREDGE and TABS Mobile growing their mobile audience using this program.

Building excellent games with better graphics and performance

Making Google Play the best place to grow PC games 💻

Google Play is improving its platform for PC games, providing better user experiences and new ways for developers to engage PC players.

You can use the Play Games PC SDK for native PC games on Google Play Games, providing tools like in-app purchase integration and security protection. You can distribute through the Play Console, where you can manage both mobile and PC game builds. There is a new earnback program that allows you to earn up to an additional 15% when you bring your PC games to Google Play Games on PC.

Mobile games will be available on PC by default, with the option to opt out. Games will have a playability badge indicating their compatibility with PC. We’re partnering with OEMs to make Google Play Games accessible from the start menu on new devices this year. New features such as custom controls are now available to help players tailor their setup, and multi-account and multi-instance support are being added.

In addition, Play Points will be easier to track and more rewarding on PC, with up to 10x points boosters, and Google is working on a solution to help you run user acquisition campaigns for both emulated mobile and native PC titles within Google Play Games on PC.

Making Google Play the best place to grow PC games

Android XR launch recap: Build immersive experiences with your existing Android skills!

We announced the Android XR developer preview, a unified platform for XR development using familiar tools and Open Standards. You can use Android Studio, Jetpack libraries, and Compose for XR (for simplified UI development). Unity developers get support for Unity’s editor and XR packages. Apps will be distributed via the Play Store. Key features include eye, voice, and hand multimodal input, Android accessibility features, automatic adaptation of your existing large-screen compatible apps, Jetpack XR SDK with ARCore, and Unity support based on OpenXR.

Strengthening Our App Ecosystem: Enhanced Tools for Secure & Efficient Development 🛡️

Google is enhancing safety and security on Google Play and Android by providing tools that make it easier for you to build secure apps.

Here are some of the ways Google is improving the app ecosystem:

Play Console pre-review checks now include the ability to check privacy policy links and login credential requirements. More pre-review checks are planned for this year.
Notifications in Android Studio alert you to relevant policies as you code. This year, the notifications will expand to cover a wider range of policies.
Google is improving its policy experience to give you clearer updates and more time for substantial changes.
The Google Play Developer Help Community will be expanded to include more languages, such as Indonesian, Japanese, Korean, and Portuguese.
Apps using the Play Integrity API features are seeing an 80% drop in unauthorized usage on average compared to other apps.
Google will enhance the Play Integrity API with stronger protection for even more users and is improving the technology that powers the API on all devices running Android 13 (API level 33) and above.
Badges will be added to more app categories in the future.
Credential Manager API is now in Beta for Digital IDs.
Google Play Protect live threat detection is expanding its protection to target malicious applications that try to impersonate financial apps.

Strengthening our app ecosystem: Enhanced tools for secure & efficient development

Articles 📚

The Google Play team covered how you can prioritize media privacy in your app, recommending requesting only essential permissions, and using the Android Photo Picker instead of requesting broad storage access. Be transparent with users about why your app needs access to their photos and videos if you’re using a custom picker.

Prioritize media privacy with Android Photo Picker and build user trust

#WeArePlay talked about how Memory Lane Games helps people with dementia, and how they’re offering deeply personal games in multiple languages. Co-founder Bruce was inspired by his mother and co-founder Peter’s mother, who, despite having vascular dementia, lit up when looking at old family photos.

The creators strive for frustration-free game design and Generative AI may be used to create personalized and localized game content, with the goal to offer deeply personal games in multiple languages.

#WeArePlay | How Memory Lane Games helps people with dementia

Nevin covered common media processing operations with Jetpack Media 3 Transformer, including common editing operations such as:

Transcoding: Re-encode an input file into a specified output format.
Trimming: Set Transformer up to trim the input video from a start to end point.
Muting: Mute the audio in the exported video file.
Resizing: Resize the input video by scaling it down (or up) to a specified height and width.

Transformer prioritizes transmuxing (repackaging video streams without re-encoding) for basic video edits where possible. When not possible, Transformer falls back to transcoding (decoding video samples into raw data, then re-encoding them for storage in a new container).

Common media processing operations with Jetpack Media3 Transformer

Jolanda showed how to implement smooth transitions for foldable devices entering tabletop mode using CameraX and Compose. Key takeaways include:

Leveraging Adaptive APIs: Update dependencies to utilize the latest animation and adaptive APIs, including Compose 1.8 and material3-adaptive.
Utilizing Rulers: Use Compose 1.7.0’s rulers (accessible via currentWindowAdaptiveInfo()) to determine hinge position for layout adjustments.
Animating Bounds: Employ Modifier.animateBounds() within a LookaheadScope to animate composable bounds during mode transitions (flat to tabletop).
Using Animated Visibility: Consider using AnimatedVisibility to create a dynamic control panel that can be positioned relative to the hinge.

Adaptive Camera: Smooth Tabletop Mode with Animations

Since Android 16 requires you to make WebViews edge-to-edge, Ash covered best practices for doing so, such as:

If you don’t own the WebView content, wrap the WebView and pad it.
If you do own the content, use the `viewport-fit=cover` meta tag, CSS variables for safe area insets, and JavaScript to inject padding. Handle IME insets to avoid keyboard overlap.

Make WebViews edge-to-edge

Cyril over at Amo covered how they leveraged Jetpack Compose to create a delightful user experience through touch-based feedback using graphics, haptics, and sound. Bump’s implementation of custom audio, shader-based animations, and interactive map elements are all built with the Android SDK, Jetpack Compose, Kotlin, and Google Play Services.

Bump’s Journey into Delightful Experiences on Android with Jetpack Compose

Videos 📹

Google Play’s April 2025 policy updates impact Android developers in several key areas:

News Apps: New policies require News and Magazine apps to complete a self-declaration form, update Play Store listings, regularly update content with named sources, and avoid affiliate marketing/ad revenue focus.
Financial Services (Line of Credit): Apps facilitating lines of credit are now included under personal loan policies, prohibiting access to sensitive user data and requiring adherence to stricter permission policies.
User Data: New best practices emphasize compliance with data protection laws (e.g., GDPR) and provide resources for doing so. Regular compliance checks are recommended.
Photos & Videos: Reminder that apps accessing photos and videos require a declaration form by May 28, 2025, and must only access them for direct functionality purposes.

Christopher, Nam, and Carmen covered how the Android team is working to improve Android app startup performance, focusing on bridging the performance gap between initial launch and subsequent runs. Key takeaways include:

Baseline Profiles & Dex Optimization: Crucial for improving startup time.
Avoid JIT Compilation: Identify and strategically load expensive dependencies to minimize just-in-time compilation.
Perfetto Traces: Use Perfetto to debug performance issues and verify optimization changes.

SDK Runtime

We’ve got two new videos covering the SDK Runtime, a new way to work with third party code in your app.

Anatomy of the SDK Runtime covers how the SDK Runtime in the Privacy Sandbox isolates third-party SDKs into their own sandboxes, enhancing user privacy and app security. Key takeaways:

SDKs run in their own process, separate from the main app.
Android SDK Bundles (ASBs) are the distribution format.
Development targets Android 11+, with Jetpack providing backward compatibility.
SDKs have restricted permissions and communication.
Jetpack simplifies inter-process communication.

Introduction to the SDK Runtime covers the features and benefits of the tech both for you and for your app’s users. The SDK Runtime isolates third-party Software Development Kits (SDKs) — common sources of app functionality like ads or analytics — into a separate environment. Benefits of this include:

Enhanced Privacy: Restricts SDK access to sensitive user data.
Improved Security: Helps prevent malicious SDK behavior and ad fraud.
Increased Stability: Reduces app crashes caused by third-party code.
Faster Updates: Allows for quicker deployment of SDK security patches.

Check out the new runtime to help build more secure and private experiences.

The Google Play “Best of 2024” awards highlighted Infinite Painter which reduced inking latency by 5x using the graphics core and input motion prediction Jetpack libraries.

Compose for Android TV allows you to reuse existing business logic and architecture from your mobile apps to accelerate TV app development, and this Compose for TV video from Paul shows you how. The recommended approach is to separate business logic from UI-specific view models, enabling the creation of dedicated TV UIs using TV-specific Compose components (from the TV material artifact) with focus management features like `onFocusChanged` and `bringIntoViewSpec`. Building a modular architecture with shared UI components, domain models, and data layers enhances code reuse across form factors.

AndroidX Releases 🚀

There’s a bunch of new stuff in AndroidX, headlining:

Media3 1.6.0 — what’s new? 🚀

Media3 version 1.6.0 is now available, which includes bug fixes, performance improvements, and new features.

ExoPlayer now supports HLS interstitials for ad insertion in HLS streams.
You can enable experimental support for pre-warming decoders on the DefaultRenderersFactory.
A new media3-ui-compose module is available for building Compose UIs for playback.
MediaExtractorCompat is a drop-in replacement for the framework MediaExtractor but implemented using Media3’s extractors.
You can use the new ExperimentalFrameExtractor class to retrieve video frames.
Dolby Vision streams are now supported for transcoding/transmuxing on devices that support this format.

Media3 1.6.0 - what's new?

Jetpack WindowManager 1.4 is stable 📱

Jetpack WindowManager 1.4 is now stable, introducing new features for building adaptive apps.

WindowSizeClass API is updated to support custom values.
Activity stack pinning provides a way to keep an activity stack always on screen.
Pane expansion lets you create a visual separation between two activities in split-screen mode.
Dialog full-screen dim lets you choose to dim just the container where the dialog appears or the entire task window.
Enhanced posture support allows you to access the WindowInfoTracker#supportedPostures API to determine if a device supports tabletop mode.

Jetpack WindowManager 1.4 is stable

Health Connect Jetpack SDK is now in beta with new feature updates 🧪

The Health Connect Jetpack SDK is now in beta. The beta release includes mandatory recording methods and device types for more accurate and insightful data.

New permissions let your app access Health Connect data while running in the background, if the user grants consent. The PERMISSION_READ_HEALTH_DATA_HISTORY permission enables access to user data beyond the default 30-day window.

Health Connect now also offers expanded data types, such as Exercise Routes and skin temperature.

Unlock deeper health insights: Health Connect Jetpack SDK is now in beta and new feature updates

Unit Testing Lifecycle and State in ViewModels

Android app developers should note that Lifecycle 2.9.0-alpha08 introduces ViewModelScenario for easier unit testing of ViewModels. This new tool simplifies testing ViewModel lifecycle and state restoration, including SavedStateHandle functionality, and ensures ViewModel.onCleared() is properly called. ViewModelScenario is also KMP compatible, facilitating cross-platform development.

Unit Testing Lifecycle and State in ViewModels

Other Highlights:

androidx.core:core-i18n:1.0.0:

A significant new library designed to simplify internationalization (i18n) in Android apps. It offers improved date/time formatting that respects user settings (unlike android.icu.text.MessageFormat) and provides a backport of android.icu.text.MessageFormat that integrates well with the new date/time formatting. This is important if you want to support diverse locales and user preferences for date and time display.

androidx.webkit:webkit:1.14.0-alpha01:

Introduces the PaymentRequest API to allow Android native payment apps to be invoked from a WebView, but developers must explicitly enable it and add a <queries> tag to their manifest. It also introduces experimental APIs for enhanced WebView navigation tracking and WebViewCompat#saveState to manage WebView state saving.

androidx.datastore:datastore-:1.2.0-alpha01:

Adds a datastore-guava module to expose APIs friendly to Java and Guava ListenableFuture users via GuavaDataStore. Also supports DataStore usage during DirectBoot mode, requiring creation within Device Protected storage.

androidx.wear:wear-phone-interactions:1.1.0:

Includes a critical bug fix for Wear OS 5 (API 34+) apps targeting API 35+. Update before* targeting API 35 to avoid runtime exceptions.

androidx.dynamicanimation:dynamicanimation:1.1.0:

The DynamicAnimation library is now stable.

androidx.activity:activity:1.11.0-beta01:

Added MediaCapabilities API to PickVisualMediaRequest to let applications specify its media capabilities.

androidx.games libraries:

Upgrades to Gradle 8.8.1 and Java 17, fixes bugs. games-frame-pacing includes various bug fixes.

Android Developers Backstage🎙️

Tor, Chet, Romain, Theresa, and Naheed took a deep dive into what Google’s doing around app safety, including the SDK Index, pre-review checks, and Safety Labels to help you build secure apps and protect users from suspicious activity, tying into the Strengthening our app ecosystem blog post.

Strengthening our app ecosystem: Enhanced tools for secure & efficient development

Now then… 👋

That’s it for this edition, with third beta of Android 16, Gemini in Android Studio for Business and Gemini Multimodal, Widgets, GDC announcements, safety and security updates on Play, Android XR, Media, Camera, a ton of AndroidX updates, and much more.

Check back soon for your next update from the Android developer universe!

$\"\"$

Now in Android #115 was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/d13a60cbf092","Now in Android #115",{"_2445":21},{"_8":2571,"_30":2572,"_2456":2457,"_2458":2573,"_2445":21,"_2460":2574,"_36":2575,"_2463":2576},751,"2025-04-23T17:26:09+00:00","

This is part 2 of the Testing at scale series of articles where we asked industry experts to share their testing strategies. In this article, Ryan Harter, Staff Engineer at Dropbox, shares how the shape of Dropbox’s testing pyramid changed over time, and what tools they use to get timely feedback.

With more than one billion downloads, the Dropbox app for Android has to maintain a high quality bar for a diverse set of use cases and users. With less than 30 Android engineers, manual testing and #yolo isn’t enough to maintain confidence in our codebase, so we employ a variety of different testing strategies to ensure we can continually serve our users needs.

Since Dropbox makes it easy to access your files across all of your devices, the Android app has to support viewing as many of those files as possible, including media files, documents, photos, and all of the variations within these categories. Additionally, features like Camera Uploads, which automatically backs up all of your most important photos, require deep integration with the Android OS in ways that have changed significantly over the years and across Android versions. All of this needs to continually work for our users, without them having to worry about the complexity, because the last thing anyone wants is to worry that they might lose their data.

While the size and distribution of the Android team at Dropbox has changed throughout the years, it’s imperative that we’re able to consistently build and refine features within the app while maintaining the level of trust from our users that we’ve become known for. To help underscore how Dropbox has been able to foster that trust, I’d like to share some ways that our testing strategies have changed over the years.

How it started

While automated testing has always been an important part of engineering culture at Dropbox, it hasn’t always been easy on Android. Years ago Dropbox invested in testing infrastructure that leaned heavily on End-to-End (E2E) testing. Built on Android’s instrumentation tests, we developed test helpers for features in the app following the test robot pattern. This enabled a large suite of tests to be created that could simulate a user moving throughout the app, but came with its own significant costs.

Like many Android projects at the time, the Dropbox app started out as a monolithic app module, but that wasn’t sustainable in the long run. Work was done to decompose the monolith into a more modular architecture, but the E2E test suite wasn’t prioritized in this effort due to the complex interplay of dependencies. This left our E2E test suite as a monolith of its own, resulting in test code that didn’t exist alongside the feature code it exercised, allowing them to easily be overlooked and become outdated.

Additionally, the long build times that come with monolithic modules with many dependencies mixed with the tests being executed on emulators in our custom continuous integration (CI) environment meant that the feedback cycle for these E2E tests was slow. This resulted in engineers feeling incentivised to remove failing tests instead of updating them.

As the Android ecosystem embraced automated testing more and more, with the introduction of helpful libraries like Espresso, Robolectric, and support for unit testing built directly into Gradle, Dropbox kept up with these changes by moving from the heavy reliance on E2E tests towards more and more unit tests, filling out the bottom layer of the previously inverted testing pyramid. This was a significant win for test coverage within the app, and allowed us to roll out quality assurance practices like code coverage baselines, to ensure that we continually improved the reliability of the product as it moved forward.

Over time, as unit testing became easier and easier and engineers became more and more frustrated with the slow feedback cycles of E2E tests, our testing pyramid became lopsided in the other direction. We had confidence in our unit tests and the infrastructure supporting them, but our E2E tests aged without much support, becoming more and more unreliable, to the point that we mostly ignored their failures. Tests that can’t be trusted end up becoming a maintenance burden and provide little value, so we recognized that something needed to change.

How it’s going

Over the past year we’ve doubled down on our focus on reliability. We’ve invested in our test infrastructure to ensure that engineers are not only able to, but incentivised to write valuable tests across all layers of the testing pyramid. In addition to technical investment in code and tooling, that has also required that we take the time to evaluate the things we test, and how we test them, and make sure the entire team has a better understanding of which tools to use when.

Unit testing

We continue to spend most of our efforts writing unit tests. These are fast, focused tests that provide quick feedback, and serve as our first line of defense against regressions. We write JUnit tests whenever we can, and fall back to instrumentation tests when we need to. Robolectric’s interoperability with AndroidX Test has allowed us to move many of our instrumentation tests to JVM-based unit tests, making it even easier to meet our test coverage goals.

Speaking of test coverage goals, the unit testing layer is the only layer that we use to determine our code coverage. By default we target 80% test coverage, though we have a process to override this target for circumstances in which unit testing is either not valuable, or infeasible.

Note: While we use standard JaCoCo tooling to evaluate our test coverage, its lack of deep understanding of Kotlin presents some challenges. For instance, we haven’t yet found a way to inform JaCoCo that the generated accessors, toString and hashcode of behaviorless data classes don’t require test coverage. We’ve been experimenting and considering alternatives to ensure that we’re not writing brittle tests that don’t provide value, but for now we are stuck with issuing coverage overrides for these cases.

E2E testing

Over the past several months we’ve been renewing investment in our automated E2E test suite. This test suite is able to alert us to extremely important issues that unit tests simply can’t identify, like OS integration issues or unexpected API responses. Therefore we’ve worked hard to improve our infrastructure to make tests easier for engineers to run locally, we’ve audited and removed flaky or invalid tests, and worked on documentation and training to ensure that we support our engineers in the creation and maintenance of our E2E test suite.

Change in E2E test counts before and after test suite improvement effort.

As I mentioned above, our E2E tests simulate a user moving throughout the app. This means that the task of defining our E2E test cases is more than simply an engineering problem. Therefore, we developed guidance to help engineers work with product and design partners to define test cases that represent true use cases.

We recently introduced a practice of using a proper Definition of Done for development work. This amounts to a checklist of items that must be completed in order for a project to be considered “done”, which is defined and agreed upon at the beginning of the project. Our standard checklist includes the declaration of E2E test cases for the project, which ensures that we are adding test cases in a thoughtful manner, taking into account the value and purpose of those tests, instead of targeting arbitrary coverage numbers.

Screenshot testing

Another dimension of our tests that we’ve ramped up in recent years is screenshot testing. Screenshot tests allow us to validate against visual regressions, ensuring that views render properly in light and dark mode, different orientations, and different form factors.

In unit tests we leverage Paparazzi for screenshot testing. This allows us to write fast, isolated tests and we find it’s best suited for testing individual view or composable layouts, including our design system components.

We also find value executing screenshot tests in more full featured instrumentation tests. For this, we use our own Dropshots library, which supports screenshot testing on devices and emulators. Since Dropshots executes screenshot tests on real (or emulated) devices, it is a great way to validate system integrations like edge-to-edge display, the default window mode on Android 15 devices.

Manual testing

With all of the investment we’ve made into automated testing you’d be forgiven for thinking that we do no manual testing, but even today that’s simply not feasible. There are many workflows for which automated tests would either be too hard to write, or too hard to validate. For example, we have both unit and E2E tests to validate that the app behaves appropriately when rendering file content, but it can be hard to programmatically validate file content, and screenshot tests can sometimes prove too flaky.

For these cases, we use a web based test case management tool to maintain a complete set of manual test cases, and a third party testing service to execute the tests prior to each release. This allows us to catch issues for which we haven’t yet written tests, or which require human judgement.

Looking forward

Testing has proven invaluable in identifying quality issues before they make it to users, allowing us to earn our customer’s trust. Given that value, we intend to continue investing in testing to ensure that we can continue to maintain high quality and reliability. There are a few things that we’re looking forward to in the future.

I’m currently in the process of expanding the functionality of Dropshots to support multiple device configurations, which will allow us to perform screenshot tests across a broad range of devices with a single set of tests. Since the Dropbox app works across many different form factors, it will be valuable for us to simultaneously run our screenshot test suite on a variety of devices or emulators to prevent regressions on less common form factors.

Additionally, we’re beginning to experiment with Compose Preview Screenshot Testing, which allows our Compose Preview functions to serve double duty by speeding up development cycles while also being used to protect against regressions.

Finally, we intend to continue ensuring that we have a good balance of the right kinds of tests. Balancing our testing pyramid to ensure that our investment in testing serves our reliability goals instead of chasing arbitrary coverage targets. We’ve already seen the value that a healthy test suite can provide, and we’ll continue investing in this area to ensure that we continue to be worthy of trust.

$\"\"$

How Dropbox leverages testing to maintain high level of trust at scale was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/b7b1bdf6161e","How Dropbox leverages testing to maintain high level of trust at scale",{"_2445":21},{"_8":2578,"_30":2579,"_2456":2457,"_2458":2580,"_2445":21,"_2460":2581,"_36":2582,"_2463":2583},729,"2025-04-16T15:55:49+00:00","

This is part of the Testing at scale series of articles where we asked industry experts to share their testing strategies. In this article, Ken Yee, Senior Engineer at Netflix, tells us about the challenges of testing a playback app at a massive scale and how they have evolved the testing strategy since the app was created 14 years ago!

Introduction

Testing at Netflix continuously evolves. In order to fully understand where it’s going and why it’s in its current state, it’s also important to understand the historical context of where it has been.

The Android app was started 14 years ago. It was originally a hybrid application (native+webview), but it was converted over to a fully native app because of performance issues and the difficulty in being able to create a UI that felt/acted truly native. As with most older applications, it’s in the process of being converted to Jetpack Compose. The current codebase is roughly 1M lines of Java/Kotlin code spread across 400+ modules and, like most older apps, there is also a monolith module because the original app was one big module. The app is handled by a team of approximately 50 people.

At one point, there was a dedicated mobile SDET (Software Developer Engineer in Test) team that handled writing all device tests by following the usual flow of working with developers and product managers to understand the features they were testing to create test plans for all their automation tests. At Netflix, SDETs were developers with a focus on testing; they wrote Automation tests with Espresso or UIAutomator; they also built frameworks for testing and integrated 3rd party testing frameworks. Feature Developers wrote unit tests and Robolectric tests for their own code. The dedicated SDET team was disbanded a few years ago and the automation tests are now owned by each of the feature subteams; there are still 2 supporting SDETs who help out the various teams as needed. QA (Quality Assurance) manually tests releases before they are uploaded as a final “smoke test”.

In the media streaming world, one interesting challenge is the huge ecosystem of playback devices using the app. We like to support a good experience on low memory/slow devices (e.g. Android Go devices) while providing a premium experience on higher end devices. For foldables, some don’t report a hinge sensor. We support devices back to Android 7.0 (API24), but we’re setting our minimum to Android 9 soon. Some manufacturer-specific versions of Android also have quirks. As a result, physical devices are a huge part of our testing

Current Testing Approach

As mentioned, feature developers now handle all aspects of testing their features. Our testing layers look like this:

\"\" — Test Pyramid showing layers from bottom to top of: unit tests, screenshot tests, E2E automation tests, smoke tests

However, because of our heavy usage of physical device testing and the legacy parts of the codebase, our testing pyramid looks more like an hourglass or inverted pyramid depending on which part of the code you’re in. New features do have this more typical testing pyramid shape.

Our screenshot testing is also done at multiple levels: UI component, UI screen layout, and device integration screen layout. The first two are really unit tests because they don’t make any network calls. The last is a substitute for most manual QA testing.

Unit Test Frameworks

Unit tests are used to test business logic that is not dependent on any specific device/UI behavior. In older parts of the app, we use RxJava for asynchronous code and streams are tested. Newer parts of the app use Kotlin Flows and Composables for state flows which are much easier to reason about and test compared to RxJava.

Frameworks we use for unit testing are:

Strikt: for assertions because it has a fluent API like AssertJ but is written for Kotlin
Turbine: for the missing pieces in testing Kotlin Flows
Mockito: for mocking any complex classes not relevant for the current Unit of code being tested
Hilt: for substituting test dependencies in our Dependency Injection graph
Robolectric: for testing business logic that has to interact in some way with Android services/classes (e.g., parcelables or Services)
A/B test/feature flag framework: allows overriding an automation test for a specific A/B test or enabling/disabling a specific feature

Developers are encouraged to use plain unit tests before switching to Hilt or Robolectric because execution time goes up 10x with each step when going from plain unit tests -> Hilt -> Robolectric. Mockito also slows down builds when using inline mocks, so inline mocks are discouraged. Device tests are multiple orders of magnitude slower than any of these types unit tests. Speed of testing is important in large codebases.

Flakiness in Unit Tests

Because unit tests are blocking in our CI pipeline, minimizing flakiness is extremely important. There are generally two causes for flakiness: leaving some state behind for the next test and testing asynchronous code.

JVM (Java Virtual Machine) Unit test classes are created once and then the test methods in each class are called sequentially; instrumented tests in comparison are run from the start and the only time you can save is APK installation. Because of this, if a test method leaves some changed global state behind in dependent classes, the next test method can fail. Global state can take many forms including files on disk, databases on disk, and shared classes. Using dependency injection or recreating anything that is changed solves this issue.

With asynchronous code, flakiness can always happen as multiple threads change different things. Test Dispatchers (Kotlin Coroutines) or Test Schedulers (RxJava) can be used to control time in each thread to make things deterministic when testing a specific race condition. This will make the code less realistic and possibly miss some test scenarios, but will prevent flakiness in the tests.

Screenshot Test Frameworks

Screenshot testing frameworks are important because they test what is seen vs. testing behavior. As a result, they are the best replacement for manual QA testing of any screens that are static (animations are still difficult to test with most screenshot testing frameworks unless the framework can control time).

We use a variety of frameworks for screenshot testing:

Paparazzi: for Compose UI components and screen layouts; network calls can’t be made to download images, so you have to use static image resources or an image loader that draws a pattern for the requested images (we do both)
Localization screenshot testing: captures screenshots of screens in the running app in all locales for our UX teams to verify manually
Device screenshot testing: device testing used to test visual behavior of the running app

Espresso accessibility testing: this is also a form of screenshot testing where the sizes/colors of various elements are checked for accessibility; this has also been somewhat of a pain point for us because our UX team has adopted the WCAG 44dp standard for minimum touch size instead of Android’s 48dp.

Device Test Frameworks

Finally, we have device tests. As mentioned, these are magnitudes slower than tests that can run on the JVM. They are a replacement for manual QA and used to smoke test the overall functionality of the app.

However, since running a fully working app in a test has external dependencies (backend, network infra, lab infra), the device tests will always be flaky in some way. This cannot be emphasized enough: despite having retries, device automation tests will always be flaky over an extended period of time. Further below, we’ll cover what we do to handle some of this flakiness.

We use these frameworks for device testing:

Espresso: majority of device tests use Espresso which is Android’s main instrumentation testing framework for user interfaces
PageObject test framework: internal screens are written as PageObjects that tests can control to ease migration from XML layouts to Compose (see below for more details)
UIAutomator: a small “smoke test” set of tests uses UIAutomator to test the fully obfuscated binary that will get uploaded to the app store (a.k.a., Release Candidate tests)
Performance testing framework: measures load times of various screens to check for any regressions
Network capture/playback framework: allows playback of recorded API calls to reduce instability of device tests
Backend mocking framework: tests can ask the backend to return specific results; for example, our home page has content that is entirely driven by recommendation algorithms so a test can’t deterministically look for specific titles unless the test asks the backend to return specific videos in specific states (e.g. “leaving soon”) and specific rows filled with specific titles (e.g. a Coming Soon row with specific videos)
A/B test/feature flag framework: allows overriding an automation test for a specific A/B test or enabling/disabling a specific feature
Analytics testing framework: used to verify a sequence of analytics events from a set of screen actions; analytics are the most prone to breakage when screens are changed so this is an important thing to test.

PageObjects and Test Steps

The PageObject design pattern started as a web pattern, but has been applied to mobile testing. It separates test code (e.g. click on Play button) from screen-specific code (e.g. the mechanics of clicking on a button using Espresso). Because of this, it lets you abstract the test from the implementation (think interfaces vs. implementation when writing code). You can easily replace the implementation as needed when migrating from XML Layouts to Jetpack Compose layouts but the test itself (e.g. testing login) stays the same.

In addition to using PageObjects to define an abstraction over screens, we have a concept of “Test Steps”. A test is composed of test steps. At the end of each step, our device lab infra will automatically create a screenshot. This gives developers a storyboard of screenshots that show the progress of the test. When a test step fails, it’s also clearly indicated (e.g., “could not click on Play button”) because a test step has a “summary” and “error description” field.

Device Automation Infrastructure

Netflix was probably one of the first companies to have a dedicated device testing lab; this was before 3rd party services like Firebase Test Lab were available. Our lab infrastructure has a lot of features you’d expect to be able to do:

Target specific types of devices
Capture video from running a test
Capture screenshots while running a test
Capture all logs

Interesting device tooling features that are uniquely Netflix:

Cellular tower so we can test wifi vs. cellular connections; Netflix has their own physical cellular tower in the lab that the devices are configured to connect to.
Network conditioning so slow networks can be simulated
Automatic disabling of system updates to devices so they can be locked at a specific OS level
Only uses raw adb commands to install/run tests (all this infrastructure predates frameworks like Gradle Managed Devices or Flank)
Running a suite of automated tests against an A/B tests
Test hardware/software for verifying that a device doesn’t drop frames for our partners to verify their devices support Netflix playback properly; we also have a qualification program for devices to make sure they support HDR and other codecs properly.

If you’re curious about more details, look at Netflix’ tech blog.

Handling Test Flakiness

As mentioned above, test flakiness is one of the hardest things about inherently unstable device tests. Tooling has to be built to:

Minimize flakiness
Identify causes of flakes
Notify teams that own the flaky tests

Tooling that we’ve built to manage the flakiness:

Automatically identifies the PR (Pull Request) batch that a test started to fail in and notifies PR authors that they caused a test failure
Tests can be marked stable/unstable/disabled instead of using @Ignore annotations; this is used to disable a subset of tests temporarily if there’s a backend issue so that false positives are not reported on PRs
Automation that figures out whether a test can be promoted to Stable by using spare device cycles to automatically evaluate test stability
Automated IfTTT (If This Then That) rules for retrying tests or ignoring temporary failures or repairing a device
Failure report let us easily filter failures according to what device maker, OS, or cage the device is in, e.g. this shows how often a test fails over a period of time for these environmental factors:

\"\" — Test failures over time grouped by environmental factors like staging/prod backend, OS version, phone/tablet

Failure report lets us triage error history to identify the most common failure reasons for a test along with screenshots:

Tests can be manually set up to run multiple times across devices or OS versions or device types (phone/tablet) to reproduce flaky tests

CI/Testing Pipelines

We have a typical PR (Pull Request) CI pipeline that runs unit tests (includes Paparazzi and Robolectric tests), lint, ktLint, and Detekt. Running roughly 1000 device tests is part of the PR process. In a PR, a subset of smoke tests is also run against the fully obfuscated app that can be shipped to the app store (the previous device tests run against a partially obfuscated app).

Extra device automation tests are run as part of our post-merge suite. Whenever batches of PRs are merged, there is additional coverage provided by automation tests that cannot be run on PRs because we try to keep the PR device automation suite under 30 minutes.

In addition, there are Daily and Weekly suites. These are run for much longer automation tests because we try to keep our post-merge suite under 120 minutes. Automation tests that go into these are typically long running stress tests (e.g., can you watch a season of a series without the app running out of memory and crashing?).

In a perfect world, you have infinite resources to do all your testing. If you had infinite devices, you could run all your device tests in parallel. If you had infinite servers, you could run all your unit tests in parallel. If you had both, you could run everything on every PR. But in the real world, you have a balanced approach that runs “enough” tests on PRs, postmerge, etc. to prevent issues from getting out into the field so your customers have a better experience while also keeping your teams productive.

Coverage

Coverage on devices is a set of tradeoffs. On PRs, you want to maximize coverage but minimize time. On post-merge/Daily/Weekly, time is less important.

When testing on devices, we have a two dimensional matrix of OS version vs. device type (phone/tablet). Layout issues are fairly common, so we always run tests on phone+tablet. We are still adding automation to foldables, but they have their own challenges like being able to test layouts before/after/during the folding process.

On PRs, we normally run what we call a “narrow grid” which means a test can run on any OS version. On Postmerge/Daily/Weekly, we run what we call a “full grid” which means a test runs on every OS version. The tradeoff is that if there is an OS-specific failure, it can look like a flaky test on a PR and won’t be detected until later.

Future of Testing

Testing continuously evolves as you learn what works or new technologies and frameworks become available. We’re currently evaluating using emulators to speed up our PRs. We’re also evaluating using Roborazzi to reduce device-based screenshot testing; Roborazzi allows testing of interactions while Paparazzi does not. We’re building up a modular “demo app” system that allows for feature-level testing instead of app-level testing. Improving app testing never ends…

$\"\"$

Netflix App Testing At Scale was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/eb4ef6b40124","Netflix App Testing At Scale",{"_2445":21},{"_8":2585,"_30":2586,"_2456":2457,"_2458":2587,"_2445":21,"_2460":2588,"_36":2589,"_2463":2590},647,"2025-04-16T15:55:36+00:00","

We’re excited to announce the new “Testing at scale” blog series! In these posts, industry experts working on different apps share their testing strategies, tips, and obstacles found along the way.

This series complements the new Testing Strategies documentation, going beyond general advice with real-world examples that showcase the importance of considering specific circumstances — technical, infrastructure, and even human.

While most apps don’t have millions of users or hundreds of contributors, and you might not need your own device farm with a cellular tower (!), there’s a great deal of valuable insights that you can apply as your app grows.

The first article, which you can read now, is How Netflix tests at scale, written by Ken Yee.

If you want to contribute to this series, drop me a note!

Happy testing!

Many thanks to Ken Yee, who had the idea to extend Netflix’s case study into a series with more partners!

$\"\"$

Introducing Testing at Scale blog series was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/8cd300ae2795","Introducing Testing at Scale blog series",{"_2445":21},{"_8":2592,"_30":2593,"_2456":2457,"_2458":2594,"_2445":21,"_2460":2595,"_36":2596,"_2463":2597},727,"2025-04-08T16:03:14+00:00","

Part 4 of Unlocking the Power of CameraX in Jetpack Compose

Welcome back to the final part of our blog post series about harnessing the power of CameraX and Compose. In the previous posts, we’ve created a camera preview screen with tap-to-focus and spotlight effect. Now, we will take our viewfinder and expand it to the larger screen!

🧱 Part 1: Building a basic camera preview using the new camera-compose artifact. We covered permission handling and basic integration.
👆 Part 2: Using the Compose gesture system, graphics, and coroutines to implement a visual tap-to-focus.
🔦 Part 3: Exploring how to overlay Compose UI elements on top of your camera preview for a richer user experience.
📂 Part 4 (this post): Using adaptive APIs and the Compose animation framework to smoothly animate to and from tabletop mode on foldable phones.

This post shows how to create a UI that elegantly transitions between a full-screen and a split-screen layout when a foldable device enters tabletop mode. We can use Compose’s animation APIs to smoothly animate this transition.

Here’s the final result:

Building upon the concepts and code from the previous posts, we’ll accomplish this in five logical steps:

Update our dependencies to use the latest animation and adaptive APIs.
Retrieve and share the hinge coordinates of our foldable device.
Position the camera viewfinder above the fold when the device is in tabletop mode.
Animate the transition between full-screen and top-half only viewfinder.
Create supporting content to display in the bottom half of the screen when in tabletop mode.

Note; you can follow along step by step, continuing with the code from the third blog post, or check out the final code snippet here.

Add and update dependencies

This post takes advantage of some newer APIs, so we need to make sure to update our dependencies to their latest versions. We will use the brand new animateBounds API, introduced in Compose 1.8.

We’ll also add a dependency on material3-adaptive, the artifact that helps us deal with foldable concepts such as tabletop mode and physical device hinges:

#libs.versions.toml

[versions]
kotlin = "2.1.20"
composeBom = "2025.03.01"
camerax = "1.5.0-alpha06"
accompanist = "0.37.2"
..

[libraries]
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom-beta", version.ref = "composeBom" }
androidx-material3-adaptive = { group = "androidx.compose.material3.adaptive", name = "adaptive" }
..

#build.gradle.kts
..
dependencies {
  ..
  implementation(libs.androidx.material3.adaptive)
}

Provide foldable hinge information with rulers

We’re aiming to align our UI components based on the position of the foldable’s hinge. Because foldables come in many shapes and forms, we should align our UI to the actual position of the top and bottom of the hinge, instead of simply breaking up the screen into two parts.

Note: Most foldables have a single display that runs across the hinge. In that case the hinge is simply a horizontal line, so its top and bottom coordinate would be equal. However, some foldables have two separate displays with some small space between them. That space still takes up layouting space, and you can still draw things in that non-existent space.

Basically, we want to know the top and the bottom y-coordinate of the first horizontal hinge:

Also, we likely want to use the same pattern in more screens in our app, so any screen can use this information when needed.

To provide the hinge position for the whole composable sub-tree, we can use rulers, a new UI concept introduced in Compose 1.7.0. By defining a horizontal ruler and providing it from the root of our UI hierarchy, any UI component can then use that ruler to align itself or its children to.

Since hinges can have a non-zero thickness, let’s provide two horizontal rulers, one for the top and one for the bottom y-coordinate of the first horizontal hinge. We’ll retrieve the actual coordinates by using the currentWindowAdaptiveInfo method in material3-adaptive.

val HorizontalHingeTopRuler = HorizontalRuler()
val HorizontalHingeBottomRuler = HorizontalRuler()

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            MyApplicationTheme {
                val viewModel = remember { CameraPreviewViewModel() }
                val horizontalHinge = currentWindowAdaptiveInfo().windowPosture
                    .allHorizontalHingeBounds.firstOrNull()
                Box(
                    Modifier.layout { measurable, constraints ->
                        val placeable = measurable.measure(constraints)
                        layout(
                            width = constraints.maxWidth,
                            height = constraints.maxHeight,
                            rulers = {
                                if (horizontalHinge != null) {
                                    val bounds = coordinates.windowToLocal(horizontalHinge)
                                    HorizontalHingeTopRuler provides bounds.top
                                    HorizontalHingeBottomRuler provides bounds.bottom
                                }
                            }
                        ) { placeable.place(0, 0) }
                    }
                ) {
                    CameraPreviewScreen(viewModel)
                }
            }
        }
    }
}


private fun LayoutCoordinates.windowToLocal(rect: Rect): Rect =
    Rect(
        topLeft = windowToLocal(rect.topLeft),
        bottomRight = windowToLocal(rect.bottomRight),
    )

Adapt camera viewfinder to tabletop posture

If you remember, in our last post, we simply showed a full screen camera viewfinder. That doesn’t look great while our foldable device is in tabletop mode:

So, let’s wrap our viewfinder inside a container, and make sure that that container shows only at the top half of the screen when the device is in tabletop mode:

As part of this, we’ll extract all code from the previous blog post into its own ViewfinderContent composable.

@Composable
fun CameraPreviewContent(
    viewModel: CameraPreviewViewModel,
    modifier: Modifier = Modifier,
    lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current
) {
    val surfaceRequest by viewModel.surfaceRequest.collectAsStateWithLifecycle()
    val sensorFaceRects by viewModel.sensorFaceRects.collectAsStateWithLifecycle()
    val context = LocalContext.current
    LaunchedEffect(lifecycleOwner) {
        viewModel.bindToCamera(context.applicationContext, lifecycleOwner)
    }
    val shouldHighlightFaces by remember {
        derivedStateOf { sensorFaceRects.isNotEmpty() }
    }

    val spotlightColor = Color(0xFFE60991)

    val windowPosture = currentWindowAdaptiveInfo().windowPosture
    val isTabletop: Boolean = windowPosture.isTabletop

    Box(modifier.safeDrawingPadding()) {
        ViewfinderContent(
            surfaceRequest,
            { sensorFaceRects },
            shouldHighlightFaces: Boolean,
            viewModel::tapToFocus,
            Modifier
                .fillMaxSize()
                .then(if (isTabletop) Modifier.alignAboveHinge() else Modifier)
                .padding(16.dp)
                .clip(RoundedCornerShape(24.dp))
                .border(8.dp, spotlightColor, RoundedCornerShape(24.dp))
        )
    }
}

// Place the composable above the horizontal hinge, if a hinge is present.
// Ruler values are only available during the placement phase, so this modifier
// *measures* with max constraints, and then *places* the content above the hinge.
private fun Modifier.alignAboveHinge(): Modifier = this then
    Modifier.layout { measurable, constraints ->
        layout(constraints.maxWidth, constraints.maxHeight) {
            // Get current hinge top, or NaN if not available
            val hingeTop = HorizontalHingeTopRuler.current(defaultValue = Float.NaN)

            // Constrain the height of the composable to the hinge top (if available)
            val childConstraints = if (hingeTop.isNaN()) constraints else
                Constraints(maxHeight = hingeTop.roundToInt()).constrain(constraints)

            // Place the composable above the hinge
            val placeable = measurable.measure(childConstraints)
            placeable.place(0, 0)
        }
    }

One thing to note is that we’ll only have access to the rulers once in the placement phase. So, in this case, we make the ViewfinderContent composable measure with full constraints, but then place itself only above the hinge.

Animate transitions

We can improve this code by adding a smooth transition between the tabletop and flat modes of the device. Right now, when the user moves between these two states, the UI jumps from one version to the other, creating a jarring experience:

Luckily, we have the new animation APIs to add automatic transitions between the two states. With Modifier.animateBounds() (new in Compose 1.8), that is available for use within a LookaheadScope , you can automatically animate the bounds of a composable. Note that we’ll need to add the LookaheadScope at the top level so the rulers take it into account, and then pass it on through the UI hierarchy using a composition local (as per documentation):

val LocalLookaheadScope = compositionLocalOf<LookaheadScope?> { null }

class MainActivity : ComponentActivity() {
   override fun onCreate(savedInstanceState: Bundle?) {
        ..
        setContent {
            MyApplicationTheme {
                ..
                LookaheadScope {
                    CompositionLocalProvider(LocalLookaheadScope provides this) {
                        Box(
                            Modifier.layout { measurable, constraints ->
                                ..
                            }
                        ) {
                            CameraPreviewScreen(viewModel)
                        }
                    }
                }
            }
        }
    }
}

@OptIn(ExperimentalSharedTransitionApi::class)
@Composable
fun CameraPreviewContent(
    viewModel: CameraPreviewViewModel,
    modifier: Modifier = Modifier,
    lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current
) {
    ..
    val isTabletop: Boolean = windowPosture.isTabletop

    val lookaheadScope = LocalLookaheadScope.current
        ?: throw IllegalStateException("No LookaheadScope found")

    Box(modifier.safeDrawingPadding()) {
        ViewfinderContent(
            ..
            modifier = Modifier
                .fillMaxSize()
                .then(if (isTabletop) Modifier.alignAboveHinge() else Modifier)
                .animateBounds(this@LookaheadScope)
                .padding(16.dp)
                .clip(RoundedCornerShape(24.dp))
                .border(8.dp, spotlightColor, RoundedCornerShape(24.dp))
        )
    }
}

Add a control panel

Now that we have some extra space in our layout, we can add a control panel that shows or hides based on the tabletop mode. Here, we can use the AnimatedVisibility API to show or hide the panel, in combination with the same rulers as above to position the panel below the hinge:

@OptIn(ExperimentalSharedTransitionApi::class)
@Composable
fun CameraPreviewContent(
    ..
) {
    ..

   val colors = listOf(Color(0xFF09D8E6), Color(0xFFE6C709), Color(0xFFE60991))
   var pickedColorIndex by rememberSaveable { mutableIntStateOf(0) }
   val onColorIndexChanged = { index: Int -> pickedColorIndex = index }
   val spotlightColor by animateColorAsState(colors[pickedColorIndex])

   Box(modifier.safeDrawingPadding()) {
        ViewfinderContent(
            ..
        )

        AnimatedVisibility(
            isTabletop,
            enter = fadeIn() + slideInVertically { it / 2 },
            exit = fadeOut() + slideOutVertically { it / 2 },
            modifier = Modifier.alignBelowHinge()
        ) {
            MyControlPanel(
                colors = colors,
                pickedColorIndex = pickedColorIndex,
                onColorPicked = onColorIndexChanged,
            )
        }
    }
}

// Place the composable below the horizontal hinge, if a hinge is present.
// Ruler values are only available during the placement phase, so this modifier
// *measures* with max constraints, and then *places* the content below the hinge.
private fun Modifier.alignBelowHinge(): Modifier = this then
    Modifier.layout { measurable, constraints ->
        layout(constraints.maxWidth, constraints.maxHeight) {
            // Get current hinge bottom, or default to 0 if not available
            val hingeBottom = HorizontalHingeBottomRuler.current(defaultValue = 0f).roundToInt()

            // Constrain the height of the composable to the hinge bottom (if available)
            val childConstraints = Constraints(maxHeight = constraints.maxHeight - hingeBottom)
                    .constrain(constraints)

            // Place the composable below the hinge
            val placeable = measurable.measure(childConstraints)
            placeable.place(0, hingeBottom)
        }
    }

And with that, we’ll have a beautiful animated adaptive experience!

Note: Generally, providing functionality only when in tabletop mode would be considered a bad practice, so you’d have to make sure the control panel is available in non-tabletop mode as well. I’ll leave that for you to implement 🙂

Conclusion

By combining the adaptive and animation APIs, we can build powerful adaptive applications that add foldable support with delightful transitions.

The principle demonstrated in this blog post can of course be generalized into a separate composable component, so it can be reused across screens.

You can find the full code snippet here. And with that, we’ve concluded our journey of exploring the power of CameraX and Compose! We’ve built a basic camera preview, added tap-to-focus functionality, overlaid a dynamic spotlight effect, and finally, made our app adaptive and beautiful on foldable devices.

We hope you enjoyed this blog series, and that it inspires you to create amazing camera experiences with Jetpack Compose. Remember to check the docs for the latest updates!

Happy coding, and thanks for joining us!

The code snippets in this blog have the following license:

// Copyright 2024 Google LLC. SPDX-License-Identifier: Apache-2.0

Many thanks to Alex Vanyo, Rebecca Franks, Nick Butcher, and Don Turner for reviewing and providing feedback. Made possible by the hard work of Yasith Vidanaarachch and Trevor McGuire.

$\"\"$

Adaptive Camera: Smooth Tabletop Mode with Animations was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/f57d77696e0f","Adaptive Camera: Smooth Tabletop Mode with Animations",{"_2445":21},{"_8":2599,"_30":2600,"_2456":-5,"_2458":2601,"_2445":13,"_2460":2602,"_36":2603,"_2463":2604},426,"2025-04-02T20:27:24+00:00","

Transparency is a core goal of the Flutter open source project, with everything from issues to design specifications being shared in the open. One of the most highly requested pieces of information is the yearly roadmap for the core Flutter team at Google, and today we’re happy to share the 2025 roadmap.

We’ve been publishing our roadmaps since 2020, and this is a natural continuation of previous years’ work; we’re still working towards our long-term goal of creating the most popular, fastest growing, and highest-productivity multi-platform UI framework for building rich app experiences!

For all the details, check out the freshly updated Flutter roadmap on GitHub.

As with any other software product roadmap, note that plans tend to shift and adapt throughout the year, so don’t be surprised if some changes happen along the way. But we still feel it’s important to share our overall plans.

Also note that what we’re listing here is primarily content gathered from those of us who work on Flutter as employees of Google. By now non-Google contributors outnumber those employed by Google, so this is not an exhaustive list of all the new and exciting things that we hope will come to Flutter this year!

We remain greatly thankful for the community and your continued support. We can’t wait to see what you’ll build!

$\"\"$

Flutter 2025 roadmap update was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/f127882b117f","Flutter 2025 roadmap update",{"_2445":13},{"_8":2606,"_30":2607,"_2456":2457,"_2458":2608,"_2445":21,"_2460":2609,"_36":2610,"_2463":2611},528,"2025-03-25T19:43:00+00:00","

Ensure your WebViews are compatible with Android 16, as Android 16 removes the ability to opt-out of drawing your app edge-to-edge. The way you handle insets for WebViews depends on whether or not your app owns the web content.

This post assumes basic knowledge of handling insets and is applicable if your WebViews are drawing underneath system bars or display cutouts. See the Compose and Views documentation, and the Inset handling tips blog for guidance on handling insets.

If you’re looking for guidance on how to make your webpage edge-to-edge on Chrome, see the Chrome on Android edge-to-edge migration guide instead.

This post covers the following topics:

How to handle WebViews if your app doesn’t own the web content
How to handle WebViews if your app owns the web content
Handling IME insets in WebViews

If your app doesn’t own the web content

WebViews displaying external content cannot easily draw edge-to-edge and should instead be inset to avoid the system bars and display cutout. The implementation is different depending on if you’re using Compose or Views, but generally follows these steps:

Wrap the WebView in a container and apply insets as padding on that container.
Set the app’s background color in a best-effort attempt to match the webpage.

\"Three — **Figure 1.** Left to right. (a) The left image shows a full screen WebView in an app targeting SDK 35, at which point edge-to-edge is enforced. The top of the WebView collides with status bar icons. (b) The middle image shows the result of padding the WebView’s parent. The app’s background is set to red to make it apparent that the WebView is inset. (c) The right image is the desired result. The app’s background is set to white in a best-effort attempt to match the webpage.

See the following code samples.

Apply insets to a WebView in a Compose app

To ensure a WebView in Compose avoids overlapping with system bars, display cutout and keyboard, apply Modifier.windowInsetsPadding(WindowInsets.safeDrawing) to its wrapper (e.g. AndroidView). This provides the necessary padding to keep the WebView content within the safe area of the screen.

@Composable
fun WebViewInCompose() {
    AndroidView(
        modifier = Modifier.windowInsetsPadding(WindowInsets.safeDrawing),
        factory = { context ->
            WebView(context).apply {
                // Configure WebView options here
            }
        }
    )
}

Then, update your app’s background so it matches the WebView’s background as much as possible.

Apply insets to a WebView in a Views app

To ensure a WebView in Views avoids overlapping the system bars, display cutout and keyboard, wrap the WebView in a container like a FrameLayout and do one of the following:

Set android:fitsSystemWindows="true"
Use ViewCompat.setOnApplyWindowInsetsListener() and apply systemBars, displayCutout, and ime insets on the container. See the Views documentation for a code sample using the listener.

Finally, update android:windowBackground in your themes.xml so it matches the WebView’s background if possible.

If your app owns the web content

If your app owns the web content, either pad the WebView’s parent as described above; or, use JavaScript to inject padding into the web page to draw the page edge-to-edge as described below.

To inject padding into the web page, first add <meta name=”viewport” content=”viewport-fit=cover”> to your HTML.

<meta name="viewport" content="viewport-fit=cover, initial-scale=1" />

Second, define CSS variables for top, right, bottom and left safe area insets, as the env(safe-area-inset-*) variables return 0px on Android at the time of writing this blog.

/* CSS */
body {
  padding-top: var(--safe-area-inset-top);
  padding-right: var(--safe-area-inset-right);
  padding-bottom: var(--safe-area-inset-bottom);
  padding-left: var(--safe-area-inset-left);
}

Instead of applying insets on the WebView’s container, use JavaScript to pass the insets to your CSS variables to pad the webpage. The implementation is different depending on if you’re using Compose or Views, but it generally follows these steps:

Retrieve the top, right, bottom and left system bar, display cutout and IME insets as raw pixel values.
Convert the raw pixel values to density independent pixels.
Inject the density independent pixels into the CSS variables as CSS pixels. When the website renders on the Android device, the WebView converts the CSS pixels back to density independent pixels. See Support different screens in web apps for more information.
In Compose, recompose when the software keyboard expands or collapses if applicable.
In Views, dispatch insets when the webpage first loads.

\"Two — **Figure 2.** Top to bottom. (a) The top image shows a full screen WebView in an app targeting SDK 35, at which point edge-to-edge is enforced. The WebView collides with system bars and display cutout. (b) The bottom image shows the result of using JavaScript to inject padding into the webpage, which is the edge-to-edge result we want.

See the following code samples.

Using Compose and JavaScript to inject insets into web pages

A code sample showing how to use JavaScript to inject insets into webpages in a Compose app.

import android.webkit.WebView
import android.webkit.WebViewClient
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.ime
import androidx.compose.foundation.layout.safeDrawing
import androidx.compose.ui.unit.Dp
...

@Composable
fun MainScreen() {
    Box(modifier = Modifier.fillMaxSize()) {
        
        // Retrieve insets as raw pixels
        val insets = WindowInsets.safeDrawing
        WebViewInCompose(
            initialUrl = "file:///android_asset/example.html",
            insets = insets
        )
    }
}

@SuppressLint("SetJavaScriptEnabled")
@Composable
fun WebViewInCompose(
    initialUrl: String,
    insets: WindowInsets,
    density: Density = LocalDensity.current,
    layoutDirection: LayoutDirection = LocalLayoutDirection.current,
    myWebViewClient: CustomWebViewClient = remember { CustomWebViewClient(
        insets, density, layoutDirection
    ) }
) {
    
    // Don't apply insets to the container 
    AndroidView(
        factory = { context ->
            WebView(context).apply {
                webViewClient = myWebViewClient
                settings.javaScriptEnabled = true
                loadUrl(initialUrl)
            }
        }, update = { view ->
            
            // Updates webpage when software keyboard expands or collapses.
            // If your webpage doesn't have an input field that opens the 
            // software keyboard, remove this line.
            applySafeAreaInsetsToWebView(insets, density, layoutDirection, view)
        }
    )
}

class CustomWebViewClient(
    private val insets: WindowInsets,
    private val density: Density,
    private val layoutDirection: LayoutDirection
) : WebViewClient(){

    override fun onPageFinished(view: WebView?, url: String?) {
        super.onPageFinished(view, url)
        
        // Inject insets into the webpage once the page has fully loaded
        applySafeAreaInsetsToWebView(insets, density, layoutDirection, view)
    }
}

private fun applySafeAreaInsetsToWebView(
    insets: WindowInsets,
    density: Density,
    layoutDirection: LayoutDirection,
    webView: WebView?){

    // Convert raw pixels to density independent pixels
    val top = insets.getTop(density).toDp(density).value
    val right = insets.getRight(density, layoutDirection).toDp(density).value
    val bottom = insets.getBottom(density).toDp(density).value
    val left = insets.getLeft(density, layoutDirection).toDp(density).value

    val safeAreaJs = """
            document.documentElement.style.setProperty('--safe-area-inset-top', '${top}px');
            document.documentElement.style.setProperty('--safe-area-inset-right', '${right}px');
            document.documentElement.style.setProperty('--safe-area-inset-bottom', '${bottom}px');
            document.documentElement.style.setProperty('--safe-area-inset-left', '${left}px');
            """

    // Inject the density independent pixels into the CSS variables as CSS pixels
    webView?.evaluateJavascript(safeAreaJs, null)
}

private fun Int.toDp(density: Density): Dp = with(density) { this@toDp.toDp() }

Using Views and JavaScript to inject insets into web pages

A code sample showing how to use JavaScript to inject insets into webpages in a Views app.

import androidx.core.util.TypedValueCompat.pxToDp
import 
androidx.core.view.WindowInsetsCompat.Type.displayCutout
import androidx.core.view.WindowInsetsCompat.Type.ime
import androidx.core.view.WindowInsetsCompat.Type.systemBars
...

override fun onCreate(savedInstanceState: Bundle?) {
    ...

    val myWebView: WebView = findViewById(R.id.webView)
    myWebView.settings.javaScriptEnabled = true
    myWebView.loadUrl("file:///android_asset/example.html")

    ViewCompat.setOnApplyWindowInsetsListener(myWebView) { _, windowInsets ->
        
        // Retrieve insets as raw pixels
        val safeDrawingInsets = windowInsets.getInsets(
            systemBars() or displayCutout() or ime()
        )
        val displayMetrics = myWebView.context.resources.displayMetrics

        // Convert raw pixels to density independent pixels 
        val top = pxToDp(safeDrawingInsets.top.toFloat(), displayMetrics)
        val right = pxToDp(safeDrawingInsets.right.toFloat(), displayMetrics)
        val bottom = pxToDp(safeDrawingInsets.bottom.toFloat(), displayMetrics)
        val left = pxToDp(safeDrawingInsets.left.toFloat(), displayMetrics)

        val safeAreaJs = """
            document.documentElement.style.setProperty('--safe-area-inset-top', '${top}px');
            document.documentElement.style.setProperty('--safe-area-inset-right', '${right}px');
            document.documentElement.style.setProperty('--safe-area-inset-bottom', '${bottom}px');
            document.documentElement.style.setProperty('--safe-area-inset-left', '${left}px');
            """

        // Inject the density independent pixels into the CSS variables as CSS pixels
        myWebView.evaluateJavascript(safeAreaJs, null)

        windowInsets
    }

    myWebView.webViewClient = object : WebViewClient() {
        override fun onPageFinished(view: WebView, url: String) {
            super.onPageFinished(myWebView, url)
            // dispatch insets because insets aren't applied when the webpage first loads.
            view.requestApplyInsets()
        }
    }
}

Note: If the injected insets look too large, it might be because your website’s Viewport initial-scale is more than 1. In this case, divide the top, right, bottom, and left variables by the scale.

Handling IME insets in WebViews

To ensure your web page correctly adjusts when the on-screen keyboard (IME) appears, you must also account for IME insets. The provided Compose and Views code example already includes this by retrieving WindowInsets.safeDrawing() in Compose or WindowInsetsCompat.Type.ime() in Views:

// Getting IME insets from the above Compose code sample
// safeDrawing includes ime, systemBars, and displayCutout
WindowInsets.safeDrawing


// Getting IME insets from the above Views code sample
val safeDrawingInsets = windowInsets.getInsets(
    systemBars() or displayCutout() or ime()
)

Omitting IME insets will lead to issues where the webpage content is obscured by the keyboard. For example, when the user taps an HTML text input and the IME expands, the webpage won’t resize, preventing the user from seeing content hidden behind the keyboard. By including IME insets, the webpage dynamically adjusts its layout when the IME is displayed, ensuring all content remains accessible to the user.

\"\" — **Figure 3.** Left (incorrect implementation) to right (correct implementation). (a) The left GIF shows a full-screen WebView where IME insets *aren’t* handled. When the IME appears, the user cannot scroll to view content behind it. (b) The right image shows the same WebView with correct IME inset handling. After the IME appears, the user can scroll to access the full webpage content.

In summary, ensuring WebViews are compatible with an edge-to-edge display requires different approaches depending on whether the app owns the web content. For external content, wrap the WebView in a container and apply insets as padding. For owned content, either pad the container or inject JavaScript to handle insets within the webpage.

The code snippets in this blog have the following license:

// Copyright 2024 Google LLC. SPDX-License-Identifier: Apache-2.0

$\"\"$

Make WebViews edge-to-edge was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/a6ef319adfac","Make WebViews edge-to-edge",{"_2445":21},{"_8":2613,"_30":2614,"_2456":2457,"_2458":2615,"_2445":21,"_2460":2616,"_36":2617,"_2463":2618},734,"2025-03-13T21:47:18+00:00","

Google I/O 2025, Android Studio at 10, Android 16 Betas, production-ready generative AI, Imagen in Firebase, kids apps on Wear OS, trusted VPNs in Play, TrustedTime, the latest in AndroidX, and more!

Welcome to Now in Android, your ongoing guide to what’s new and notable in the world of Android development.

In this edition, we’ll cover the return of Google I/O, Android Studio Turning 10, the Android 16 Betas, Imagen in Firebase, the latest in AndroidX, and more!

Most of the content of this post is available in the form of a video or podcast, so feel free to watch or listen rather than read on. (Or do all three to help you remember! There won’t be a quiz.)

Get Ready for Google I/O 2025! 🎊

Mark your calendars! Google I/O is returning on May 20–21. This year’s event will share Google’s vision for the future of technology, including updates across Android, AI, web, cloud, and more. Tune in online to learn how the latest AI models can help you build innovative apps and transform your development workflows. Registration is now open.

Get ready for Google I/O May 20-21

Celebrating 10 Years of Android Studio 🎂🔟

January 2025 marked the 10th anniversary of Android Studio 1.0 reaching the stable channel. To celebrate this milestone, we reflected on the journey of Android Studio, including the three core principles that guided its development: building a complete product that worked out-of-the-box, leveraging a best-of-breed actively-maintained, open source Java IDE (IntelliJ), and providing a consistent build system with Gradle.

The blog post features reflections from key team members across Android, JetBrains, and Gradle, emphasizing the partnership and community contributions that have been crucial to Android Studio’s success.

To continue the celebration, we’ve launched “Meet the Android Studio Team,” a weekly series of blogs that pulls back the curtain, introducing you to the passionate people behind these tools. So far, we’ve heard from Jamal Eason, Director of Product Management, who shared his journey and insights on the impact of product quality, Gemini integration, and App Quality Insights. Product Manager Paris Hsu recounted her journey to become part of the team, her approach to Compose Tools, and the importance of developer feedback. Trevor Johns, Staff Developer Programs Engineer, discussed the team’s focus on developer productivity through AI and the impact of Kotlin, along with his long history at Google.

Check out the Android Studio’s 10th birthday: our favorite moments video for a look at some of the best moments in Android Studio history from the people that made it happen.

Android 16 Beta Releases are Here! 🤖🎉

The Android team has released betas 1–3 of Android 16, bringing you new features and changes to explore and adapt your apps to. Beta 3 brings platform stability and, with it, the ability to publish apps targeting API 36

Adaptive Apps: Android 16 is phasing out the ability for apps to restrict screen orientation and resizability on large screens. Apps targeting API level 36 on screens wider than 600dp will have resizable windows. Ensure that your UIs scale well across different aspect ratios. This change becomes mandatory for apps targeting API level 37.

Progress centric notifications: A new class of notifications to help users monitor ongoing activities like rideshares and deliveries, featuring a new ProgressStyle template.

Improved Camera and Media quality: Enhanced support for high-quality media, including the Advanced Professional Video (APV) format and camera night mode scene detection. Android 16 also introduces standard Intent actions for capturing motion photos and enhances UltraHDR image quality with HEIC support.

Custom Graphical Effects: New APIs like RuntimeColorFilter and RuntimeXfermode allow you to author and apply complex GPU-accelerated graphical effects using AGSL.

Accessibility Improvements: New APIs for supplemental descriptions, required form fields, support for elements with multiple labels, improved support for expandable elements, indeterminate ProgressBars, and a tri-state CheckBox. Beta 3 adds support for a new outline text high contrast mode.

Behavior Changes: Several behavior changes are introduced in Android 16, including updates to ART internals, predictive back animations, fixed-rate work scheduling optimization, ordered broadcast priority scope, edge-to-edge enforcement, health and fitness permissions, and intent redirect protections. The list of changes not targeted to targetSdk is here, and the ones that are tied to targetSdk are here.

Two Android API Releases in 2025: Expect a major Android release in Q2 and a minor release in Q4. Behavior changes are primarily in the Q2 release. Please test your apps on Android 16.

https://android-developers.googleblog.com/2025/03/the-third-beta-of-android-16.html

Production-ready access to Gemini and Imagen cloud models on Android 🖼️💬

Vertex AI in Firebase, which became generally available last October, is a production-ready solution to allow you to leverage the power of generative AI in your apps with. It gives you access to Google’s Gemini Cloud models, such as Gemini 2.0 Flash and Gemini 1.5 Pro.

Imagen 3, Google’s advanced image generation model, is now in public preview in Firebase for Android! The Imagen blog covers how you can use the Firebase SDK for Android to integrate Imagen 3, customize generation (format, safety), and create engaging user experiences with AI-powered visuals.

The production ready blog covers important tips for a successful deployment to production:

Implement Firebase App Check to help protect backend resources from abuse.
Consider using Firebase Remote Config for server-controlled configuration of your AI models.
Gathering user feedback with tools such as Google Analytics is also essential to evaluate the impact of your AI features.
Remember to be transparent with your users about their engagement with generative AI; make sure to let them know that data sent to Google won’t be used to train Google’s models, and provide them with control over how their activity related to AI model interactions is stored.

Helping users find trusted apps on Google Play 🔐

Google Play is introducing a “Verified” badge for consumer-facing VPN apps that meet specific criteria, including completing the Mobile Application Security Assessment (MASA) Level 2 validation, having an Organization developer account, meeting target API level requirements, having at least 10,000 installs and 250 reviews, being published for at least 90 days, and opting into independent security review and encryption in transit in their Data Safety section.

Helping users find trusted apps on Google Play

Building Kids App Experiences for Wear OS 🚸

In collaboration with Samsung, Wear OS is introducing Galaxy Watch for Kids, a new experience enabling kids to stay connected with their families from their smartwatch, no phone necessary. The kids experience includes support for calling, texting, games, and more, with parent-managed contacts and app controls via Google Family Link.

The kids app experience unlocks new opportunities for Wear OS developers to reach younger audiences. Wear OS kids apps must adhere to age / content requirements while supporting standalone functionality — including having ‘standalone’ in their manifest. Watch faces for kids must be built with Watch Face Format. We’re providing new design and content principles to help you build kid-friendly apps for Wear OS. Apps like MathTango are already creating engaging experiences.

Build kids app experiences for Wear OS

TrustedTime for reliable timekeeping ⏰

The new TrustedTime API leverages Google’s secure infrastructure to provide a trustworthy timestamp that is independent of a device’s potentially manipulated local time settings. TrustedTime periodically syncs its clock to Google’s servers and even calculates the device’s clock drift to inform you of potential inaccuracies.

Key benefits include preventing data inconsistency, closing security gaps in time-based measures, ensuring reliable scheduling, and providing more accurate time compared to the device’s internal clock. Use cases span across financial applications, gaming (preventing clock manipulation), limited-time offers, e-commerce, content licensing, IoT devices, and productivity apps, The TrustedTime API is built on Google Play services and is available on devices running Android 5 (Lollipop) and above.

TrustedTime API: Introducing a reliable approach to time keeping for your apps

AndroidX Releases 🚀

The first alpha of the Android test libraries now require a minSdkVersion of 21:

Core 1.7, Espresso 3.7, Espresso device 1.1 , Junit 1.3, Truth 1.7, Monitor 1.8, Runner 1.7, and Rules 1.7. There are a few other changes, such as Espresso device 1.1 updating WidthSizeClass and HeightSizeClass to use androidx.window size classes.

Wear Ongoing & Interactions Version 1.1 is released, bringing a crucial bug fix that prevents a runtime exception for Apps running on Wear OS 5 (API level 34) or higher and targeting API level 35 or higher.

Browser 1.9 alpha 1 is released, including color scheme params support, experimental ephemeral browsing for Custom Tabs, a new service intent filter category to support multi-network, and more.

TV material 1.1 includes changes to the way focus is handled along with fixes for broken focus management in Carousel, fixes to jittery text while scaling, and more.

Now then… 👋

That’s it for this edition, with Google I/O announced for May 20–21, the 10th anniversary of Android Studio, the Android 16 Betas, production-ready generative AI along with Imagen in Firebase, kids apps on Wear OS, trusted VPNs in Play, TrustedTime, the latest in AndroidX, and more!

Check back soon for your next update from the Android developer universe!

$\"\"$

Now in Android #114 was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/bf1416b5f5ae","Now in Android #114",{"_2445":21},{"_8":2620,"_30":2621,"_2456":2457,"_2458":2622,"_2445":21,"_2460":2623,"_36":2624,"_2463":2625},728,"2025-03-13T16:17:59+00:00","

Lifecycle 2.9.0-alpha01 introduced ViewModelScenario, a helper that simplifies unit testing for ViewModels.

Why It Matters

You can test a ViewModel by simply creating an instance using its constructor in your test code. However, this approach has limitations — there is no straightforward way to:

Trigger ViewModelStore.clear() / ViewModel.onCleared().
Simulate a save and restore instance state change.

With ViewModelScenario, these are now easy to test, helping you catch errors related to ViewModel clean-up and saved state.

How to Use

First, add the dependency to your Gradle file. It’s available from 2.9.0-alpha08:

implementation("androidx.lifecycle:lifecycle-viewmodel-testing:{version}")

Next, define your ViewModel:

class MyViewModel(
  scope: CoroutineScope,
  val handle: SavedStateHandle,
) : ViewModel(scope) { … }

/* Class used by SavedStateHandle. */
@Parcelize
data class MyData(
  val name: String,
  val surname: String,
) : Parcelable

Finally, write a unit test for your ViewModel using a ViewModelScenario:

class MyViewModelTest {

  @Test
  fun testStateRestoration() = runTest { // this: TestScope
    viewModelScenario { // this: CreationExtras
      MyViewModel(
        scope = this@runTest,
        handle = createSavedStateHandle(),
      )
    }.use { it: ViewModelScenario ->
      // Set a ViewModel state.  
      it.viewModel.handle["key"] = MyData("John", "Doe")

      // Recreate ViewModel, simulating a state restoration
      // (including parcelizing).  
      it.recreate()

      // Verify state is restored correctly after parcelizing.  
      assertThat(it.viewModel.handle["key"])
        .isEqualTo(MyData("John", "Doe"))
    }
  }
}

Test in Details

ViewModelScenario.recreate() simulates Android’s state saving and restoring, including parcelizing (see Save UI states).
It ensures that data in SavedStateHandle is correctly saved and restored.
AutoCloseable use {} ensures ViewModelStore.clear() / ViewModel.onCleared() runs after the block finishes.
You can manually call ViewModelScenario.close() to trigger a clearing.
Also, ViewModelScenario is KMP compatible.

We invite you to try out the new API and share any issues or feedback through our Lifecycle issue tracker.

Happy testing!

The code snippets in this blog have the following license:

// Copyright 2024 Google LLC. SPDX-License-Identifier: Apache-2.0

$\"\"$

Unit Testing Lifecycle and State in ViewModels was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/9d406c08cbd7","Unit Testing Lifecycle and State in ViewModels",{"_2445":21},{"_8":2627,"_30":2628,"_2456":2457,"_2458":2629,"_2445":21,"_2460":2630,"_36":2631,"_2463":2632},533,"2025-03-12T16:04:53+00:00","

This is a guest post from amo Engineer, Cyril Mottier, on how they’ve leveraged Android to create magic in their Android app.

At amo, we are redefining what it means to build social applications. Our mission is to create a new kind of social company, one that prioritizes high-quality, thoughtfully designed mobile experiences. One of our flagship applications, Bump, puts your friends on the map — whether you’re checking in on your crew or making moves to meet up.

Our app leverages multiplatform technologies for its foundation. At the core lies a shared Rust-based library that powers all of our iOS and Android apps. This library, managed by our backend engineers, is responsible for persistence and networking. The library exposes its APIs as Kotlin Flow. In addition to making everything reactive and realtime-enabled by default, it integrates effortlessly with Jetpack Compose, the technology we use to build our UI. This architecture ensures a consistent and high-performance experience across platforms. It also allows mobile engineers to spend more time on the user experience where they can focus on crafting innovative and immersive user interactions.

In this post, we will explore how we leverage the Android SDK, Jetpack Compose, the Kotlin programming language, and Google Play Services to build unique, delightful experiences in Bump. Our goal is to break mental barriers and show what’s truly possible on Android — often in a very few lines of code. We want to inspire engineers to think beyond conventional UI paradigms and explore new ways to create magical moments for users. By the end of this article, you’ll have a deeper understanding of how to harness Android’s capabilities to build experiences that feel like magic.

At amo, we ship, learn, and iterate rapidly across our feature set. That means that the design of some of the features highlighted in this article has already changed, or will do so in the coming weeks and months.

Designing for the senses vs designing for the eyes

Great touch-based UX isn’t just about flashy visuals. It’s about delivering meaningful feedback through graphics, haptics, sounds, and more. Said differently, it is about designing for all senses, not just for the eyes. We take this very seriously when designing applications and always take all of these potential dimensions into account.

One example is our in-app notification center. The notification center is a visual entry point accessible from anywhere in the app which shows all of your notifications from the entire amo suite of apps. It can be moved anywhere on the screen. Its style also changes regularly thanks to some in-residence or external artists. But styling doesn’t stop at the visual level, we also style it at the audio level: when it is dragged around, a short and repeating sound is played.

To make it fun and joyful, we pushed this even further to let the user be a DJ. The volume, the speed and the pitch of the audio change depending on where the user drags it. It is a “be your own DJ” moment. The implementation of this experience can be split in two parts. The first part deals with the audio and the second part handles the rendering of the entry point and its interactions (dragging, tapping, etc.).

Let’s first dive into the code handling the audio. It consists of a Composable requiring an URL pointing to the music, a flag indicating whether it should play or not (true only when dragging) and a two-dimensional offset: X axis controls the volume, Y axis controls the playback speed & pitch.

@Composable
fun GalaxyGateAccessPointMusicPlayer(
    musicUrl: String,
    isActive: Boolean,
    offset: Offset,
) {
    val audioPlayer = rememberAudioPlayer(
        uri = Uri.parse(musicUrl),
    )
    LaunchedEffect(audioPlayer, isActive) {
        if (isActive) {
            audioPlayer.play(isLooped = true)
        } else {
            audioPlayer.pause()
        }
    }

    SideEffect {
        audioPlayer.setSpeedPitch(
            speed = 0.75f + offset.y * 0.5f,
            pitch = offset.x + 0.5f
        )
        audioPlayer.setVolume(
            (1.0f - ((offset.x - 0.5f) * 2f).coerceIn(0f, 1f)),
            (1.0f - ((0.5f - offset.x) * 2f).coerceIn(0f, 1f)),
        )
    }
}

@Composable
fun rememberAudioPlayer(
    uri: Uri,
): AudioPlayer {
    val context = LocalContext.current
    val lifecycle = LocalLifecycleOwner.current.lifecycle
    return remember(context, lifecycle, uri) {
        DefaultAudioPlayer(
            context = context,
            lifecycle = lifecycle,
            uri = uri,
        )
    }
}

DefaultAudioPlayer is just an in-house wrapper around ExoPlayer provided by Jetpack Media3 that deals with initialization, lifecycle management, fading when starting/stopping music, etc. It exposes 2 methods setSpeedPitch and setVolume delegating to the underlying ExoPlayer.

By combining gesture readings with audio pitch, speed and volume, we added delight and surprise when users didn’t expect it.

Highly Unique Experiences with Animations and Shaders

We named our application “Bump” as a nod to its core feature: people close to each other can “bump” their phones together. If they are not registered as friends on the app, bumping will automatically send a friend request. And if they are, a mesmerizing animation triggers. We also notify mutual friends that they “bumped” and they should join.

This Bump feature is central to the app’s experience. It stands out in its interaction, functionality, and the unique value it provides. To express its importance, we wanted the feature to have a distinctive visual appeal. Here’s a glimpse of how it currently looks in the app:

There is a lot going on in this video but it can be summarized to 3 animations: the “wave” animation when the device detects a local bump/shake, the animation showing the two friends bumping and lastly a “ring pulsing” animation to finish. While the second animation is plain Compose, the two others are custom. Creating such custom effects involved venturing into what is often considered “unknown territory” in Android development: custom shaders. While daunting at first, it’s actually quite accessible and unlocks immense creative potential for truly unique experiences.

Simply put, shaders are highly parallelizable code segments. Each shader runs once per pixel per frame. This might sound intense, but this is precisely where GPUs excel. In Android 13, shaders have been integrated as first-class citizens with AGSL shaders and RuntimeShader for Views and Compose.

Since our app requires a minimum of API 30 (Android 11), we opted for a more traditional approach using a custom OpenGL renderer.

We extract a Bitmap of the view we want to apply the effect to, pass it to the OpenGL renderer, and run the shader. While this method ensures retro-compatibility, its main drawback is that it operates on a snapshot of the view hierarchy throughout the animation. As a result, any changes occurring on the view during the animation aren’t reflected on screen until the animation concludes. Keen observers might notice a slight glitch at the end of the animation when the screenshot is removed, and normal rendering resumes.

Bringing Friends to Life on the Map

In our apps, profile pictures are a bit different. Instead of static images, you record a live profile picture, a transparent, animated boomerang-like cutout. This approach feels more personal, as it literally brings your friends to life on-screen. You see them smiling or making faces, rather than just viewing curated or filtered photos from their camera roll.

From a product perspective, this feature involves two key phases: the recording and the rendering. Before diving into these specific areas, let’s discuss the format we use for data transport between mobile devices (Android & iOS) and the server. To optimize bandwidth and decoding time, we chose the H.265 HEVC format in an MP4 container and perform the face detection on device. Most modern devices have hardware decoders, making decoding incredibly fast. Since cross-platform videos with transparency aren’t widely supported or optimized, we developed a custom in-house solution. Our videos consist of two “planes”:

The original video on top
A mask video at the bottom

We haven’t yet optimized this process. Currently, we don’t pre-apply the mask to the top plane. Doing so could reduce the final encoded video size by replacing the original background with a plain color.

This format is fairly effective. For instance, the video above is only 64KB. Once we aligned all mobile platforms on the format for our animated profile pictures, we began implementing it.

Recording a Live Profile Picture

The first step is capturing the video, which is handled by Jetpack CameraX. To provide users with visual feedback, we also utilize ML Kit Face Detection. Initially, we attempted to map detected facial expressions (such as eyes closed or smiling) to a 3D model rendered with Filament. However, achieving real-time performance proved too challenging for the timeframe we had. We instead decided to detect the face contour and to move a default avatar image on the screen accordingly.

Once the recording is complete, Jetpack CameraX provides a video file containing the recorded sequence. This marks the beginning of the second step. The video is decoded frame by frame, and each frame is processed using ML Kit Selfie Segmentation. This API computes the face contour from the input image (our frames) and produces an output mask of the same size. Next, a composite image is generated, with the original video frame on top and the mask frame at the bottom. These composite frames are then fed into an H.265 video encoder. Once all frames are processed, the video meets the specifications described earlier and is ready to be sent to our servers.

While the process could be improved with better interframe selfie segmentation, usage of depth sensors, or more advanced AI techniques, it performs well and has been successfully running in production for over a year.

Rendering Your Friends on the Map

Playing back animated profile pictures presented another challenge. The main difficulty arose from what seemed like a simple product requirement: displaying 10+ real-time moving profile pictures simultaneously on the screen, animating in a back-and-forth loop (similar to boomerang videos). Video decoders, especially hardware ones, excel at decoding videos forward. However, they struggle with reverse playback. Additionally, decoding is computationally intensive. While decoding a single video is manageable, decoding 10+ videos in parallel is not. Our requirement was akin to wanting to watch 10+ movies simultaneously on your favorite streaming app, all in reverse mode. This is an uncommon and unique use case.

We overcame this challenge by trading computational needs for increased memory consumption. Instead of continuously decoding video, we opted to store all frames of the animation in memory. The video is a 30fps, 2.5-second video with a resolution of 256x320 pixels and transparency. This results in a memory consumption of approximately 24MB per video. A queue-based system handling decoding requests sequentially can manage this efficiently. For each request, we:

Decode the video frame by frame using Jetpack Media3 Transformer APIs
For each frame:

Apply the lower part of the video as a mask to the upper part.
Append the generated Bitmap to the list of frames.

Upon completing this process, we obtain a List<Bitmap> containing all the ordered, transformed (mask-applied) frames of the video. To animate the profile picture in a boomerang manner, we simply run a linear, infinite transition. This transition starts from the first frame, proceeds to the last frame, and then returns to the first frame, repeating this cycle indefinitely.

@Immutable
class MovingCutout(
    val duration: Int,
    val bitmaps: List<ImageBitmap>,
) : Cutout

@Composable
fun rememberMovingCutoutPainter(cutout: MovingCutout): Painter {
    val state = rememberUpdatedState(newValue = cutout)
    val infiniteTransition = rememberInfiniteTransition(label = "MovingCutoutTransition")
    val currentBitmap by infiniteTransition.animateValue(
        initialValue = cutout.bitmaps.first(),
        targetValue = cutout.bitmaps.last(),
        typeConverter = state.VectorConverter,
        animationSpec = infiniteRepeatable(
            animation = tween(cutout.duration, easing = LinearEasing),
            repeatMode = RepeatMode.Reverse
        ),
        label = "MovingCutoutFrame"
    )
    return remember(cutout) {
        // A custom BitmapPainter implementation to allow delegation when getting
        //  1. Intrinsic size
        //  2. Current Bitmap
        CallbackBitmapPainter( 
            getIntrinsicSize = {
                with(cutout.bitmaps[0]) { Size(width.toFloat(), height.toFloat()) }
            },
            getImageBitmap = { currentBitmap }
        )
    }
}

private val State<MovingCutout>.VectorConverter: TwoWayConverter<ImageBitmap, AnimationVector1D>
    get() = TwoWayConverter(
        convertToVector = { AnimationVector1D(value.bitmaps.indexOf(it).toFloat()) },
        convertFromVector = { value.bitmaps[it.value.roundToInt()] }
    )

Beyond Default: Crafting Powerful Map Interactions

As a map-based social app, Bump relies heavily on the Google Maps Android SDK. While the framework provides default interactions, we wanted to push the boundaries of what’s possible. Specifically, users want to zoom in and out quickly. Although Google Maps offers pinch-to-zoom and double-tap gestures, these have limitations. Pinch-to-zoom requires two fingers, and double-tap doesn’t cover the full zoom range.

For a better user experience, we’ve added our own gestures. One particularly useful feature is edge zoom, which allows rapid zooming in and out using a single finger. Simply swipe up or down from the left or right edge of the screen. Swiping down to the bottom zooms out completely, while swiping up to the top zooms in fully.

Like Google Maps gestures, there are no visual cues for this feature, but it’s acceptable for a power gesture. We provide visual and haptic feedback to help users remember it. Currently, this is achieved with a glue-like effect that follows the finger, as shown below:

Implementing this feature involves two tasks: detecting edge zoom gestures and rendering the visual effect. Thanks to Jetpack Compose’s versatility, this can be done in just a few lines of code. We use the draggable2D Modifier to detect drags, which triggers an onDragUpdate callback to update the Google Maps camera and triggers a recomposition by updating a point variable.

@Composable
fun EdgeZoomGestureDetector(
    side: EdgeZoomSide,
    onDragStarted: () -> Unit,
    onDragUpdate: (Float) -> Unit,
    onDragStopped: () -> Unit,
    modifier: Modifier = Modifier,
    curveSize: Dp = 160.dp,
) {
    var heightPx by remember { mutableIntStateOf(Int.MAX_VALUE) }
    var point by remember { mutableStateOf(Offset.Zero) }
    val draggableState = rememberDraggable2DState { delta ->
        point = when (side) {
            EdgeZoomSide.Start -> point + delta
            EdgeZoomSide.End -> point + Offset(-delta.x, delta.y)
        }
        onDragUpdate(delta.y / heightPx)
    }
    val curveSizePx = with(LocalDensity.current) { curveSize.toPx() }
    
    Box(
        modifier = modifier
            .fillMaxHeight()
            .onPlaced {
                heightPx = it.size.height
            }
            .draggable2D(
                state = draggableState,
                onDragStarted = {
                    point = it
                    onDragStarted()
                },
                onDragStopped = {
                    point = point.copy(x = 0f)
                    onDragStopped()
                },
            )
            .drawWithCache {
                val path = Path()
                onDrawBehind {
                    path.apply {
                        reset()
                        val x = point.x.coerceAtMost(curveSizePx / 2f)
                        val y = point.y
                        val top = y - (curveSizePx - x)
                        val bottom = y + (curveSizePx - x)
                        moveTo(0f, top)
                        cubicTo(
                            0f, top + (y - top) / 2f,
                            x, top + (y - top) / 2f,
                            x, y
                        )
                        cubicTo(
                            x, y + (bottom - y) / 2f,
                            0f, y + (bottom - y) / 2f,
                            0f, bottom,
                        )
                    }

                    scale(side.toXScale(), 1f) {
                        drawPath(path, Palette.black)
                    }
                }
            }
    )
}

enum class EdgeZoomSide(val alignment: Alignment) {
    Start(Alignment.CenterStart),
    End(Alignment.CenterEnd),
}

private fun EdgeZoomSide.toXScale(): Float = when (this) {
    EdgeZoomSide.Start -> 1f
    EdgeZoomSide.End -> -1f
}

The drawing part is handled by the drawBehind Modifier, which creates a Path consisting of two simple cubic curves, emulating a Gaussian curve. Before rendering it, the path is flipped on the X axis based on the screen side.

This effect looks nice but it also feels static, instantly following the finger without any animation effect. To improve this, we added spring-based animation. By extracting the computation of x (representing the tip of the Gaussian curve) from drawBehind into an animatable state, we achieve a smoother visual effect:

val x by animateFloatAsState(
    targetValue = point.x.coerceAtMost(curveSizePx / 2f),
    label = "animated-curve-width",
)

This creates a visually appealing effect that feels natural. However, we wanted to engage other senses too, so we introduced haptic feedback to mimic the feel of a toothed wheel on an old safe. Using Kotlin Flow and LaunchedEffect and snapshotFlow this was implemented in a very few lines of code:

val haptic = LocalHapticFeedback.current
LaunchedEffect(heightPx, slotCount) {
    val slotHeight = heightPx / slotCount
    snapshotFlow { (point.y / slotHeight).toInt() }
        .drop(1) // Drop the initial "tick"
        .collect {
            haptic.performHapticFeedback(HapticFeedbackType.SegmentTick)
        }
}

Conclusion

Bump is filled with many other innovative features. We invite you to explore the product further to discover more of these gems. Overall, the entire Android ecosystem — including the platform, developer tools, Jetpack Compose, Google Play Services — provided most of the necessary building blocks. It offered the flexibility needed to design and implement these unique interactions. Thanks to Android, creating a standout product is just a matter of passion, time, and more than a few lines of code!

$\"\"$

Bump’s Journey into Delightful Experiences on Android with Jetpack Compose was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/b2a1f8048018","Bump’s Journey into Delightful Experiences on Android with Jetpack Compose",{"_2445":21},{"_8":2634,"_30":2635,"_2456":2457,"_2458":2636,"_2445":13,"_2460":2637,"_36":2638,"_2463":2639},427,"2025-02-12T19:09:57+00:00","

Enhancing Performance and Fidelity Across Platforms

Introduction

Dive into Flutter 3.29! This release refines development and boosts performance, with updates to Impeller, Cupertino, DevTools and more. With 104 unique authors contributing this release cycle, Flutter 3.29 showcases the community’s dedication. Let’s explore what’s new!

Framework

Cupertino updates

CupertinoNavigationBar and CupertinoSliverNavigationBar now accept a bottom widget, typically a search field or segmented control.

In a CupertinoSliverNavigationBar, this bottom widget can be configured using the bottomMode property to either automatically resize until hidden or to always be shown when the navigation bar is scrolled.

Other changes to the navigation bars include:

When partially scrolled, CupertinoSliverNavigationBar snaps between its expanded and collapsed state.
A new CupertinoNavigationBar.large constructor allows the static navigation bar to display a large title.
Thanks to community contributor davidhicks980, Cupertino popups now have more vibrant background blurs, which improves native fidelity.

The new CupertinoSheetRoute shows an iOS-styled modal sheet view that can be removed using the drag-to-dismiss gesture.
The new showCupertinoSheet function displays the sheet with a common setup for nested navigation baked in.

Community member thejitenpatel improved CupertinoAlertDialog’s native fidelity in dark mode, as shown in the following screenshots:

\"\" — Before improvement — Left is a native view, right is a Flutter view

\"\" — After improvement — Left is a native view, right is a Flutter view

When inverted, Flutter’s text selection handles swap their order on iOS, and the border color of the text selection magnifier now matches the current theme.

Material

The FadeForwardsPageTransitionsBuilder is the new Material 3 (M3) page transition builder, designed to match the Android’s latest page transition behavior. During the transition, the incoming page slides in from right to left while simultaneously fading in, and the outgoing page slides out from right to left, fading out concurrently. This new transition also addresses the performance issues previously caused by the ZoomPageTransitionsBuilder.

This release updates the CircularProgressIndicator and LinearProgressIndicator to align with the latest Material Design 3 specifications. To use the updated styling, either set the year2023 property to false, or set ProgressIndicatorThemeData.year2023 to false.

This release also introduces the latest Material 3 Slider design, featuring updated track and handle shapes. The Slider defaults to the previous Material 3 style. To enable the latest design, either set year2023 to false, or set SliderThemeData.year2023 to false.

This release includes several bug fixes and feature enhancements for the Material library. Notable fixes include:

Keyboard navigation now correctly triggers the DropdownMenu.onSelected callback.
Improved TabBar elastic tab animation.
Improved RangeSlider thumb alignment with divisions, thumb padding, and rounded corners.

In addition to bug fixes, this release enhances the customizability of several Material components. The mouseCursor property has been added to Chip, Tooltip, and ReorderableListView, allowing for custom mouse cursors on hover.

Text selection

Flutter now gives you more information about the selection under a SelectionArea or SelectableRegion with SelectionListener and SelectionListenerNotifier. The SelectionDetails object, available through SelectionListenerNotifier, provides you with the start and end offsets of the selection (relative to the wrapped subtree), and indicates whether a selection exists and if it’s collapsed. For a widget or selectable subtree that you want to listen to, wrap it with the SelectionListener widget.

Flutter also gives you information regarding the status of a SelectionArea or SelectableRegion through the SelectableRegionSelectionStatusScope inherited widget. You can check whether a parent SelectionArea or SelectableRegion is actively changing or has finalized its selection by using SelectableRegionSelectionStatusScope.maybeOf(context) and checking the SelectableRegionSelectionStatus.

Accessibility

This release improves the accessibility of several Material widgets:

When a screen reader is enabled, the Form widget only announces the first error that it encounters.
A screen reader now announces the correct label for dropdown menus.

Web

When initially released in May 2024, Flutter’s WebAssembly (wasm) support on the web required you to host your Flutter applications with special HTTP response headers. This requirement has now been relaxed. While updating the headers allows Flutter web apps built with wasm to run with multiple threads, using default headers now allows the application to run with wasm, but limited to a single thread.

We have fixed several issues around images on the WebGL backends but the most important are:

Engine

Impeller Vulkan stability

Thanks to the feedback and bug reports on the 3.27 beta and stable releases, a number of correctness and performance improvements were made to the Vulkan backend, including:

Fixed a reproducible flickering and visual jitter that many users reported on older Vulkan-capable devices.
Disabled Android Hardware Buffer swapchains. This feature has been placed behind a feature flag until it’s determined that it works correctly across Android devices.
A large number of black screen and crash reports were the result of using Vulkan on MediaTek/PowerVR soc’s and have been disabled. These devices now only use Impeller OpenGLES (see below).
Android emulators have been updated to use the Impeller GLES backend.

Impeller OpenGLES

In 3.29, Android devices that don’t have a functional Vulkan driver will fall back to Impeller running on OpenGLES instead of using Skia. This behavior is enabled by default and doesn’t need to be configured. This brings Impeller support on Android to 100% of Flutter’s supported Android devices.

Impeller on iOS

Skia support has been removed from the iOS backend and the FLTEnableImpeller opt-out flag no longer works. Further binary size reductions are expected in future releases as we begin to remove Skia components from iOS builds.

New features

This release contains a number of new features that take advantage of the Impeller backend.

Backdrop filter optimizations

Applications that display multiple backdrop filters can now use the new widget BackdropGroup and a new BackdropFilter.grouped constructor. These can improve performance of multiple blurs above and beyond what was possible on the Skia backend. For an example, visit the basic.dart source code.

ImageFilter.shader

A new ImageFilter constructor allows applying a custom shader to any child widgets. This provides similar functionality to the AnimatedSampler widget from package:flutter_shaders, except that it also works with backdrop filters. For an example, visit the painting.dart source code.

Dart threading changes on Android/iOS

Previously, Flutter executed Dart code on a different thread (UI thread) than the platform’s main thread. This allowed higher theoretical throughput if both platform and UI threads were occupied, but came at the cost of making most platform interop require serialized and asynchronous message passing. This architecture also had knock-on effects on text input, accessibility, plugins, and so on.

Starting in 3.29, Flutter on Android and iOS execute Dart code on the application’s main thread, and there is no longer a separate UI thread. This is the first part in a series of changes to improve platform interop on mobile platforms, as it allows making synchronous calls to and from the platform without the overhead of serialization and message passing.

DevTools and IDEs

New DevTools inspector

The new DevTools inspector is enabled by default for all users. The new inspector has a condensed widget tree, a new widget properties view, and an option to automatically update in response to hot-reload and navigation events. For more details, visit the new inspector page on docs.flutter.dev.

Changes to on-device widget selection

After enabling widget selection mode from the DevTools inspector, any selections on the device are considered widget selections until you exit widget selection mode. Previously, after the initial widget selection you needed to click the on-device Select widget button to then select another widget. Instead, there is now an on-device button that can be used to quickly exit widget selection mode.

Logging tool improvements

The Logging tool in DevTools has been improved in the following ways:

Logs include and display more metadata such as log severity, category, zone, and isolate.
Added support for filtering by log severity level.
Significant improvement in performance and initial load time.

These are just a few highlights from this release. To learn more about all the updates included in Flutter 3.29, check out the release notes for DevTools 2.41.0 and 2.42.2.

Breaking changes and deprecations

Discountinuing package support

We plan to discontinue support for the following packages on April 30th, 2025:

ios_platform_images; see ios_platform_images planned to be discontinued #162961
css_colors; see css_colors planned to be discontinued #162962
palette_generator; see palette_generator planned to be discontinued #162963
flutter_image; see flutter_image discontinued #162964
flutter_adaptive_scaffold; see flutter_adaptive_scaffold planned to be discontinued #162965
flutter_markdown; see flutter_markdown planned to be discontinued #162966

We encourage any interested members of the community to coordinate on establishing and maintaining forks. Links to the issues are provided above for discussion and coordination.

Removal of script-based application of the Flutter Gradle plugin

Removal of script-based application of the Flutter Gradle plugin, which has been deprecated since 3.19. This supports converting the Flutter Gradle plugin from Groovy to Kotlin, and towards migrating it to use AGPs public API. This work is expected to decrease the frequency of breakages when a new AGP version is published and reduce build-based regressions.

Projects created before 3.16 that have not yet migrated will likely be impacted. If the flutter tool logs the warning: “You are applying Flutter’s main Gradle plugin imperatively” when building your project, you are impacted and need to migrate according to Deprecated imperative apply of Flutter’s Gradle plugins on docs.flutter.dev.

Removal of the web HTML renderer

This is the first release where the HTML renderer has been removed from Flutter web. For more information, visit The intent to deprecate and remove the HTML renderer in Flutter web and Issue 145584: Intent to deprecate and remove the HTML renderer in Flutter web.

Web image handling

This release also gives you more control over how images are displayed on the web. In the previous beta release (3.28), Image widgets would automatically use <img> elements to display images from URLs when CORS errors occurred. This could lead to inconsistent behavior. Now, the webHtmlElementStrategy flag lets you choose when <img> elements are used. While this fallback is disabled by default, you can still enable the fallback or even prioritize <img> elements if needed for your application.

Material normalization

As part of our ongoing theme normalization project in Material, this release deprecates ThemeData.dialogBackgroundColor in favor of DialogThemeData.backgroundColor. You can use the dart fix command to migrate affected code.

Also in Material, the ButtonStyleButton iconAlignment property was deprecated after being added to ButtonStyle and associated styleFrom methods.

For all breaking changes in this release, see the full list of migration guidance on the breaking changes page of the website.

As always, many thanks to the community for contributing tests — these help us identify breaking changes. To learn more, check out Flutter’s breaking change policy.

Conclusion

Thanks to the Flutter community for making this release possible! We’re excited for the future and can’t wait to see your apps. Check the release notes and changelog, then run flutter upgrade and start building!

$\"\"$

What’s new in Flutter 3.29 was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/f90c380c2317","What’s new in Flutter 3.29",{"_2445":13},{"_8":2641,"_30":2642,"_2456":2457,"_2458":2643,"_2445":21,"_2460":2644,"_36":2645,"_2463":2646},741,"2025-01-23T23:44:03+00:00","

Second Developer Preview of Android 16, Android XR, Spotlight Week on Android Camera and Media, Android Studio Ladybug Feature Drop and more!

Welcome to the 113th iteration of Now in Android — your ongoing guide to what’s new and notable in the world of Android development.

In this edition, we’ll cover the Second Developer Preview of Android 16, Android XR, the Spotlight Week on Android Camera and Media, the Android Studio Ladybug Feature Drop and more!

Most of the content of this post is available in the form of a video or podcast, so feel free to watch or listen rather than read on. (Or do all three to help you remember! There won’t be a quiz.)

The Second Developer Preview of Android 16 🤖

We released the second Developer Preview of Android 16, ahead of the planned release in Q2 of 2025. Android 16 introduces major and minor API releases to allow us to drive faster innovation with more frequent API releases. We’re planning both a major and minor API release in 2025, and only the Q2 major release will include app-impacting planned behavior changes; the minor release introduces new features without these changes, so you can focus your app testing on major releases.

This developer preview focuses on performance optimization, developer tools, haptic feedback enhancements, task management, adaptive refresh rate improvements and more.

Android 16 Developer Preview 2 introduces System Triggered Profiling to help developers collect profiling data during critical scenarios like app startups or ANR events. It improves developer tools with enhanced job introspection, allowing apps to identify multiple reasons why jobs are pending and debug task scheduling more effectively. Haptic feedback enhancements include new APIs to define detailed amplitude and frequency curves for more nuanced tactile responses across devices.

Additionally, adaptive refresh rate improvements refine app behavior on devices with variable refresh rates, optimizing performance and reducing power consumption. Predictive back additions include new APIs to help play corresponding ahead-of-time animations when the back gesture is invoked.

Get started today by testing your app with Android 16 in the emulator or by flashing a system image onto a Pixel device.

The Second Developer Preview of Android 16

Android XR 👓

We released the Developer Preview of the Android XR SDK, a toolkit to create immersive extended reality (XR) experiences on Android.

The SDK helps developers:

Spatialize Applications: Add 3D elements, spatial panels, and spatial audio.
Build Immersive Environments: Create virtual or augmented spaces.
Enable Natural Interactions: Support hand and eye tracking for intuitive engagement.
It includes Jetpack XR SDK for Compose and Material Design in XR, Unity Integration for real-time 3D development, WebXR for immersive web experiences, and OpenXR 1.1 for native C/C++ development. The Play Store will also support XR apps, with existing apps spatialized automatically.

At XR Unlocked ’24, we shared how to design intuitive and engaging apps for Android XR. We covered XR design principles, considerations, and practical approaches to interaction and UI that leverage the unique capabilities of the platform and help you elevate your app’s design.

Then, Ryan, Spencer, Tricia, and Luke discussed how to build immersive experiences with Open XR and Unity by building on top of supporting industry standards and tools familiar to XR developers. They explored OpenXR APIs, our partnership with Unity, and the experimental release of Unity for Android XR, including features and roadmap.

Additionally, if you wondered how to adapt existing Android apps for Android XR devices, Yasmine, Patrick, and Stevan covered new tools and resources available. You can start building with the Android XR SDK and see your changes come to life in the Android XR Emulator within Android Studio. Also, you can learn how to use what you already know to deliver great experiences to your users.

Spotlight Week on Android Camera and Media 📷

The week of January 7th is a Spotlight Week on Android Camera and Media, offering resources to help you uplevel the media experiences in your app. Check out this blog post for everything that we covered during the week!

Spotlight Week: Android Camera and Media

Tuesday focused on the latest releases in CameraX and Media3, including guidance on building camera apps with Compose.

Getting Started with CameraX in Jetpack Compose

Wednesday emphasized creating premium user experiences, such as utilizing the Media Performance Class and enabling HDR video capture. We featured Google Drive’s implementation of Ultra HDR images and Instagram’s enhancement of in-app image capture with Night Mode.

How Instagram enabled users to take stunning Low Light Photos

Thursday addressed adapting camera and media apps for large screens and the new Android XR platform, covering media experiences on large devices, implementing tabletop mode for camera applications, and preparing apps for XR with considerations for spatial audio and video.

Optimize your camera app on foldable devices with Jetpack WindowManager | Android Developers

Friday delved into media creation, exploring Media3’s Transformer module for media processing, showcasing the 1 Second Everyday app, and introducing a new API for capturing concurrent camera streams. Android GDE Tom Colvin also shared how he built a hand gesture recognizer app with CameraX and MediaPipe.

Articles 📝

Reddit improved app startup speed by over 50% using Baseline Profiles and R8

Ben Weiss collaborated with Reddit to explore how they leveraged Baseline Profiles, the R8 compiler, and Jetpack Compose to reduce startup times, enhance rendering performance, optimize bytecode, and modernize legacy UI, improving both user and developer experiences.

Reddit improved app startup speed by over 50% using Baseline Profiles and R8

What’s new in CameraX 1.4.0 and a sneak peek of Jetpack Compose support 📷

Scott Nien showcased the expanded HDR capabilities, preview stabilization, and versatile effects framework in CameraX 1.4.0. He also demonstrated how to seamlessly integrate CameraX with Jetpack Compose, empowering developers to leverage Android’s camera capabilities for creating exceptional app experiences.

What's new in CameraX 1.4.0 and a sneak peek of Jetpack Compose support

How Instagram enabled users to take stunning Low Light Photos 📹

Donovan McMurray detailed how Instagram improved its Android app with Night Mode, enabling users to capture higher-quality photos in low-light settings. This feature leverages Android’s Camera Extensions API to tap into device-specific capabilities, ensuring a consistent and scalable experience across devices.

How Instagram enabled users to take stunning Low Light Photos

Unlocking the Power of CameraX in Jetpack Compose

Jolanda Verhoef demonstrated how to integrate the camera-compose APIs into your app, showcasing the delightful UI experiences they enable. In Part 1, she covered building a basic camera preview using the new camera-compose artifact, including permission handling and basic integration. In Part 2, she implemented a visual tap-to-focus feature using the Compose gesture system, graphics, and coroutines.

Performance Class helps Google Maps deliver premium experiences

Nevin Mital demonstrated how Google Maps leveraged MPC to roll out a UI transparency feature exclusively to higher-performing devices and provided guidance on implementing MPC in your apps with the Core Performance library.

Performance Class helps Google Maps deliver premium experiences

Get your apps ready for 16 KB page size devices

Yacine Rezgui walked you through the essential steps to prepare your apps for 16 KB page size devices, unlocking performance enhancements, enabling future innovations, and delivering smoother, more immersive app experiences to users.

Get your apps ready for 16 KB page size devices

Android Studio Ladybug Feature Drop 🐞

Steven Jenkins announced the stable release of Android Studio’s Ladybug Feature Drop, introducing five Gemini in Android Studio features, Animation Preview support for Wear Tiles, and an App Links Assistant to simplify app development. These enhancements are designed to improve developer productivity and support the creation of high-quality Android applications.

AndroidX Releases 🚀

There were a lot of alpha releases.

To help you build for Android XR, we have added:

ARCore for Jetpack 1.0.0-alpha01 for advanced perception capabilities
Jetpack Compose for XR 1.0.0-alpha01 for declaratively building Spatial UI layouts
Material Design for XR 1.0.0-alpha01 for component and layout guidance
Jetpack SceneCore 1.0.0-alpha01 for 3D content manipulation
XR Runtime 1.0.0-alpha01 has fundamental pieces of functionality for the Jetpack XR suite of library experiences

For Camera and Media, we have added:

Camera Media3 1.0.0-alpha01 is adapter library for using Media3 effects with CameraX
Media3 1.6.0-alpha01 adds a lot of changes to the ExoPlayer, Transformer, Extractors, UI and more

Transition Version 1.6.0-alpha01 sets the disjoint parent for ViewOverlays used to animate its transitions.

Tv-Material 1.1.0-alpha01 changes FocusEnterExitScope.cancelFocus() to cancelFocusChange() and replaces FocusProperties.enter and FocusProperties.exit with onEnter and onExit.

Don’t fret, there’s stability — there were also some stable releases.

AndroidX Core 1.16.0-alpha01 has a fix for inset dispatching for Views.

ViewPager 1.1.0 is stable and adds support for Android 12 stretch over scroll edge effect and nullability annotations in ViewPager.

Activity 1.10.0 is stable and adds a new LocalActivity composition local that provides the Activity for the current scope and PhotoPicker allows picking images in order and choosing which tab should be initially visible.

RecyclerView 1.4.0 is stable and has Adaptive refresh rate support.

Now then… 👋

That’s it for this week, with the Second Developer Preview of Android 16, Android XR, the Spotlight Week on Android Camera and Media, the Android Studio Ladybug Feature Drop and more!

Check back soon for your next update from the Android developer universe! 💫

$\"\"$

Now in Android #113 was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/d6617517df62","Now in Android #113",{"_2445":21},{"_8":2648,"_30":2649,"_2456":2457,"_2458":2650,"_2445":21,"_2460":2651,"_36":2652,"_2463":2653},742,"2025-01-23T17:03:20+00:00","

Part 3 of Unlocking the Power of CameraX in Jetpack Compose

Hey there! Welcome back to our series on CameraX and Jetpack Compose. In the previous posts, we’ve covered the fundamentals of setting up a camera preview and added tap-to-focus functionality.

🧱 Part 1: Building a basic camera preview using the new camera-compose artifact. We covered permission handling and basic integration.
👆 Part 2: Using the Compose gesture system, graphics, and coroutines to implement a visual tap-to-focus.
🔦 Part 3 (this post): Exploring how to overlay Compose UI elements on top of your camera preview for a richer user experience.
📂 Part 4: Using adaptive APIs and the Compose animation framework to smoothly animate to and from tabletop mode on foldable phones.

In this post, we’ll dive into something a bit more visually engaging — implementing a spotlight effect on top of our camera preview, using face detection as the basis for the effect. Why, you say? I’m not sure. But it sure looks cool 🙂. And, more importantly, it demonstrates how we can easily translate sensor coordinates into UI coordinates, allowing us to use them in Compose!

Enable face detection

First, let’s modify the CameraPreviewViewModel to enable face detection. We’ll use the Camera2Interop API, which allows us to interact with the underlying Camera2 API from CameraX. This gives us the opportunity to use camera features that are not exposed by CameraX directly. We need to make the following changes:

Create a StateFlow that contains the face bounds as a list of Rects.
Set the STATISTICS_FACE_DETECT_MODE capture request option to FULL, which enables face detection.
Set a CaptureCallback to get the face information from the capture result.

class CameraPreviewViewModel : ViewModel() {
    ...
    private val _sensorFaceRects = MutableStateFlow(listOf<Rect>())
    val sensorFaceRects: StateFlow<List<Rect>> = _sensorFaceRects.asStateFlow()

    private val cameraPreviewUseCase = Preview.Builder()
        .apply {
            Camera2Interop.Extender(this)
                .setCaptureRequestOption(
                    CaptureRequest.STATISTICS_FACE_DETECT_MODE,
                    CaptureRequest.STATISTICS_FACE_DETECT_MODE_FULL
                )
                .setSessionCaptureCallback(object : CameraCaptureSession.CaptureCallback() {
                    override fun onCaptureCompleted(
                        session: CameraCaptureSession,
                        request: CaptureRequest,
                        result: TotalCaptureResult
                    ) {
                        super.onCaptureCompleted(session, request, result)
                        result.get(CaptureResult.STATISTICS_FACES)
                            ?.map { face -> face.bounds.toComposeRect() }
                            ?.toList()
                            ?.let { faces -> _sensorFaceRects.update { faces } }
                    }
                })
        }
        .build().apply {
    ...
}

With these changes in place, our view model now emits a list of Rectobjects representing the bounding boxes of detected faces in sensor coordinates.

Translate sensor coordinates to UI coordinates

The bounding boxes of detected faces that we stored in the last section use coordinates in the sensor coordinate system. To draw the bounding boxes in our UI, we need to transform these coordinates so that they are correct in the Compose coordinate system. We need to:

Transform the sensor coordinates into preview buffer coordinates
Transform the preview buffer coordinates into Compose UI coordinates

These transformations are done using transformation matrices. Each of the transformations has its own matrix:

Our SurfaceRequest holds on to a TransformationInfo instance, which contains a sensorToBufferTranform matrix.
Our CameraXViewfinder has an associated CoordinateTransformer. You might remember that we already used this transformer in the previous blog post to transform tap-to-focus coordinates.

We can create a helper method that can do the transformation for us:

private fun List<Rect>.transformToUiCoords(
    transformationInfo: SurfaceRequest.TransformationInfo?,
    uiToBufferCoordinateTransformer: MutableCoordinateTransformer
): List<Rect> = this.map { sensorRect ->
    val bufferToUiTransformMatrix = Matrix().apply {
        setFrom(uiToBufferCoordinateTransformer.transformMatrix)
        invert()
    }

    val sensorToBufferTransformMatrix = Matrix().apply {
        transformationInfo?.let {
            setFrom(it.sensorToBufferTransform)
        }
    }

    val bufferRect = sensorToBufferTransformMatrix.map(sensorRect)
    val uiRect = bufferToUiTransformMatrix.map(bufferRect)

    uiRect
}

We iterate through the list of detected faces, and for each face execute the transformation.
The CoordinateTransformer.transformMatrix that we get from our CameraXViewfinder transforms coordinates from UI to buffer coordinates by default. In our case, we want the matrix to work the other way around, transforming buffer coordinates into UI coordinates. Therefore, we use the invert() method to invert the matrix.
We first transform the face from sensor coordinates to buffer coordinates using the sensorToBufferTransformMatrix, and then transform those buffer coordinates to UI coordinates using the bufferToUiTransformMatrix.

Implement the spotlight effect

Now, let’s update the CameraPreviewContent composable to draw the spotlight effect. We’ll use a Canvas composable to draw a gradient mask over the preview, making the detected faces visible:

@Composable
fun CameraPreviewContent(
    viewModel: CameraPreviewViewModel,
    modifier: Modifier = Modifier,
    lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current
) {
    val surfaceRequest by viewModel.surfaceRequest.collectAsStateWithLifecycle()
    val sensorFaceRects by viewModel.sensorFaceRects.collectAsStateWithLifecycle()
    val transformationInfo by
        produceState<SurfaceRequest.TransformationInfo?>(null, surfaceRequest) {
            try {
                surfaceRequest?.setTransformationInfoListener(Runnable::run) { transformationInfo ->
                    value = transformationInfo
                }
                awaitCancellation()
            } finally {
                surfaceRequest?.clearTransformationInfoListener()
            }
        }
    val shouldSpotlightFaces by remember {
        derivedStateOf { sensorFaceRects.isNotEmpty() && transformationInfo != null} 
    }
    val spotlightColor = Color(0xDDE60991)
    ..

    surfaceRequest?.let { request ->
        val coordinateTransformer = remember { MutableCoordinateTransformer() }
        CameraXViewfinder(
            surfaceRequest = request,
            coordinateTransformer = coordinateTransformer,
            modifier = ..
        )

        AnimatedVisibility(shouldSpotlightFaces, enter = fadeIn(), exit = fadeOut()) {
            Canvas(Modifier.fillMaxSize()) {
                val uiFaceRects = sensorFaceRects.transformToUiCoords(
                    transformationInfo = transformationInfo,
                    uiToBufferCoordinateTransformer = coordinateTransformer
                )

                // Fill the whole space with the color
                drawRect(spotlightColor)
                // Then extract each face and make it transparent

                uiFaceRects.forEach { faceRect ->
                    drawRect(
                        Brush.radialGradient(
                            0.4f to Color.Black, 1f to Color.Transparent,
                            center = faceRect.center,
                            radius = faceRect.minDimension * 2f,
                        ),
                        blendMode = BlendMode.DstOut
                    )
                }
            }
        }
    }
}

Here’s how it works:

We collect the list of faces from the view model.
To make sure we’re not recomposing the whole screen every time the list of detected faces changes, we use derivedStateOf to keep track of whether any faces are detected at all. This can then be used with AnimatedVisibility to animate the colored overlay in and out.
The surfaceRequest contains the information we need to transform sensor coordinates to buffer coordinates in the SurfaceRequest.TransformationInfo. We use the produceState function to set up a listener in the surface request, and clear this listener when the composable leaves the composition tree.
We use a Canvas to draw a translucent pink rectangle that covers the entire screen.
We defer the reading of the sensorFaceRects variable until we’re inside the Canvas draw block. Then we transform the coordinates into UI coordinates.
We iterate over the detected faces, and for each face, we draw a radial gradient that will make the inside of the face rectangle transparent.
We use BlendMode.DstOut to make sure that we are cutting out the gradient from the pink rectangle, creating the spotlight effect.

Note: When you change the camera to DEFAULT_FRONT_CAMERA you will notice that the spotlight is mirrored! This is a known issue, tracked in the Google Issue Tracker.

Result

With this code, we have a fully functional spotlight effect that highlights detected faces. You can find the full code snippet here.

This effect is just the beginning — by using the power of Compose, you can create a myriad of visually stunning camera experiences. Being able to transform sensor and buffer coordinates into Compose UI coordinates and back means we can utilize all Compose UI features and integrate them seamlessly with the underlying camera system. With animations, advanced UI graphics, simple UI state management, and full gesture control, your imagination is the limit!

In the final post of the series, we’ll dive into how to use adaptive APIs and the Compose animation framework to seamlessly transition between different camera UIs on foldable devices. Stay tuned!

The code snippets in this blog have the following license:

// Copyright 2024 Google LLC. SPDX-License-Identifier: Apache-2.0

Many thanks to Nick Butcher, Alex Vanyo, Trevor McGuire, Don Turner and Lauren Ward for reviewing and providing feedback. Made possible by the hard work of Yasith Vidanaarachch.

$\"\"$

Create a spotlight effect with CameraX and Jetpack Compose was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/8a7fa5b76641","Create a spotlight effect with CameraX and Jetpack Compose",{"_2445":21},{"_8":2655,"_30":2656,"_2456":2457,"_2458":2657,"_2445":21,"_2460":2658,"_36":2659,"_2463":2660},743,"2025-01-09T17:04:14+00:00","

Part 2 of Unlocking the Power of CameraX in Jetpack Compose

This blog post is a part of Camera and Media Spotlight Week. We’re providing resources — blog posts, videos, sample code, and more — all designed to help you uplevel the media experiences in your app.

To learn more about what Spotlight Week has to offer and how it can benefit you, be sure to read our overview blog post.

Welcome back! In the first post of this series, we built a basic camera preview using the new camera-compose artifact. We covered permission handling and basic integration, and now it’s time to get more interactive!

🧱 Part 1: Building a basic camera preview using the new camera-compose artifact. We’ll cover permission handling and basic integration.
👆 Part 2 (this post): Using the Compose gesture system, graphics, and coroutines to implement a visual tap-to-focus.
🔎 Part 3: Exploring how to overlay Compose UI elements on top of your camera preview for a richer user experience.
📂 Part 4: Using adaptive APIs and the Compose animation framework to smoothly animate to and from tabletop mode on foldable phones.

In this post, we’ll dive into implementing the tap-to-focus feature. This involves understanding how to translate Compose touch events to camera sensor coordinates, and adding a visual indicator to show the user where the camera is focusing.

There’s an open feature request for a higher level composable that will contain more out-of-the-box functionality (like tap-to-focus and zooming). Please upvote the feature if you need this!

Add tap-to-focus functionality to the view model

First, let’s modify the CameraPreviewViewModel to handle tap-to-focus logic. We need to adapt our existing code in two ways:

We hold on to a SurfaceOrientedMeteringPointFactory, that is able to translate the tap coordinates coming from the UI into a MeteringPoint.
We hold on to a CameraControl, that can be used to interact with the camera. Once we have the correct MeteringPoint, we pass it to that camera control to be used as the reference point for auto-focusing.

class CameraPreviewViewModel : ViewModel() {
    ..
    private var surfaceMeteringPointFactory: SurfaceOrientedMeteringPointFactory? = null
    private var cameraControl: CameraControl? = null

    private val cameraPreviewUseCase = Preview.Builder().build().apply {
        setSurfaceProvider { newSurfaceRequest ->
            _surfaceRequest.update { newSurfaceRequest }
            surfaceMeteringPointFactory = SurfaceOrientedMeteringPointFactory(
                newSurfaceRequest.resolution.width.toFloat(),
                newSurfaceRequest.resolution.height.toFloat()
            )
        }
    }

    suspend fun bindToCamera(appContext: Context, lifecycleOwner: LifecycleOwner) {
        val processCameraProvider = ProcessCameraProvider.awaitInstance(appContext)
        val camera = processCameraProvider.bindToLifecycle(
            lifecycleOwner, DEFAULT_BACK_CAMERA, cameraPreviewUseCase
        )
        cameraControl = camera.cameraControl

        // Cancellation signals we're done with the camera
        try { awaitCancellation() } finally {
            processCameraProvider.unbindAll()
            cameraControl = null
        }
    }

    fun tapToFocus(tapCoords: Offset) {
        val point = surfaceMeteringPointFactory?.createPoint(tapCoords.x, tapCoords.y)
        if (point != null) {
            val meteringAction = FocusMeteringAction.Builder(point).build()
            cameraControl?.startFocusAndMetering(meteringAction)
        }
    }
}

We create a SurfaceOrientedMeteringPointFactory when the SurfaceRequest is available, using the surface’s resolution. This factory translates the tapped coordinates on the surface to a focus metering point.
We assign the cameraControl attached to the Camera when we bind to the camera’s lifecycle. We then reset it to null when the lifecycle ends.
The tapToFocus function takes an Offset representing the tap location in sensor coordinates, translates it to a MeteringPoint using the factory, and then uses the CameraX cameraControl to initiate the focus and metering action.

Note: We could improve the interaction between UI and CameraControl somewhat by using a more sophisticated coroutines setup, but this is outside the scope of this blog post. If you’re interested in learning more about such an implementation, check out the Jetpack Camera App sample, which implements camera interactions through the CameraXCameraUseCase.

Transform gesture from display to sensor coordinates

Now, let’s update the CameraPreviewContent composable to handle touch events and pass those events to the view model. To do that, we’ll use the pointerInput modifier and the detectTapGestures extension function:

@Composable
fun CameraPreviewContent(..) {
    ..

    surfaceRequest?.let { request ->
        val coordinateTransformer = remember { MutableCoordinateTransformer() }
        CameraXViewfinder(
            surfaceRequest = request,
            coordinateTransformer = coordinateTransformer,
            modifier = modifier.pointerInput(Unit) {
                detectTapGestures { tapCoords ->
                    with(coordinateTransformer) {
                        viewModel.tapToFocus(tapCoords.transform()) 
                    }
                }
            }
        )
    }
}

We use the pointerInput modifier and detectTapGestures to listen for tap events on the CameraXViewfinder.
We create a MutableCoordinateTransformer, which is provided by the camera-compose library, to transform the tap coordinates from the layout’s coordinate system to the sensor’s coordinate system. This transformation is non-trivial! The physical sensor is often rotated relative to the screen, and additional scaling and cropping is done to make the image fit the container it’s in. We pass the mutable transformer instance into the CameraXViewfinder. Internally, the viewfinder sets the transformation matrix of the transformer. This transformation matrix is capable of transforming local window coordinates into sensor coordinates.
Inside the detectTapGestures block, we use the coordinateTransformer to transform the tap coordinates before passing them to the tapToFocus function of our view model.

As we’re using typical Compose gesture handling, we unlock any sort of gesture recognition. So if you want to focus after the user triple-taps, or swipes up and down, nothing is holding you back! This is an example of the power of the new CameraX Compose APIs. They are built from the ground up, in an open way, so that you can extend and build whatever you need on top of them. Compare this to the old CameraController that had tap-to-focus built in — that’s great if tap-to-focus is what you need, but it didn’t give you any opportunity to customize the behavior.

Visual indicator when tapping to focus

To provide visual feedback to the user, we’ll add a small white circle that briefly appears at the tap location. We’ll use Compose animation APIs to fade it in and out:

@Composable
fun CameraPreviewContent(
    viewModel: CameraPreviewViewModel,
    modifier: Modifier = Modifier,
    lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current
) {
    val surfaceRequest by viewModel.surfaceRequest.collectAsStateWithLifecycle()
    val context = LocalContext.current
    LaunchedEffect(lifecycleOwner) {
        viewModel.bindToCamera(context.applicationContext, lifecycleOwner)
    }

    var autofocusRequest by remember { mutableStateOf(UUID.randomUUID() to Offset.Unspecified) }

    val autofocusRequestId = autofocusRequest.first
    // Show the autofocus indicator if the offset is specified
    val showAutofocusIndicator = autofocusRequest.second.isSpecified
    // Cache the initial coords for each autofocus request
    val autofocusCoords = remember(autofocusRequestId) { autofocusRequest.second }

    // Queue hiding the request for each unique autofocus tap
    if (showAutofocusIndicator) {
        LaunchedEffect(autofocusRequestId) {
            delay(1000)
            // Clear the offset to finish the request and hide the indicator
            autofocusRequest = autofocusRequestId to Offset.Unspecified
        }
    }

    surfaceRequest?.let { request ->
        val coordinateTransformer = remember { MutableCoordinateTransformer() }
        CameraXViewfinder(
            surfaceRequest = request,
            coordinateTransformer = coordinateTransformer,
            modifier = modifier.pointerInput(viewModel, coordinateTransformer) {
                detectTapGestures { tapCoords ->
                    with(coordinateTransformer) {
                        viewModel.tapToFocus(tapCoords.transform())
                    }
                    autofocusRequest = UUID.randomUUID() to tapCoords
                }
            }
        )

        AnimatedVisibility(
            visible = showAutofocusIndicator,
            enter = fadeIn(),
            exit = fadeOut(),
            modifier = Modifier
                .offset { autofocusCoords.takeOrElse { Offset.Zero } .round() }
                .offset((-24).dp, (-24).dp)
        ) {
            Spacer(Modifier.border(2.dp, Color.White, CircleShape).size(48.dp))
        }
    }
}

We use the mutable state autofocusRequest to manage the visibility state of the focus box and the tap coordinates.
A LaunchedEffect is used to trigger the animation. When the autofocusRequest is updated, we briefly show the autofocus box and hide it after a delay.
We use AnimatedVisibility to show the focus box with a fade-in and fade-out animation.
The focus box is a simple Spacer with a white border in a circular shape, positioned using offset modifiers.

In this sample, we chose a simple white circle fading in and out, but the sky is the limit and you can create any UI using the powerful Compose components and animation system. Confetti, anyone? 🎊

Result

Our camera preview now responds to touch events! Tapping on the preview triggers a focus action in the camera and shows a visual indicator where you tapped. You can find the full code snippet here and a version using the Konfetti library here.

In the next post, we’ll explore how to overlay Compose UI elements on top of your camera preview for a fancy spotlight effect. Stay tuned!

The code snippets in this blog have the following license:

// Copyright 2024 Google LLC. SPDX-License-Identifier: Apache-2.0

Many thanks to Nick Butcher, Trevor McGuire, Alex Vanyo and Lauren Ward for reviewing and providing feedback. Made possible by the hard work of Yasith Vidanaarachch.

$\"\"$

Tap to focus: Mastering CameraX Transformations in Jetpack Compose was originally published in Android Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/440853280a6e","Tap to focus: Mastering CameraX Transformations in Jetpack Compose",{"_2445":21},{"_8":2662,"_30":2663,"_2456":2664,"_2458":2665,"_2445":13,"_2460":2666,"_36":2667,"_2463":2668},744,"2024-12-17T20:13:46+00:00",2024,"

Just over six years ago, we unveiled Flutter 1.0. Today, at #FlutterInProduction, we’re celebrating how far we’ve come — from the immense support we’ve received from thousands of contributors in the community, to the widespread adoption of Flutter as a production-grade app framework for building multi-platform app experiences.

If you haven’t experienced Flutter yet, we invite you to try it! As we shared today, you’d be joining a big group: Flutter has over 1 million monthly active developers across the globe, and powers nearly 30% of all new iOS apps. More than 90 thousand developers actively participate in Flutter Meetups across more than sixty countries. And if you want input on designing or building a new successful Flutter app, we have a large and growing list of Flutter Consultants ready to help you.

“Apptopia tracks millions of apps in the Apple AppStore and Google Play Store, and analyzes and detects which developer SDKs were used to create the apps. Flutter is one of the most popular SDKs we track: In the Apple AppStore it has grown steadily in usage from around 10% of all tracked free apps in 2021 to nearly 30% of all tracked free apps in 2024!”

— Apptopia Inc.

A decade of innovation to reach the production era

It’s been an incredible journey, starting in 2014 (in what we now call our experimental era) as a Google experiment codenamed “Sky.”

Before Flutter, compromises were inevitable. Many developers have become skeptical that any framework can truly deliver a premium experience across multiple platforms.

With the launch of Flutter 1.0 in 2018 we had a clear mission to resolve that technology dilemma: We aimed to empower developers with the ultimate app framework for crafting beautiful, high-performance user interfaces across all platforms. Also, to enable developers to reach all customers with high-quality apps on all the platforms that customers care about, but with lower cost and in less time.

Our focus has remained constant through Flutter’s growth era, even as we’ve added support for the six major platforms across mobile, web, and desktop — and continue to push beyond, with work like Toyota’s use of Flutter for infotainment systems.

We’re now in the “production era,” and we’re celebrating that with #FlutterInProduction! This event spotlights the achievements of developers using Flutter in real-world applications.

Building in partnership with the community

None of this would be possible without our amazing community of over 1,400 contributors, more than 10,000 package publishers authoring over 50,000 packages, and passionate Flutter content creators and enthusiasts.

Together, we’ve built a top-5 GitHub open-source project by contributions!

Amazing user experiences

It all starts with a focus on enabling amazing user experiences. Free from typical platform constraints, Flutter supports a broad set of design languages — support for Material Design and our Apple-inspired Cupertino widgets comes with the SDK. The ecosystem also provides a broad selection of design libraries like Windows-inspired fluent_ui, macOS-inspired macos_ui, and the Ubuntu-inspired yaru widgets.

Scandinavian Airlines design awards

With Flutter, you have the flexibility and power to realize any design your design team envisions. This is exemplified by Scandinavian Airlines, who after creating their new mobile app with Flutter have filled their trophy case with prestigious design awards such as the Red Dot Design Award, the Webby People’s Voice Award, and the iF Design Gold Award. Charlotte Svensson, EVP & CIO at SAS explains:

“I’m extremely proud over this award, which is not just an industry award, but a global recognition. It’s a testament to what we can do, when we go above-and-beyond in focusing on improving the customer experience, and when we interact and develop together with our customers. SAS has always been at the forefront of innovation in the aviation industry, and this award serves as a validation of its dedication to providing exceptional digital solutions for our customers.”

\"\" — Scandinavian Airlines design awards

Great performance & reliability

Performance and reliability are crucial for a positive user experience and brand perception. Slow or crash-prone apps not only frustrate users in the short term but can also damage your brand reputation in the long run through negative reviews and word-of-mouth.

Flutter has prioritized performance and reliability from the outset. By choosing the Dart programming language, we ensure fast startup times through ahead-of-time compilation to native machine code or web assembly. Dart’s rich, null-safety type system helps catch errors during development, further enhancing reliability. Additionally, Flutter’s custom Impeller rendering engine, designed specifically for multi-platform UI, delivers smooth animations and gives us full control over the rendering stack, top to bottom, from the UI source code to the GPU.

Universal Studios performance and reliability

For example, Universal Destinations and Experiences recently reported that by adopting Flutter, they not only decreased their app size — a significant benefit for users with unreliable internet connections — but also dramatically reduced app crashes to near zero, thus lowering their total cost of ownership.

LG Electronics performance

LG Electronics has traditionally relied on web apps for their webOS-powered smart TVs due to concerns about the high development cost of traditional native apps. However, they found that web apps launch slower and consume more memory than native apps. With Flutter, LG Electronics has a solution that combines fast development speed and excellent performance. As a result, they plan to use Flutter for key applications in webOS TVs globally starting in 2025.

First-class developer experience and thriving ecosystem

Flutter’s success is deeply rooted in its focus on developer experience. We pioneered instant developer workflows with Stateful Hot Reload, and during our growth era added Flutter DevTools to significantly accelerate diagnostics and debugging workflows.

Flutter’s community provides a thriving and open ecosystem of over 50,000 packages published by over 10,000 publishers, combined with robust third-party services & technologies. Also, if you want input on designing or building a new successful Flutter app, we have a large list of Flutter Consultants ready to help you.

MGM and developer productivity

App agency Superformula has built with Flutter since August 2020. They found that Flutter is easy to learn and well documented, enabling them to get new team members up to speed quickly and contribute effectively.

Superformula also used Flutter to revitalize the digital dining experience for MGM Resorts’ 400+ restaurants. The new Flutter-based MGM Rewards app was rebuilt in just 4 months, cutting the total amount of code in half, and improving delivery speed by a factor of 4. One core enabler of productivity for Superformula is the ability to share code across mobile, tablet-based kiosks, and web-based tools.

GEICO and the democratization of mobile development

Earlier this year, American auto insurance company GEICO published a blog post detailing their experiences with Flutter and how it had improved their productivity. They were able to change the structure of their organization so that UX teams now own the entire experience across all channels, reducing the amount of drift between the different implementations of the same functionality. They also describe Flutter’s development experience as “mature, with rich tooling and support for the Software Development Lifecycle (SDLC)”.

\"\" — GEICO user interface elements shared across web, iOS, and Android.

A sneak preview of the future

As we said, some of the most important work the Flutter team will undertake in the next few years is to sustain the quality and depth of support demanded by the enterprises delivering Flutter-based experiences to hundreds of millions of users all over the world.

To meet these evolving needs, we’re focusing on several key areas:

Deeper iOS fidelity: We’re continuing to deliver even greater fidelity to Apple’s design language by expanding our Cupertino widgets. And we’re embracing modern Apple ecosystem standards like Swift Package Manager.
Seamless platform integration: We’re investigating a new approach to interoperability — direct native interop — which we believe will simplify access to platform-specific APIs available in C, Java, Kotlin, ObjectiveC, or Swift.
Developer productivity enhancements: We’re continuing to evolve our developer tools by exploring potential new UI design features that may offer a live widget previewer combined with real-time visual property editing.
Concise and readable code: To boost developer productivity, we’re exploring how to make Flutter code quicker to write and easier to read. This includes potential new language features such as ‘primary constructors’ and ‘enum shorthands’, and looking through the Flutter framework to identify new APIs that may offer a more concise way of writing common code.

As Rivers so accurately puts it, things have certainly “gotten a little slicker, and a bit more professional” and it’s our intention to keep things feeling that way going into the future.

Ready to use #FlutterInProduction?

If you haven’t tried Flutter recently, there’s never been a better time!

Want to learn more from others’ experiences first?

Attend the Observable Flutter panel on December 19th, 2024
Join the Flutter community: Find a local meetup, join the forum, or connect on Slack: https://flutter.dev/community

We’re dedicated to earning your trust with an unwavering focus on quality and performance. We continue to drive our roadmap from the needs of our users. That has evolved too over the last 6 years of growth, from individuals and hobbyists in our experimental era, to the large enterprises leveraging Flutter for business critical functionality today.

As always, we can’t wait to see what you build next. Until next time!

$\"\"$

Celebrating Flutter’s “Production Era” was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/f9418261d8e1","Celebrating Flutter’s “Production Era”",{"_2445":13},{"_8":2670,"_30":2671,"_2456":2664,"_2458":2672,"_2445":13,"_2460":2673,"_36":2674,"_2463":2675},513,"2024-12-17T19:02:26+00:00","

Want AI chat in your Flutter app? This toolkit makes it easy.

Flutter AI developers, rejoice! Adding an AI-powered chat experience to your app just got a whole lot easier. Introducing Flutter AI Toolkit, a collection of ready-to-use AI chat widgets designed to seamlessly integrate into your Flutter projects. No more building complex chat interfaces from scratch — Flutter AI Toolkit provides everything you need to quickly and easily add a sophisticated AI chat window to your app. Ready to boost customer engagement and satisfaction across multiple platforms? You’ve got this!

\"\" — Try Flutter AI Toolkit in Project IDX!

Multi-turn chat

With multi-turn chat, you can maintain context across multiple interactions in the same session.

Imagine you’re talking to a friend. They ask if you have a pet and you tell them that you have a pet rock named Rocky. A little while later after chatting with you about other things, your friend asks “How long have you had Rocky?” The friend remembers your pet rock from an earlier conversation, even though you didn’t mention it again.

That’s essentially what multi-turn chat does! It helps the LLM (generative AI Large Language Model) remember what is being talked about.

\"\" — Multi-turn chat in Flutter AI Toolkit

Rich text display

Rich-text format is supported in the responses produced by the LLM. Instead of producing just plain-text words, the LLM can format the text to be more interesting to read. For example, the response could include bold text, images, bullets, and more.

\"\" — Rich-format support in Flutter AI Toolkit

Voice input

Voice input can be used to convert messages to text. This hands-free option is perfect for those who prefer not to type or who want a faster way to compose messages.

\"\" — Voice input support in Flutter AI Toolkit

Multimedia attachments

Pictures, videos, audio, PDFs, and other files can be added to conversations separately or all together.

\"\" — Multimedia attachment support in Flutter AI Toolkit

Custom response widgets

Design specialized UI components for responses. For example, if someone requests a recipe, you can show an interactive recipe card with an option to save the recipe directly to a database.

\"\" — Custom AI response widget support in Flutter AI Toolkit

Custom styling

Configure the chat appearance to match your app. Change the colors of the chat bubbles, the background, the UI fonts, and even add UI pictures or animations to reflect your brand identity.

\"\" — Custom styling support in Flutter AI Toolkit

Cross-platform support

Flutter supports many platforms and so does Flutter AI Toolkit. Want to deploy an AI chat app made with Flutter on iOS, Android, web, and macOS? No problem!

Pluggable LLMs

Flutter AI Toolkit makes it easy to add AI to your app, whether you want to use Google’s Gemini or Vertex AI, or even another LLM. GeminiProvider and VertexProvider are available for out-of-the-box integration, using the Google AI Dart SDK and Vertex AI in Firebase SDK respectively. We highly recommend that you use the Vertex AI in Firebase SDK for production use cases beyond prototyping. In addition, you can leverage Flutter AI Toolkit’s LLM provider interface to plug in the LLM of your choice with your own custom code.

Stand-alone chat app with multiple conversations

Build a full-fledged chat app that can store and manage multiple conversations. To help you get started, Flutter AI Toolkit comes with a sample project that leverages a Cloud Firestore database and Vertex AI in Firebase.

Try Flutter AI Toolkit now

To try Flutter AI Toolkit yourself, check out Flutter AI Toolkit on pub.dev and the following resources:

$\"\"$

Announcing Flutter AI Toolkit was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/e36b16a840d2","Announcing Flutter AI Toolkit",{"_2445":13},{"_8":2677,"_30":2678,"_2456":2664,"_2458":2679,"_2445":13,"_2460":2680,"_36":2681,"_2463":2682},642,"2024-12-17T19:02:25+00:00","

Coauthors: Zoey Fan, Harold Benson, Alak Jhunjhunwala

Monetizing your Flutter app just got easier and more rewarding. Today, we are thrilled to announce a new suite of tools and feature updates that provide developers with a range of options to monetize your apps and grow your business.

Video ads now available for Flutter developers

\"\" — An animated gif showing a sample video ads

Let’s start by turning your video content into a revenue-generating powerhouse!

We’d like to announce the launch of the Interactive Media Ads (IMA) plugin for Flutter. You can now seamlessly integrate high-quality video ads into your Flutter apps on iOS and Android. This means that you can now easily monetize your video content with video ads before (pre-roll), during (mid-roll), or after (post-roll) your video content playback. Just like the Google Mobile Ads plugin simplifies the display of mobile ads in your Flutter apps, the IMA plugin makes it easy to incorporate video ads. We’ve taken care of the heavy lifting, so you can focus on what matters most: creating amazing app experiences.

Effortless integration, maximum impact

Client-side ad insertion: Ads play in a separate video player, ensuring a smooth viewing experience for your users while giving you more control.
Seamless ad handling: The plugin requests video ads and handles the playback. It also ensures UI elements such as skip buttons are rendered and ad measurement signals are fired.
Industry standard compliance: IMA leverages the industry-standard Video Ad Serving Template (VAST) specification, ensuring broad compatibility with ad servers.
Access to premium ad demand: IMA ensures you can monetize your video content with high quality and premium video ad demand from Google.

Get started today!
Are you ready to supercharge your Flutter app with video ads? Head over to pub.dev/packages/interactive_media_ads to explore the IMA plugin and access detailed documentation. You’ll find everything you need to get started, including code samples and step-by-step guides. We’re excited to see how you use the IMA plugin to monetize your Flutter video content and create even more engaging app experiences!

Beta: Monetize your Flutter web games with AdSense ads

\"\" — An animated gif showing a sample AdSense Ads in a game

Many Flutter developers want a way to monetize their Flutter web projects just like their mobile counterparts. We have been busy working behind the scenes, and have some exciting progress to share!

Today, we’re thrilled to announce the beta program for AdSense for the H5 games plugin! With this plugin, you can easily add AdSense H5 Game Ads to your web-based (H5) games built in Flutter, opening up new opportunities to generate revenue.

What the beta program offers:

Be among the first to integrate AdSense: Get early access to the Flutter AdSense plugin and start experimenting with different ad formats.
Shape the future of the plugin: Provide valuable feedback and help us tailor the plugin to the specific needs of Flutter web developers.

This program is a major step towards a complete ad monetization solution for Flutter web. Currently, this Beta program focuses on enabling AdSense for Flutter web games. We’re collaborating with the AdSense team to develop solutions for Flutter web apps in the future.

If you are a Flutter web game developer, and interested in participating, please fill out the H5 AdSense application form. Once you are approved into the beta program, use pub.dev/packages/google_adsense to get started!

Higher conversion and better user experience with Deep Linking

Adding ads is one of the ways to become a successful business. Sometimes your business requires selling goods and services in your app. You have probably already spent an enormous amount of time and resources in creating SMS/email marketing and Ads campaigns, and hoping these campaigns will drive effective conversion. But what if you could take your campaigns to the next level by directing customers from a marketing campaign straight to your app and the specific item they’re interested in?

With deep linking in Flutter, you can do just that. When someone clicks a link in your campaign, they’ll be taken directly to your app and the product or service you’re promoting. This seamless transition increases the chances of conversion by 2.3x compared to linking to your website.

Here’s why deep linking is a game-changer for advertisers:

Drive higher conversions: By bringing customers directly to your app, you eliminate distractions and make it easier for them to complete their purchase.
Personalize the experience: Deep linking allows you to create personalized experiences for each customer. When they click on a link, they’ll be taken to the exact product or service they’re interested in.
Track campaign performance: With deep linking, you can track the effectiveness of your campaigns and see how many people are clicking through to your app. This data can help you optimize your campaigns for better results.

While deeplinking offers all these great benefits, it can be quite cumbersome to set up. Therefore, we’re also making deep linking more robust and reliable than ever before. With full web and app check validation support across iOS and Android in Flutter DevTools, you can ensure your deep links are configured correctly and securely. Your users will enjoy seamless transitions between web and app content, increasing engagement and satisfaction! To start, go to Flutter DevTools, and open the Deeplinking validation tab.

\"\" — An animated gif showing Deeplinking Validation in Flutter DevTools

We’re committed to providing you, the Flutter developer, with the tools and resources you need to succeed. These new features are a testament to that commitment. So go ahead, take your Flutter app to new heights, and unlock its full potential!

Explore More:

Dive into the world of Flutter monetization: flutter.dev/monetization
Master the art of deep linking: Flutter documentation
Stay updated with the latest Flutter news:Flutter blog

$\"\"$

Video & web ad support in Flutter was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/f50e5a3480a8","Video & web ad support in Flutter",{"_2445":13},{"_8":2684,"_30":2685,"_2456":2664,"_2458":2686,"_2445":13,"_2460":2687,"_36":2688,"_2463":2689},512,"2024-12-11T20:19:53+00:00","

Elevating App Development with Impeller, Cupertino Updates, and More

Introduction

Let’s dive into Flutter 3.27! This release is brimming with enhancements and features focused on refining your development experience and boosting your app’s performance.

We’ve got updates across the framework, engine, and ecosystem, including progress with Impeller and improvements to Cupertino widgets. Plus, we’re introducing exciting new features in DevTools, making it easier than ever to manage your Flutter projects. With over 1,400 commits from 187 contributors (including 49 first time contributors!), Flutter 3.27 is a testament to the incredible energy and collaboration of the Flutter community. Let’s explore what’s new!

Framework

Cupertino updates

This release includes high fidelity updates to CupertinoCheckbox and CupertinoRadio, featuring updates to sizes, colors, stroke widths, and behaviors when pressed. There have also been large customizability updates to CupertinoRadio, CupertinoCheckbox, and CupertinoSwitch, adding properties like mouse cursors, semantic labels, thumb images, and fill colors. Some properties, like the inactive color of CupertinoCheckbox, were deprecated, while others, like the track color of CupertinoSwitch, were renamed. These changes bring these widgets up to feature parity with their Material counterparts.

CupertinoSlidingSegmentedControl sees some fidelity updates to its thumb radius, separator height, padding, shadows, and thumb scale alignment. It also now supports disabling individual segments, and proportional layout based on segment content.

Thanks to an amazing contribution from community member @veloce, both CupertinoNavigationBar’s and CupertinoSliverNavigationBar’s backgrounds are now transparent until content is scrolled under them.

This allows the sliver navigation bar to have the same color as its background in its expanded state, but a different customizable color in its collapsed state (and the ability to lerp between both colors on scroll).

Thanks to an amazing contribution from community member @kerberjg, you can now apply the iOS 15+ button styles using the new CupertinoButtonSize enum with the new sizeStyle property in CupertinoButton. Use the new CupertinoButton.tinted constructor to make buttons with a translucent background.

CupertinoButton also has a new onLongPress handler, and allows performing actions through keyboard shortcuts.

CupertinoPicker and CupertinoDatePicker will now scroll to tapped items.

CupertinoAlertDialog now supports the tap-slide gesture.

CupertinoActionSheet sees some high fidelity updates, including adjusting padding and font sizes across all system text size settings and supporting haptic feedback when sliding over buttons.

Other changes include CupertinoContextMenu now supporting scrolling if its actions overflow the screen, CupertinoDatePicker no longer clipping long contents in its columns, and CupertinoMagnifier supporting zoom effects by providing a magnification scale.

Normalizing Material theming

In this release, CardTheme, DialogTheme and TabBarTheme have been refactored to make them conform to Flutter’s conventions for component themes. CardThemeData, DialogThemeData and TabBarThemeData were added to define overrides for the defaults of the component visual properties. Future releases will continue to normalize component themes like these for a more consistent theming experience in the material library.

More Features for CarouselView

This release introduces CarouselView.weighted, enabling more dynamic layouts within carousels. By adjusting the flexWeights parameter in the constructor, you can achieve a variety of item layouts. For instance, [3, 2, 1] creates a multi-browse layout, [7, 1] produces a hero layout, and [1, 7, 1] yields a centered-hero layout. These values represent the relative weight each item occupies within the carousel view and can be customized to suit users’ specific needs.

Mixing Route Transitions

ModalRoutes are now more flexible when the previous and new routes have different page transitions. When a new route enters the screen, sometimes they need the previous existing route to play a certain transition to sync up with the entrance transition of the new route. Now ModalRoutes can provide exit transition builders to each other so the enter and exit transitions always sync up. This allows pages to have multiple route transition options on one page using Flutter’s Navigator and Router.

Text Selection Improvements

Flutter’s SelectionArea now supports Shift + Click gesture to move the extent of the selection to the clicked position on Linux, macOS, and Windows.

You can also now clear the selection under a SelectionArea and SelectableRegion through the method clearSelection on SelectableRegionState. SelectableRegionState is also now accessible through SelectionArea by providing it a GlobalKey and accessing its SelectionAreaState.selectableRegion.

We also resolved some issues with RenderParagraph, so selecting text under a SelectionArea or SelectableRegion still works as expected after resizing the window, and when clicking or tapping outside of the actual text.

Row and Column spacing

This release also features a new convenience to using Rows and Columns, spacing! This double parameter will apply a fixed amount of pixels to offset children of Rows and Columns from each other, reducing the previous amount of code required to do so.

Engine

Impeller on Android

We are pleased to share that Impeller is now the default rendering engine on modern Android devices. While Impeller on these devices has been in preview since Flutter’s 3.16 stable release in November 2023, since then we have made large improvements to both performance and fidelity based on user feedback.

On older Android devices and devices without Vulkan support, the Skia rendering engine will still be used as before. While we believe that Impeller’s performance and fidelity are both high quality, users are able to opt-out and return to the legacy Skia renderer by passing--no-enable-impeller to the flutter command line tool, or by placing the following in your AndroidManifest.xml file(s):

Going forward we will continue to make improvements to Impeller’s performance and fidelity on Android. Additionally, we intend to make Impeller’s OpenGL backend production ready to remove the Skia fallback.

As during the preview period, we request that Flutter developers upgrade to the latest stable version, and file issues about any shortcomings noticed when Impeller is enabled. Feedback continues to be invaluable to ensuring that Impeller is successful on Android. The Android hardware ecosystem is much more diverse than the iOS ecosystem. For that reason, the most helpful feedback about Impeller should include detailed information about the specific device and Android version where issues occurred.

Improvements on iOS devices

In previous versions of Flutter, users may have experienced an issue in which applications on iOS devices waited several milliseconds per frame on compositor backpressure. This backpressure would be observed as delays in the beginning of the raster workload. In many circumstances, this delay caused missed frames and jank. This effect was especially noticeable on high frame-rate devices with a smaller frame time budget.

In this release, open source contributor @knopp added a new implementation of a Metal rendering surface that allows raster workloads to begin more consistently after the UI workload completes. This means that users will observe that overall frame times are more stable as there is less waiting on the iOS system compositor. In particular, Flutter will now much more consistently hit 120Hz on high frame-rate devices. In our benchmarks we have observed this improvement in a large reduction in average frame rasterization time across many scenarios.

\"\" — *This chart shows an across-the-board decrease in average frame rasterization time in milliseconds on a large number of different benchmarks running on iPhone 11 devices.*

Framework Wide Gamut Colors

Flutter now supports defining UI’s with colors in the DisplayP3 color space to take full advantage of displays on iOS devices. It also has wider bit depth to support more colors in sRGB and DisplayP3 color spaces. This change has led to the deprecation of some Color methods; more information can be found in the breaking change notice.

Web

Web Improvements

This release brings a variety of improvements to Flutter web, focusing on performance, efficiency, and accessibility:

Image decoding in Safari and Firefox is now done using an <img> element instead of WebAssembly codecs for all static images. This removes jank related to image decoding and reduces WASM memory usage.
Platform views were optimized to reduce the number of canvas overlays, improving rendering efficiency.
All plugins and packages developed by the Flutter team are now compatible with WebAssembly.
Multiple accessibility fixes were implemented for headings, dialogs, passwords, iOS keyboard, links, and scrollables.
A number of rendering bugs were fixed in the CanvasKit and Skwasm renderers, including image filters, clipping, and memory usage of Paint objects.
Improved drag scrolling in multi-view mode.

iOS

Swift Package Manager

Flutter is migrating to Swift Package Manager. This brings several benefits:

1. Access to the Swift package ecosystem. Flutter plugins will be able to leverage the growing ecosystem of Swift packages!
2. Simpler Flutter installation. Swift Package Manager is bundled with Xcode. In the future, you won’t need to install Ruby and CocoaPods to use Flutter for Apple’s platforms.

Previously, Swift Package Manager support was only available on Flutter’s “main” channel. We’re pleased to announce that the Swift Package Manager feature is now available on the “beta” and “stable” channels too! For now, the Swift Package Manager feature is off by default while we iron out the kinks.

Plugin authors are encouraged to add support for Swift Package Manager to your plugins. Many popular plugins — including Firebase, plus plugins, and more — have already migrated to Swift Package Manager!

Pub.dev now checks plugins for Swift Package Manager compatibility. In the future, packages that are incompatible will not receive full package scores.

If you have feedback on Flutter’s support for Swift Package Manager, please file an issue.

Android

Edge to Edge

By default on devices running Android 15+, your app will use edge-to-edge mode and run in full screen! For details on the change and how you can opt out of this behavior, see the guide.

Support for Freeform

Android Freeform allows users to resize app windows and has been available as a developer option. Flutter’s SafeArea and MediaQuery have been updated to handle hardware cutouts when a freeform window moves into a hardware cutout.

Kotlin build script support and declarative plugin migration

Developers can now use build.gradle.kts files.
Flutter tooling now supports Kotlin build files. If you encounter a place where we don’t support Kotlin, please file a bug. Groovy remains a supported Gradle language.

Flutter 3.27 is the last release that will support Gradle’s legacy apply script method. See migration docs.

Note: Most apps will need to manually migrate. Newly created apps will use kotlin build files.

Moving to declarative inclusion of the Flutter Gradle Plugin helps Flutter migrate to Kotlin builds files with better type safety and easier to maintain unit tests for build code. It is also a part of a broader effort to bring more stability across Android tooling versions.

Ecosystem

Flutter and Dart Package Ecosystem Summit USA 2024

As part of Fluttercon USA 2024 in September, we held a Flutter and Dart Package Ecosystem Summit. This was our second in-person summit, that followed on from the summit at Fluttercon Europe in July 2024, and the first virtual summit we held in August 2023. See a summary of takeaways from the discussion sessions here.

The summit brought together package authors and maintainers for unconference-style sessions on the following topics:

Session 1 — Adding support for Swift Package Manager
Session 2 — Past, Present and Future of Native Interop
Session 3 — Sustainable package maintenance models

We’re looking forward to holding more of these summits going forward, in partnership with the community.

Package download counts on pub.dev

We launched download count metrics on pub.dev!

Providing more precise popularity metrics on pub.dev has been the most requested feature in the site’s issue tracker for a long time.

Now, when you view a package page you will see a 30-day download count replacing the former “popularity score”.

Additionally, we added an interactive sparkline chart showing weekly download activity over time. This chart helps developers and package authors uncover trends in package usage. For example, it could be an indicator that a new release has caused a spike in usage, or that a package is gaining or losing popularity.

A download is registered each time the package is downloaded from pub.dev. For example, when you run flutter pub get, and the package isn’t already in your pub cache.

The download count numbers presented are raw download counts, and reflect usage from CI systems, package analysis, human pub client users, and more.

Pub workspaces

We are launching Pub Workspaces with Dart 3.6, to support the development of multiple related packages in one monorepo

By defining a root pubspec that references the other packages in the repository, running pub get anywhere in the repository will result in a shared resolution for all the packages. This ensures that all packages are developed with a consistent set of dependencies.

The shared resolution is also picked up by the analyzer, which now only has to keep track of a single analysis context for the entire workspace, potentially resulting in a significant reduction in memory use when opening the whole repository in your IDE.

Automated publishing of Flutter packages from GitHub

We have extended the setup-dart publish Github Actions workflow to also allow automated publishing of Flutter packages to pub.dev, making it easier to contribute to the Pub ecosystem in a verifiable manner.

Launch of Interactive Media Ads plugin

We launched an Interactive Media Ads (IMA) Flutter plugin that makes it easy to integrate multimedia ads into iOS and Android apps built with Flutter. The IMA plugin can request ads from any VAST-compliant ad server and manage ad playback in your apps. Ads play in a separate video player positioned on top of the app’s content video player. The current supported features are:

Client-side APIs for linear instream video ad requests
VAST & VMAP
Single & Podded Requests
Skippable Ads

In-App Purchase iOS and macOS plugin updates

We’ve added StoreKit 2 support to the in_app_purchase_storekit package to migrate off StoreKit 1 APIs, which were deprecated in iOS 18. This allows us to add new StoreKit 2 features like better subscription management in the future. Stay tuned for an upcoming migration guide to help you transition to the newer StoreKit 2 functionality. This is a non-breaking change, so you can migrate whenever you wish.

DevTools and IDEs

Flutter DevTools updates

This release includes new features, overall improvements to robustness and polish, as well as some exciting new experimental features that you can enable from DevTools. See the Previews and Experimental features section below for more information on these.

Firstly, we added support for validating iOS deep link settings in the Flutter Deep Links tool. You can now validate deep links for Android and iOS.

\"\" — *iOS deep link validation in the DevTools Deep Links tool.*

Next, we’ve made some improvements to the workflow of working with “offline” data. Sometimes it is necessary to export the data you are viewing in DevTools for future use or for loading into another tool. This release adds support for exporting Network data as a .har file, and for loading memory snapshots into DevTools for viewing when DevTools is not connected to a running app.

Additionally, if you’ve ever been in the middle of debugging a memory issue with DevTools and lost your memory tool data because your app crashed (perhaps due to the very OOM issue you are trying to debug), we feel your frustration! We have fixed this UX pain point by allowing you to continue viewing the most recent memory tool data in DevTools, even after an app disconnects.

These are just a few highlights from this release. To learn more about all the updates included in Flutter 3.27, check out the release notes for DevTools 2.38.0, 2.39.0, and 2.40.1.

Previews and experimental features to try

Flutter DevTools — New Flutter Inspector

The Flutter Inspector has undergone some major changes to improve usability and enhance your UI debugging journey. Enable the new Inspector by toggling the “New Inspector” setting.

\"\" — *New Flutter Inspector in DevTools.*

A few of the changes include:

A condensed Widget tree that makes it easier to view deeply nested Flutter widget trees. This is especially helpful when using the Flutter Inspector from inside your IDE, where horizontal screen space is limited.
An option to toggle whether implementation widgets should be included in the widget tree. Implementation widgets are widgets that you didn’t include in your app code, but rather that were added to the widget tree by the Flutter framework or other packages.
A details view for the selected widget that shows an inline layout viewer, widget and render object properties, and a flex layout explorer for Flex widgets and their children.

More improvements are coming soon for the new Inspector, but these changes are ready for you to try out! Please file any issues you encounter so that we can fix them before enabling the new Inspector by default.

Flutter DevTools — Try with WebAssembly

Enable the WebAssembly feature in DevTools settings to load the WASM-compiled DevTools web app.

This should yield better performance than the default JS-compiled version of DevTools. This feature is experimental, so please file any issues you encounter with the WASM build.

\"\" — *DevTools setting to use the WebAssembly build instead of the Javascript build.*

Breaking Changes and Deprecations

Material Design 3 tokens

The latest Material Design 3 tokens(v6.1) have been applied to the Flutter Material library. The Material Design tokens updated the mapping of 4 color roles in Light mode only to be more visually appealing while retaining accessible contrast. We did not identify any breakages in our testing of this change, which applied to these color properties:

On-primary-container (Primary10 to Primary30)
On-secondary-container (Secondary10 to Secondary30)
On-tertiary-container (Tertiary10 to Tertiary30)
On-error-container (Error10 to Error30)

This affects widgets that use these roles as their default value.

The border color of Chips (Chip, ActionChip, ChoiceChip, FilterChip, and InputChip) was updated from ColorScheme.outline to ColorScheme.outlineVariant. This improves the visual hierarchy between chips and buttons.

Objective-C iOS projects

Since Flutter 1.9.1 released in 2019, new iOS projects use Swift by default. Creating a new Objective-C iOS project is now deprecated, and the flutter create --ios-language objc flag will be removed in a future version of Flutter. You will still be able to open your Xcode project and add Objective-C files, including for plugins. Java continues to be supported for Android apps with the flutter create --android-language java flag.

Deep link default flag

The default value for Flutter’s deep linking flag has changed from false to true, meaning deep linking is now opt-in by default. If you’re using Flutter’s default deep linking setup, there’s no need to manually set the flag to true anymore.

However, if you’re using third-party plugins for deep links, such as:

This update will introduce a breaking change. In this case, you’ll need to manually reset the Flutter deep linking flag to false.

For more details, refer to the design document: flutter.dev/go/deep-link-flag-migration.

Deprecating support for older SDKs in IDE

To ensure we can continue to deliver a high-quality developer experience, we’re making a change to our IDE plugin support. As the Dart and Flutter plugins for VS Code and IntelliJ have evolved, supporting older Dart SDK versions has become increasingly challenging.

Starting with the release of Dart 3.6, we will deprecate support for Dart SDK versions older than 3.0 (released in May 2023). This means that while the tools may still function with older SDKs, we will no longer provide official support or fixes for issues specific to these versions.

With the release of Dart 3.7 (estimated in Q1 2025), we will remove support for these older SDK versions entirely. Future releases of the plugins may not be compatible with these versions.

What does this mean for you?

If you’re using an older Dart SDK, we encourage you to upgrade to version 3.0 or later to continue receiving support and updates.
This change affects less than 1% of our users, and it will allow us to focus on delivering the best possible experience for the vast majority of developers.

Closing

For all breaking changes in this release, see the full list of migration guidance on the breaking changes page.

As always, many thanks to the community for contributing tests — these help us identify breaking changes. To learn more, check out Flutter’s breaking change policy.

Conclusion

A huge thank you to the entire Flutter community for making this release possible! Your contributions, feedback, and enthusiasm are what drive Flutter forward. We’re incredibly excited about the future of Flutter and can’t wait to see the amazing apps you build with Flutter 3.27.

For a complete rundown of all the changes, check out the detailed release notes and changelog. Ready to experience the latest and greatest? Simply run flutter upgrade and start building!

$\"\"$

What’s new in Flutter 3.27 was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/28341129570c","What’s new in Flutter 3.27",{"_2445":13},{"_8":2691,"_30":2692,"_2456":2664,"_2458":2693,"_2445":13,"_2460":2694,"_36":2695,"_2463":2696},429,"2024-12-03T19:01:01+00:00","

Tune in for #FlutterInProduction — coming soon to a screen near you!

Mark your calendars and be sure to tune into #FlutterInProduction on December 17, 2024 at 11:00am PT / 2:00pm ET / 20:00 CET.

This virtual event, hosted on the Flutter YouTube channel, is a little different than our previous events. We’re not just diving into the latest releases (though we’ll definitely be doing that!): #FlutterInProduction is about celebrating the incredible journey we’ve taken together as a community to make Flutter the powerful production-ready framework it is today.

What to expect

#FlutterInProduction: Whether you’re a seasoned pro or just starting out, you’ll gain new insights and inspiration from Flutter user stories, learn more about the latest features from Flutter technical leads, and see what the future holds for Flutter app development in this multi-segment virtual event.
#AskFlutter Live Q&A: Get your questions answered by Flutter team leads. Stay tuned for our call for questions on social media!
Observable Flutter: Have any questions about what it’s like to build with Flutter in an enterprise development environment? Get those questions answered by tech leads at companies using Flutter in production.

Stay tuned

We’ve got a couple surprises and announcements to make along the way, so be sure to take the following steps to stay in-the-know.

Set a reminder for the event time on your calendar, or on YouTube.
Follow us on Twitter, LinkedIn, or here on Medium!

We can’t wait to share #FlutterinProduction with you!

$\"\"$

Tune in for #FlutterInProduction — coming soon to a screen near you! was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/6bb9820d1506","Tune in for #FlutterInProduction — coming soon to a screen near you!",{"_2445":13},{"_8":2698,"_30":2699,"_2456":2664,"_2458":2700,"_2445":13,"_2460":2701,"_36":2702,"_2463":2703},428,"2024-11-21T17:32:03+00:00","

Developers around the world are using Google’s Gemini models to tackle real-world challenges, and one of the most exciting applications we’ve seen is in the field of sales. Meet Prospera, winner of both best Flutter app and most Useful app in our recent Gemini API Developer Competition! Created by Leon Kukuk and Max Hasenohr from Germany, Prospera is an AI-powered sales coach that provides real-time guidance and feedback during and after calls. This innovative Flutter app showcases the power of Gemini to transform how sales professionals learn and improve their skills.

Gemini API at the core: real-time analysis and multimodal magic

Prospera leverages Gemini’s multimodal capabilities in a truly unique way. By feeding snippets of audio conversations directly into the Python SDK for the Gemini API, the app provides real-time feedback from the perspective of a seasoned sales coach. Imagine having an AI co-pilot whispering valuable insights and suggestions during your calls — that’s the power of Prospera.

But how did they achieve this seamless integration? Leon, the developer of Prospera, cleverly used Dart FFI (Foreign Function Interface) and the ffigen package to create Dart bindings for the PJSIP C library, enabling seamless phone call integration in Flutter and allowing these calls to be processed through the Gemini API. This allowed them to process audio data in real-time and deliver instant feedback to the sales representative.

“We were impressed by Gemini’s nuanced understanding of speech, thanks to its multimodal audio capabilities as well as its ease of implementation. Flutter enabled us to develop cross-platform apps at an incredible speed, while offering powerful opportunities to run native code through FFI and platform channels.” — Leon

A Flutter app for all platforms

Built with Flutter, Prospera runs seamlessly across various desktop platforms from a single codebase. This not only streamlines development but also opens doors for future expansion to mobile devices, making the app accessible to an even wider audience. The developer also paid close attention to user experience, crafting a beautifully designed app with Material Design widgets and ensuring full accessibility.

Beyond sales: a glimpse into the future of communication

By combining the power of Gemini with the versatility of Flutter, Leon and Max have created an app with the potential to revolutionize how we learn, interact, and excel in our professional lives. Prospera is more than just a sales coach; it’s a glimpse into the future of how AI can enhance human communication and professional development. While Prospera focuses on sales coaching, its underlying technology and approach have broader applications. The ability to analyze real-time conversations and provide constructive feedback can be valuable in various communication-driven professions, such as customer service and education.

Want to learn more about Dart FFI and how it can empower your Flutter applications? Check out the ffigen package on pub.dev.

$\"\"$

Prospera: using Flutter to bring AI to the frontline of sales was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/71377810fd26","Prospera: using Flutter to bring AI to the frontline of sales",{"_2445":13},{"_8":2705,"_30":2706,"_2456":2664,"_2458":2707,"_2445":13,"_2460":2708,"_36":2709,"_2463":2710},425,"2024-08-06T18:02:39+00:00","

Build custom renderers and render 3D scenes in Flutter.

The Flutter 3.24 release introduces a new low-level graphics API called Flutter GPU. There is also a 3D rendering library powered by Flutter GPU called Flutter Scene (package: flutter_scene). Both Flutter GPU and Flutter Scene are currently in preview, only available on Flutter’s main channel (due to reliance on experimental features), require Impeller to be enabled, and might occasionally introduce breaking changes.

This article contains two “getting started” guides for these packages:

🔺 Advanced: Getting started with Flutter GPU
If you’re an experienced graphics programmer or you’re interested in low level graphics and want to build renderers from scratch in Flutter, then this guide will get you set up to start tinkering with Flutter GPU. You’ll draw your first triangle from scratch… in Flutter!
💚 Intermediate: 3D rendering with Flutter Scene
If you’re a Flutter developer that wants to add 3D functionality to your apps, or you want to create 3D games using Dart and Flutter, then this is a guide for you! You’ll set up a project that imports and renders 3D assets in Flutter.

Getting started with Flutter GPU

⚠️ Warning! ⚠️ Flutter GPU is ultimately a low-level API. It’s overwhelmingly likely that the vast majority of Flutter devs who will benefit from Flutter GPU’s existence will do so by consuming higher level rendering libraries published on pub.dev, such as the Flutter Scene rendering package. If you’re not interested in the Flutter GPU API itself and you’re just interested in 3D rendering, skip ahead to 3D rendering with Flutter Scene.

\"\" — Ooh shiny. This is a ray-marched signed distance field. You could render this using Flutter GPU, but it’s perfectly possible to do so with a custom fragment shader as well.

Getting started with Flutter GPU

Flutter GPU is Flutter’s built-in low-level graphics API. It allows you to build and integrate custom renderers in Flutter by writing Dart code and GLSL shaders. No native platform code required.

Currently, Flutter GPU is in early preview and offers a basic rasterization API, but more functionality will continue to be added and refined, as the API approaches stable.

Flutter GPU also requires Impeller to be enabled. This means it can only be used when targeting platforms that are supported by Impeller. At the time of writing, Impeller supports:

iOS (on by default)
macOS (opt-in preview)
Android (opt-in preview)

Our aim with Flutter GPU is to eventually support all of Flutter’s platform targets. The ultimate goal is to foster an ecosystem of cross-platform rendering solutions in Flutter that are easy to maintain for package authors and easy to install for users.

3D rendering is just one possible use case. Flutter GPU can also be used to build specialized 2D renderers, or to do something more unorthodox, like render 3D slices of a 4D space, or project non-euclidean spaces.

One example of a great use case for a custom 2D renderer powered by Flutter GPU would be 2D character animation formats that rely on skeletal mesh deformation. Spine 2D is a good example of this. Such skeletal mesh solutions usually have animation clips that manipulate translation, rotation, and scale properties of bones in a hierarchy, and each vertex has a few associated “bone weights” that determine what bones should influence the vertex and by how much.’

With a Canvas solution like drawVertices, bone weight transforms would need to be applied for each vertex on the CPU. With Flutter GPU, the bone transforms could be fed to a vertex shader in the form of a uniform array or even a texture sampler, allowing the final position for each vertex to be calculated in parallel on the GPU based on the state of the skeleton and the per-vertex bone weights.

With that out of the way, let’s get started with Flutter GPU by way of a gentle introduction: Drawing your first triangle!

Add Flutter GPU to your project

First, note that Flutter GPU is currently in an early preview state and might be prone to API breakages. Quite a lot is already possible with the current API, but experienced graphics engineers might notice some missing common functionality. Much is planned for Flutter GPU over the coming months.

For these reasons, it’s strongly recommended that, for now, you operate against the tip of the main channel when developing packages against Flutter GPU. If you happen to run into any unexpected behavior, bugs, or have feature requests, please file issues using the standard Flutter issue templates on GitHub. All tracked issues related to Flutter GPU are given the flutter-gpu label.

So before experimenting with Flutter GPU, switch Flutter over to the main channel by running the following commands.

flutter channel main
flutter upgrade

Now create a fresh Flutter project.

flutter create my_cool_renderer
cd my_cool_renderer

Next, add the flutter_gpu SDK package to your pubspec.

flutter pub add flutter_gpu --sdk=flutter

Build and import shader bundles.

In order to render anything with Flutter GPU, you’ll need to author some GLSL shaders. Flutter GPU’s shaders have different semantics than those consumed by Flutter’s fragment shader feature, particularly when it comes to uniform bindings. You’ll also define a vertex shader to go alongside the fragment shader.

Start with defining the simplest possible shaders. You can place shaders anywhere in your project, but for this example, create a shaders directory and populate it with two shaders: simple.vert and simple.frag .

// Copy into: shaders/simple.vert

in vec2 position;

void main() {
  gl_Position = vec4(position, 0.0, 1.0);
}

When drawing the triangle, you’ll have a list of data that defines each vertex. In this case, it merely lists 2D positions. For each of these vertices, a simple vertex shader assigns these 2D positions to the clip space output intrinsic gl_Position.

// Copy into: shaders/simple.frag

out vec4 frag_color;

void main() {
  frag_color = vec4(0, 1, 0, 1);
}

The fragment shader is even simpler; it outputs an RGBA color with a range of (0, 0, 0, 0) to (1, 1, 1, 1). So everything will be shaded as green.

Okay, so now that you have your shaders, compile them using Flutter's ahead of time (AOT) shader compiler . To set up automated builds for shader bundles, we recommend using the flutter_gpu_shaders package.

Use pub to add flutter_gpu_shaders as a regular dependency in your project.

flutter pub add flutter_gpu_shaders

Flutter GPU shaders are bundled into .shaderbundle files, which can be added to your project's asset bundle as regular assets. Shader bundles contain the compiled shader sources for the platform target(s).

Next, create a shader bundle manifest file that describes the contents of the shader bundle. Add the following to my_renderer.shaderbundle.json in the root directory of your project.

{
    "SimpleVertex": {
        "type": "vertex",
        "file": "shaders/simple.vert"
    },
    "SimpleFragment": {
        "type": "fragment",
        "file": "shaders/simple.frag"
    }
}

Each entry in the shader bundle can have an arbitrary name. In this case, the names are "SimpleVertex" and "SimpleFragment". These names are used to look up the shaders in your app.

Next, use the flutter_gpu_shaders package to build the shaderbundle. You can add a hook that automatically triggers a build by enabling the experimental "native assets" feature. Use the following commands to enable native assets and install the native_assets_cli package.

flutter config --enable-native-assets
flutter pub add native_assets_cli

With the native assets feature enabled, add a build.dart script under the hook directory that will trigger building the shader bundle automatically.

// Copy into: hook/build.dart

import 'package:native_assets_cli/native_assets_cli.dart';
import 'package:flutter_gpu_shaders/build.dart';

void main(List<String> args) async {
  await build(args, (config, output) async {
    await buildShaderBundleJson(
        buildConfig: config,
        buildOutput: output,
        manifestFileName: 'my_renderer.shaderbundle.json');
  });
}

After this change, when the Flutter tool is building the project, buildShaderBundleJson builds the shader bundle and outputs the result to build/shaderbundles/my_renderer.shaderbundle under the package root.

The shader bundle format itself is tied to the specific version of Flutter you're using and might change over time. If you're authoring a package that builds shader bundles, do not check the generated .shaderbundle files into your source tree. Instead, use a build hook to automate the build process (as previously explained).

This way, developers that use your library will always build fresh shader bundles with the correct format!

Now that you're automatically building your shader bundle, import it like a regular asset. Add an asset entry to your project's pubspec.yaml:

flutter:
  assets:
    - build/shaderbundles/

In the future, the native assets feature will allow build hooks to append data assets to the bundle. Once this happens, it will no longer be necessary to add an asset import rule alongside the build hook.

Next, add some code to load up the shaders at runtime. Create lib/shaders.dart and add the following code.

// Copy into: lib/shaders.dart

import 'package:flutter_gpu/gpu.dart' as gpu;

const String _kShaderBundlePath =
    'build/shaderbundles/my_renderer.shaderbundle';
// NOTE: If you're building a library, the path must be prefixed
//       with a package name. For example:
//      'packages/my_cool_renderer/build/shaderbundles/my_renderer.shaderbundle'

gpu.ShaderLibrary? _shaderLibrary;
gpu.ShaderLibrary get shaderLibrary {
  if (_shaderLibrary != null) {
    return _shaderLibrary!;
  }
  _shaderLibrary = gpu.ShaderLibrary.fromAsset(_kShaderBundlePath);
  if (_shaderLibrary != null) {
    return _shaderLibrary!;
  }

  throw Exception("Failed to load shader bundle! ($_kShaderBundlePath)");
}

This code creates a singleton getter for the Flutter GPU shader runtime library. The first time shaderLibrary is accessed, the runtime shader library is initialized using the built asset bundle with gpu.ShaderLibrary.fromAsset(shader_bundle_path).

The project is now set up to use Flutter GPU shaders. It’s time to render that triangle!

Drawing your first triangle

For this guide, you’ll create an RGBA Flutter GPU Texture and a RenderPass that attaches the Texture as a color output. Then, you’ll render the Texture in a widget using Canvas.drawImage.

For the sake of brevity, you’ll forego best practice and just rebuild all of the resources for each frame.

As long as you mark your Texture as "shader readable" when allocating it, you’ll be able to convert it to a dart:ui.Image. To display the rendered results in the widget tree, draw it to a dart:ui.Canvas!

You can access a Canvas by scaffolding the widget tree with a custom painter. Replace the contents of lib/main.dart with the following:

import 'dart:typed_data';

import 'package:flutter/material.dart';
import 'package:flutter_gpu/gpu.dart' as gpu;

// NOTE: We made this earlier while setting up shader bundle imports!
import 'shaders.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter GPU Triangle Example',
      home: CustomPaint(
        painter: TrianglePainter(),
      ),
    );
  }
}

class TrianglePainter extends CustomPainter {
  @override
  void paint(Canvas canvas, Size size) {
    // Attempt to access `gpu.gpuContext`.
    // If Flutter GPU isn't supported, an exception will be thrown.
    print('Default color format: ' +
        gpu.gpuContext.defaultColorFormat.toString());
  }

  @override
  bool shouldRepaint(covariant CustomPainter oldDelegate) => true;
}

Now, run the app. As a reminder, Flutter GPU currently requires Impeller to be enabled. So you must use an Impeller-supported platform. For this guide, I'll be targeting macOS.

flutter run -d macos --enable-impeller

If Flutter GPU is working, then you should see the default color format printed to the console.

flutter: Default color format: PixelFormat.b8g8r8a8UNormInt

If Impeller isn't enabled, an exception is thrown when attempting to access gpu.gpuContext.

Exception: Flutter GPU requires the Impeller rendering backend to be enabled.

The relevant error-causing widget was:
  CustomPaint

For the sake of simplicity, you’ll only modify the paint method from here onwards.

To start off, create a Flutter GPU Texture, clear it, and then display it by drawing it to the Canvas.

Create a Texture the size of the Canvas. A StorageMode must be chosen. In this case, you’ll mark the Texture as devicePrivate, because you'll only be using instructions that accesses the texture's memory from the device (GPU).

final texture = gpu.gpuContext.createTexture(gpu.StorageMode.devicePrivate,
    size.width.toInt(), size.height.toInt())!;

If overwriting the texture's data by uploading it from the host (CPU), then use StorageMode.hostVisible instead.

The third available option is StorageMode.deviceTransient, which is useful for attachments that don't need to exceed the lifetime of a single RenderPass (so they can just exist in tile memory and don't need to be backed by a VRAM allocation). Oftentimes, depth/stencil textures fit this criteria.

Next, define a RenderTarget. Render targets contain a collection of "attachments" that describe a per-fragment memory layout and its setup/teardown behavior at the beginning and end of a RenderPass.

Essentially, a RenderTarget is a reusable descriptor for a RenderPass.

For now, define a very simple RenderTarget consisting of only one color attachment.

final renderTarget = gpu.RenderTarget.singleColor(
gpu.ColorAttachment(texture: texture, clearValue: Colors.lightBlue));

Notice that this code sets the clearValue to light blue. Each attachment has a LoadAction and a StoreAction that determines what should happen to the attachment's ephemeral tile memory at the beginning and end of the pass, respectively.

By default, color attachments are set to LoadAction.clear (which initializes the tile memory to a given color), and StoreAction.store (which saves the results to the attached texture's VRAM allocation).

Now, create a CommandBuffer, spawn a RenderPass from it using the RenderTarget from earlier, and then immediately submit the CommandBuffer to clear the texture.

final commandBuffer = gpu.gpuContext.createCommandBuffer();
final renderPass = commandBuffer.createRenderPass(renderTarget);
// ... draw calls will go here!
commandBuffer.submit();

All that's left is to draw the initialized texture to the Canvas!

final image = texture.asImage();
canvas.drawImage(image, Offset.zero, Paint());

Now that you have a RenderPass hooked up with results displayed to the screen, you’re ready to start drawing the triangle. To do this, set up the following:

A RenderPipeline created from our shaders, and
A GPU-accessible buffer containing our geometry (three vertex positions).

Creating the RenderPipeline is easy. You just need to combine a vertex and fragment shader from your library.

final vert = shaderLibrary['SimpleVertex']!;
final frag = shaderLibrary['SimpleFragment']!;
final pipeline = gpu.gpuContext.createRenderPipeline(vert, frag);

Now for the geometry. Recall that the "SimpleVertex" shader only has one input: in vec2 position. So, to draw the three vertices, you need three sets of two floating point numbers.

final vertices = Float32List.fromList([
  -0.5, -0.5, // First vertex
   0.5, -0.5, // Second vertex
   0.0,  0.5, // Third vertex
]);
final verticesDeviceBuffer = gpu.gpuContext
    .createDeviceBufferWithCopy(ByteData.sublistView(vertices))!;

All that's remaining is to bind the new resources and call renderPass.draw() to finish recording the draw call.

renderPass.bindPipeline(pipeline);

final verticesView = gpu.BufferView(
  verticesDeviceBuffer,
  offsetInBytes: 0,
  lengthInBytes: verticesDeviceBuffer.sizeInBytes,
);
renderPass.bindVertexBuffer(verticesView, 3);

renderPass.draw();

If you launch your app, you should now see a green triangle!

Yay, you built a renderer from scratch with Flutter, Dart, and a little bit of GLSL!

Whether this is your first time rendering a triangle or you're a seasoned graphics veteran, I hope you'll continue playing with Flutter GPU and check out the packages that we're working on, like Flutter Scene.

In the future, we hope to publish beginner-friendly codelabs that dive deeper into Flutter GPU's default behavior and best practices. We still haven't talked about the vertex attribute layout, texture binding, uniforms and alignment requirements, pipeline blending, depth and stencil attachments, perspective correction, and so much more!

Until then, I'd recommend exploring Flutter Scene as a more comprehensive example of how to use Flutter GPU.

3D rendering with Flutter Scene

Flutter Scene (package flutter_scene) is a new 3D scene graph package powered by Flutter GPU that enables Flutter developers to import animated glTF models and render realtime 3D scenes.

The intent is to provide a package that makes building interactive 3D apps and games easy in Flutter.

This package started life as a dart:ui extension for a 3D renderer written in C++ and built directly into Flutter's native runtime, but it's been rewritten against Flutter GPU with a more flexible interface.

As with the Flutter GPU API itself, Flutter Scene is currently in an early preview state and requires Impeller to be enabled. Flutter Scene generally keeps up to date with breaking changes to Flutter GPU's API, and so it's strongly recommended to use the main channel when experimenting with Flutter Scene.

Next, make an app with Flutter Scene!

Set up a Flutter Scene project

Since it's strongly recommended to use Flutter Scene against the main channel, start off by switching to it.

flutter channel main
flutter upgrade

Next, create a fresh Flutter project.

flutter create my_3d_app
cd my_3d_app

Flutter Scene relies on the experimental "native assets" feature for automatically building shaders. You’ll use native assets in a moment to set up automatic importing of 3D models for Flutter Scene.

Enable native assets with the following command.

flutter config --enable-native-assets

And finally, add Flutter Scene as a project dependency.

You’ll also need to use several vector_math constructs while interacting with Flutter Scene's API, so add the vector_math package as well.

flutter pub add flutter_scene vector_math

Next, import a 3D model!

Import a 3D model

First, you need a 3D model to render. For this guide, you’ll use a common glTF sample asset: DamagedHelmet.glb. Here's what it looks like.

\"\" — The original Damaged Helmet model was created by theblueturtle_ in 2016 (license: CC BY-NC 4.0 International). The converted glTF version was created by ctxwing in 2018 (license: CC BY 4.0 International)

You can grab it from the glTF sample assets repository hosted on GitHub. Place DamagedHelmet.glb in your project root.

curl -O https://raw.githubusercontent.com/KhronosGroup/glTF-Sample-Models/main/2.0/DamagedHelmet/glTF-Binary/DamagedHelmet.glb

Like most real-time 3D renderers, Flutter Scene uses a specialized 3D model format internally. You can convert standard glTF binaries (.glb files) to this format using Flutter Scene's offline importer tool.

Add the flutter_scene_importer package to the project as a regular dependency.

flutter pub add flutter_scene_importer

Note: The importer will automatically build itself using CMake when invoked. So be sure to install CMake. Otherwise, you will run into “ProcessException: No such file or directory” errors.

Adding this package makes it possible to invoke the importer manually using dart run.

dart --enable-experiment=native-assets \\
     run flutter_scene_importer:import \\
     --input "path/to/my/source_model.glb" \\
     --output "path/to/my/imported_model.model"

You can automatically run the importer by using a native assets build hook. To do this, first install native_assets_cli as a regular project dependency.

flutter pub add native_assets_cli

You can now write the build hook. Create hook/build.dart with the following contents.

import 'package:native_assets_cli/native_assets_cli.dart';
import 'package:flutter_scene_importer/build_hooks.dart';

void main(List<String> args) {
  build(args, (config, output) async {
    buildModels(buildConfig: config, inputFilePaths: [
      'DamagedHelmet.glb',
    ]);
  });
}

Using the buildModels utility from flutter_scene_importer, supply a list of models to build. The paths are relative to the build root of the project.

When the Flutter tool is building the project, buildModels now builds the shader bundle and outputs the result to build/models/DamagedModel.model under the package root.

The imported model format itself is tied to the specific version of Flutter Scene you're using and will change over time. When authoring an app or library that uses Flutter Scene, do not check the generated .model files into your source tree. Instead, use a build hook to generate them from your source models (as previously explained).

This way, you'll always build fresh .model files with the correct format as you upgrade Flutter Scene over time!

Next, import the model like a regular asset. Add an asset entry to your project's pubspec.yaml.

flutter:
  assets:
    - build/models/

Rendering a 3D scene

Now for the app's code.

First, create a stateful widget to persist a Scene across frames.

You’ll be animating based on time, so add the SingleTickerProviderStateMixin to the state along with an elapsedSeconds member.

import 'dart:math';

import 'package:flutter/material.dart';
import 'package:flutter/scheduler.dart';
import 'package:flutter_scene/camera.dart';
import 'package:flutter_scene/node.dart';
import 'package:flutter_scene/scene.dart';
import 'package:vector_math/vector_math.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatefulWidget{
  const MyApp({super.key});

  @override
  MyAppState createState() => MyAppState();
}

class MyAppState extends State<MyApp> with SingleTickerProviderStateMixin {
  double elapsedSeconds = 0;
  Scene scene = Scene();

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'My 3D app',
      home: Placeholder(),
    );
  }
}

Run the app as a smoke test to ensure there are no errors. And remember to enable Impeller!

flutter run -d macos --enable-impeller

Before continuing, set up the ticker for the animation. Override initState in MyAppState to call createTicker.

  @override
  void initState() {
    createTicker((elapsed) {
      setState(() {
        elapsedSeconds = elapsed.inMilliseconds.toDouble() / 1000;
      });
    }).start();

    super.initState();
  }

As long as the widget is visible, the ticker callback is invoked for every frame. Calling setState triggers this widget to rebuild every frame.

Next, load up the 3D model that you placed in the project earlier and add it to the Scene.

Use Node.fromAsset to load the model from the asset bundle. Place the following code in initState.

    Node.fromAsset('build/models/DamagedHelmet.model').then((model) {
      model.name = 'Helmet';
      scene.add(model);
    });

Node.fromAsset asynchronously deserializes the model from the asset bundle and resolves the returned Future<Node> once it's ready to be added to the scene.

The MyAppState.initState should now look as follows:

  @override
  void initState() {
    createTicker((elapsed) {
      setState(() {
        elapsedSeconds = elapsed.inMilliseconds.toDouble() / 1000;
      });
    }).start();

    Node.fromAsset('build/models/DamagedHelmet.model').then((model) {
      model.name = 'Helmet';
      scene.add(model);
    });

    super.initState();
  }

However, you’re still not actually rendering the 3D Scene yet! To do this, use Scene.render, which takes a UI Canvas, a Flutter Scene Camera, and a size.

One way to access a Canvas is to create a CustomPainter:

class ScenePainter extends CustomPainter {
  ScenePainter({required this.scene, required this.camera});
  Scene scene;
  Camera camera;

  @override
  void paint(Canvas canvas, Size size) {
    scene.render(camera, canvas, viewport: Offset.zero & size);
  }

  @override
  bool shouldRepaint(covariant CustomPainter oldDelegate) => true;
}

Don't forget to set the shouldRepaint override to return true so that the custom painter will repaint whenever a rebuild occurs.

Lastly, add the CustomPainter to the source tree.

  @override
  Widget build(BuildContext context) {
    final painter = ScenePainter(
      scene: scene,
      camera: PerspectiveCamera(
        position: Vector3(sin(elapsedSeconds) * 3, 2, cos(elapsedSeconds) * 3),
        target: Vector3(0, 0, 0),
      ),
    );

    return MaterialApp(
      title: 'My 3D app',
      home: CustomPaint(painter: painter),
    );
  }

This code instructs the camera to move in a continuous circle, but always facing towards the origin.

Finally, start the app!

flutter run -d macos --enable-impeller

Here's the full source we put together.

import 'dart:math';

import 'package:flutter/material.dart';
import 'package:flutter_scene/camera.dart';
import 'package:flutter_scene/node.dart';
import 'package:flutter_scene/scene.dart';
import 'package:vector_math/vector_math.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatefulWidget {
  const MyApp({super.key});

  @override
  MyAppState createState() => MyAppState();
}

class MyAppState extends State<MyApp> with SingleTickerProviderStateMixin {
  double elapsedSeconds = 0;
  Scene scene = Scene();

  @override
  void initState() {
    createTicker((elapsed) {
      setState(() {
        elapsedSeconds = elapsed.inMilliseconds.toDouble() / 1000;
      });
    }).start();

    Node.fromAsset('build/models/DamagedHelmet.model').then((model) {
      model.name = 'Helmet';
      scene.add(model);
    });

    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    final painter = ScenePainter(
      scene: scene,
      camera: PerspectiveCamera(
        position: Vector3(sin(elapsedSeconds) * 3, 2, cos(elapsedSeconds) * 3),
        target: Vector3(0, 0, 0),
      ),
    );

    return MaterialApp(
      title: 'My 3D app',
      home: CustomPaint(painter: painter),
    );
  }
}

class ScenePainter extends CustomPainter {
  ScenePainter({required this.scene, required this.camera});
  Scene scene;
  Camera camera;

  @override
  void paint(Canvas canvas, Size size) {
    scene.render(camera, canvas, viewport: Offset.zero & size);
  }

  @override
  bool shouldRepaint(covariant CustomPainter oldDelegate) => true;
}

Flutter’s great future ahead

If you were able to successfully follow one of these guides and get something up and running: Woohoo, congrats!

Both Flutter GPU and Flutter Scene are very young efforts with limited platform support. But I think someday we'll look back fondly at these humble beginnings.

With the Impeller effort, the Flutter team took full ownership over the rendering stack because we needed to specialize the renderer towards Flutter's use case. And now we're starting a new chapter in Flutter's history. One where YOU collectively take control over the rendering!

Flutter Scene started as a C++ component in Impeller alongside the 2D Canvas renderer with a slim dart:ui extension. By the time I was building it, I was already aware that Flutter Engine wouldn't be its final destination.

The sea of architecture decisions for 3D renderers is vast, and no single generic 3D renderer can solve every use case well. "Generic" and "high performance" are generally antithetical goals.

At best, adequacy at everything all but guarantees excellence at nothing.

In the world of rendering performance, the situation is even worse. Specializing for one use case often means degrading the performance of another.

In short, it's just not possible to ship a generic 3D renderer that can solve every use case for everyone. But, by surfacing the low level APIs necessary for you to build your own solutions (Flutter GPU), and building a useful generic 3D renderer on top of it that's easy for the Flutter community to inspect and modify (Flutter Scene), we’re carving out the space for Flutter developers to enjoy low-risk for obsolescence and a high reward.

I can't wait to see what you'll make with these new capabilities. Stay tuned for future releases of Flutter Scene. There's a lot on the way.

In the meantime, I’m heading back to work.

See you soon. :)

$\"\"$

Getting started with Flutter GPU was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/f33d497b7c11","Getting started with Flutter GPU",{"_2445":13},{"_8":2712,"_30":2713,"_2456":2664,"_2458":2714,"_2445":13,"_2460":2715,"_36":2716,"_2463":2717},747,"2024-08-06T18:00:29+00:00","

An early look at Flutter GPU, web enhancements, and more!

Today, we’re unveiling Flutter 3.24 and Dart 3.5 alongside the last stop in the I/O 2024 Connect series, happening in just a few hours in China — one of Flutter’s most prolific communities in the world, making this moment very special.

We kicked off Google I/O in May with an exciting slew of updates, including the graduation of support for WebAssembly compilation to the stable channel, improvements to Impeller, and an early look at the future of Dart macros.

The Flutter 3.24 and Dart 3.5 releases build upon our mission to help you craft stunning, performant apps that reach users across mobile, web, and desktop — all from a single, shared codebase. They include an early preview of the new Flutter GPU API, enhancements to element embedding on the web, and several exciting updates for those interested in building for the iOS ecosystem, including early support for Swift Package Manager, and updated functionality to Cupertino widgets.

Let’s jump in!

Impeller: Raising the bar for multi-platform graphics performance

Historically, cross-platform frameworks have required compromise on visuals, due to a reliance on high-level abstractions offered by the underlying platforms. Flutter has taken a different approach, with its own rendering layer that offers hardware-accelerated graphics and smooth performance on every device. We’ve made substantial progress with Impeller and shaders, unlocking exciting new possibilities in graphics — like 3D.

We’re excited to share an early preview of the new Flutter GPU API, a powerful, low-level graphics API integrated directly into the Flutter SDK. The API allows you to define custom raster pipelines and submit draw calls directly to the GPU, making it possible to create specialized renderers like 2D Canvas alternatives, 3D scene graphs, or even particle systems for visually stunning, performant, and immersive experiences without the engine-level bulk typically needed.

\"\" — 3D animation of a sci-fi space helmet rendered in flutter_scene.

Given how low-level the API is, we expect a learning curve for developers who don’t have significant experience developing graphics. That’s why we’re investing in rendering packages, like the new flutter_scene package, which leverages the Flutter GPU API to allow importing animated glTF models and constructing 3D scenes, enabling you to easily build 3D apps and games in Flutter and Dart, like the one below.

While the Flutter GPU API offers exciting possibilities, it’s still in early preview and we might make breaking changes to the API. We recommend developing against Flutter’s main channel when using Flutter GPU. Learn more in the blog post Introducing Flutter GPU & Flutter Scene.

Flutter for iOS and macOS: making it easier to deliver beautiful, fast apps for the Apple ecosystem

It’s our goal to empower you to build exceptional apps that feel native and perform flawlessly. Part of that work is optimizing performance as well as maximizing Flutter’s compatibility with the underlying platforms, including accessing the full power of the Apple ecosystem.

In this release, we’ve introduced early support for Swift Package Manager, unlocking access to the thriving Swift package ecosystem, and empowering Flutter plugins to leverage a wealth of pre-built functionality to accelerate development. Once Swift Package Manager (SPM) is widely adopted by plugin developers, it should simplify the Flutter installation process itself, and lower the barrier to entry for newcomers, particularly those that aren’t familiar with the iOS ecosystem. We encourage plugin authors to try adding support for SPM to your plugins, and provide feedback on your experience.

Next, we want to enable you to always say “yes” to your designers and deliver high-fidelity experiences on iOS. To address this, we’ve embarked on a journey to modernize and expand our Cupertino widget library, resolving 15 issues across Cupertino, and adding 37 missing Cupertino widgets in the widget catalog.

Finally, we’ve added platform view and webview support for Flutter macOS apps, allowing for seamless integration of native macOS UI components directly into your Flutter app for a more complete and polished user experience.

Looking forward, we’re excited to invest more in additional Cupertino widget fidelity, land Swift Package Manager with our ecosystem, and provide other investments that make it even easier to integrate and interoperate with Apple’s platforms.

Highlighting the global impact of the vibrant Flutter community

We also want to acknowledge that these releases wouldn’t be possible without contributions from the community, including you! This set of releases consist of almost 1,500 commits from over 167 unique contributors, including 49 new contributors. We’re inspired by the continued high levels of activity, commitment, and growth in the Flutter community, including those actively building the framework. Thank you!

The impact of our collective work is showing up all over the world in incredible apps and experiences that millions of people use every day. For instance, here is a sneak peek at a case study showing how and why a small team at a Chinese technology company, Xiaomi, used Flutter to develop a companion app for the firm’s popular new EV, the Xiaomi SU7.

Several other exciting examples of Flutter apps popping up all over the world:

SNCF Connect, the French railway, and owners of the largest Flutter app in Europe at over 150 screens, partnered with the Olympics to deliver many updates to the Flutter app that enabled millions of visitors to travel across France during the Olympic games.
Wolt, part of DoorDash International, used Flutter to expand into the merchant retail market.
Whirlpool, a Fortune 500 company with a worldwide presence, is exploring new sales channels in Brazil using Flutter.
Monta, a Danish EV charging ecosystem startup, brought their first mobile app to market in just 3 months with Flutter, and later successfully ported their web app to Flutter too.

Wrap up

The above are just a few of many new features and updates to Flutter and Dart in these releases, and you can learn more in the Flutter 3.24 technical blog post and in the Dart 3.5 blog post.

Looking ahead, we’re filled with excitement for the future of Flutter. We remain committed to our mission, and we’re grateful to you — whether a contributor, community member, or Flutter developer — for being part of this amazing journey. We can’t wait to see what you build next!

$\"\"$

Announcing Flutter 3.24 and Dart 3.5 was originally published in Flutter on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/204b7d20c45d","Announcing Flutter 3.24 and Dart 3.5",{"_2445":13},{"_8":2719,"_30":2720,"_2456":2721,"_2458":-5,"_2445":2448,"_2460":2722,"_36":2723,"_2463":2724},430,"2020-05-02T13:33:09+00:00",2020,"https://medium.com/p/56c8b918dc0a","SwiftUI — You got this! Learn to build your first app — Part 1 of 3",{"_2445":2448},{"_8":2726,"_30":2727,"_2456":2728,"_2458":2729,"_2445":2448,"_2460":2730,"_36":2731,"_2463":2732},749,"2019-04-04T09:40:15+00:00",2019,"

Design patterns by Tutorials — The power of OOP (part 2)

Singleton Pattern: pure-singleton and semi-singleton design pattern in Swift

Prerequisites — This blog series requires an intermediate level of expertise in object-oriented programming. You should have basic knowledge about class, object, constructor, inheritance, value and reference type. An Intermediates will gain knowledge and experts will sharpen his or her knowledge by reading this series from start to finish.

Singleton class

In object-oriented programming, a singleton class is a class that can have only one object during the whole life-cycle of an application or project.

Singleton design pattern is a part of iOS Applications life-cycle code. For example, in an iOS project, the UIApplication class is the best example of a singleton class, which is created by the iOS system on app launch and passed to the AppDelegate as a parameter in application(_:didFinishLaunchingWithOptions:)method.

There are two types of Singleton design patterns.

Pure-singleton design pattern
Semi-singleton design pattern

Pure-Singleton Design Pattern:

In this pattern, a programmer who is using the functionality of a pure-singleton class is not allowed to create an instance of the class. A programmer can only call methods and access properties available for the singleton class by using the predefined instance of that class.
The object of a pure-singleton class is automatically created during application launch with pre-defined parameters mentioned by the developer who created that class.
Pure-singleton classes must be marked as final to avoid inheritance confusion. In swift, you can use structure also to achieve the same concept.
A programmer cannot inherit the pure-singleton class. When you try to inherit any class in swift, you must call the constructor of the superclass. Calling the constructor of the superclass is not possible in pure-singleton class because all constructors of the pure-singleton class are always marked as private.

Let understand this design pattern in a simple way with below example.

In the above example, PureSingletonDesignPatterExample1.swift we have marked all init methods as private of LogManger class so no one can create an instance of that class. If we try to create a sub-class of LogManger, the compiler will give you an error.

UIApplication, AppDelegate are examples of the pure-singleton class. Have you ever tried to create an object of UIApplication class manually? Try to do so and run the app. [What happened? App crashed, right? -I have tested this crash on swift 5, XCode 10.2]

Limitations of Pure-Singleton Design Pattern,

We cannot test the pure-singleton class with the test data. In the above example PureSingletonDesignPatterExample1.swift, suppose you want to test the LogManager class by pointing it to some test mode URL instead of production mode URL, we can not do that when we are writing test cases in XCTest target.

We can overcome this limitation by converting our pure-singleton class to semi-singleton class or by using the dependency injection pattern. I will write a dedicated article on dependency injection pattern. For now, let’s continue with the semi-singleton design pattern.

Semi-singleton design pattern:

In semi-singleton design pattern, a programmer who is using the class is allowed to create an object of the singleton class if required. as well as also allowed to call methods and use properties of the singleton class.
A programmer can also inherit the semi-singleton class if the singleton is not marked as final by the developer of the singleton class. In semi-singleton design pattern to mark the class as a final is not necessary.

In the above example, SemiSingletonDesignPatterExample1.swift, we have not marked the init method as private, so we can create multiple instances of the semi-singleton class to remove the dependency from the property databaseURLEndpoint. Now we can create an object of the LogManger class by using any databaseURLEndpoint value, now our class LogManger follows the semi-singleton pattern.

UserDefault, FileManager, NotificationCenter are the example of semi-singleton classes. We can use pre-defined shared objects of UserDefault, FileManager, and NotificationCenter which are UserDefault.standard, FileManager.default and NotificationCenter.default.

The pre-defined object of pure or semi-singleton classes always lives in memory and never destroyed until you close the application. A programmer-defined object of semi singleton class destroyed after the scope of the object is completed.

Question: Which is a better way, “Pure-singletone design pattern” or “Semi-singleton design pattern”, when I should use the first one and when other one?

This totally depends on the responsibilities of your class. If you have created singleton class in your project and needs to change some of the properties at some point or if you want to add more responsibilities to the class by adding new methods in future and if you required its test cases also with mock data for newly added methods, you should go with the semi-singleton design pattern.

If you created your class, you are done with unit testing and want to publish it via a framework or library, you can go with pure-singleton design patterns. Because you created the class and some other developer will use it, so unit testing of your singleton-class is your responsibility before release, not the responsibility of the developer who is using it.

Liked this article?
Give claps and show your support.
It doesn’t cost you anything to clap.

Antoine v.d. Lee 🇳🇱 on Twitter

Although the URLSession APIs are pretty good nowadays, Alamofire is still very popular (30k stars on Github). For my upcoming blog post, I'd like to know your preference, Alamofire or URLSession?

It turns out that there is a clear separation between developers who prefer to use Alamofire or URLSession. A big question here is if they only prefer it or whether they actually choose to go with the framework of choice as well.

Alamofire is being advertised as “Elegant Networking in Swift” which gives away its intention a bit already. It’s a layer on top of URLSession with the goal to make common networking features easier to implement.

Features which are easier to implement with Alamofire

Alamofire contains a lot of extra logic apart from simply building a networking request. These features can make a difference and can sometimes save you a lot of time compared to building them yourself.

The list of features advertised on their repository readme is long, from which only a few of them really add unique extra value:

Certificate pinning. It can take some time to sort this out and build this yourself.
Requests retrying. When a request fails for example because of an authentication failure, you can easily refresh your authentication token and invoke the same request again without touching the implementation code.

Apart from these features, the syntax for building up requests is a lot more elegant and easier to use. It saves you from a lot extra code and makes validation and error handling a lot easier.

Often seen as an advantage is the network reachability manager. However, since iOS 12 we can make use of the new NWPathMonitor API as well.

Building a network request compared

Let’s say we have an API which allows us to create a new board with a title “New York Highlights”. For this, using Alamofire the code is very easy:

AF.request("https://api.mywebserver.com/v1/board", method: .get, parameters: ["title": "New York Highlights"])
    .validate(statusCode: 200..<300)
    .responseDecodable { (response: DataResponse) in
        switch response.result {
        case .success(let board):
            print("Created board title is \\(board.title)") // New York Highlights
        case .failure(let error):
            print("Board creation failed with error: \\(error.localizedDescription)")
        }
}

Doing exactly the same with the URLSession API requires a bit more of work.

enum Error: Swift.Error {
    case requestFailed
}

// Build up the URL
var components = URLComponents(string: "https://api.mywebserver.com/v1/board")!
components.queryItems = ["title": "New York Highlights"].map { (key, value) in
    URLQueryItem(name: key, value: value)
}

// Generate and execute the request
let request = try! URLRequest(url: components.url!, method: .get)
URLSession.shared.dataTask(with: request) { (data, response, error) in
    do {
        guard let data = data,
            let response = response as? HTTPURLResponse, (200 ..< 300) ~= response.statusCode,
            error == nil else {
            // Data was nil, validation failed or an error occurred.
            throw error ?? Error.requestFailed
        }
        let board = try JSONDecoder().decode(Board.self, from: data)
        print("Created board title is \\(board.title)") // New York Highlights
    } catch {
        print("Board creation failed with error: \\(error.localizedDescription)")
    }
}

This shows the real power of Alamofire as the framework makes a lot of things easier:

The request is build up within a single initializer
A URL encoder is encoding parameters by default
Validation is done inline with a simple one-liner and converts into a strongly typed error if validation fails. The response result enum will return this error inside the failure case.
A generic completion callback makes it easy to decode the response into our custom Board type

This only could already be a reason to chose for Alamofire and make your life easier. With using URLSession you’re likely ending up making your own wrapper, which requires maintenance and testing. At first, this might seem to be a better decision compared to adding a new dependency, but as projects evolve it could easily be that your own networking layer evolves and gets more complex.

How bad would it be to add Alamofire as a dependency?

Let’s make it clear that you have to be careful when adding an external dependency to your project. When it’s not maintained, tested or not used a lot, it can add a possible risk to your project. In the end, you might have to continue the development yourself.

In the case of Alamofire, you don’t really have to worry about that. The framework is well maintained, tested, and used. The framework is quite small and makes it way more elegant to write network requests.

Conclusion: How to make the decision?

Alamfore is often compared to AFNetworking, the Objective-C equivalent framework for networking. At the time, networking was a lot harder without the URLsession API which only exists since iOS 7. Therefore, it was way more obvious to chose for a framework like AFNetworking to make your life a bit easier.

Nowadays, looking at the URLSession APIs available, it’s a lot easier to build up network requests. However, doing so will likely move you towards building your own networking layer on top of URLSession. This layer needs to be tested and can potentially grow towards a more complex layer as your project evolves.

With that in mind, taking the fact that Alamofire is well maintained and used by a lot of projects, you’re probably saving yourself a lot of hassle and time by adding Alamofire as a dependency.

This blog post is comparing URLSession to Alamofire 5, which is in beta at the moment of writing. You can read more about this release here.

Originally published at SwiftLee.

More posts and updates: @twannl

$\"\"$

Alamofire vs URLSession: a comparison for networking in Swift was originally published in Swift Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/c6cb3bc9f3b8","Alamofire vs URLSession: a comparison for networking in Swift",{"_2445":2448},{"_8":2741,"_30":2742,"_2456":2728,"_2458":-5,"_2445":2448,"_2460":2743,"_36":2744,"_2463":2745},746,"2019-04-04T01:43:56+00:00","https://medium.com/p/eadc97b1a9b8","Clear and searchable logging in Swift with OSLog",{"_2445":2448},{"_8":2747,"_30":2748,"_2456":2728,"_2458":2749,"_2445":2448,"_2460":2750,"_36":2751,"_2463":2752},631,"2019-01-08T15:01:56+00:00","

Memory leaks often happen without notice. Although best practices like using a weak reference to self inside closures help a lot, it’s often not enough to prevent you from finding a certain memory peak during the development of a project.

We can use memory graph debugging or Xcode Instruments to help find and fix leaked and abandoned memory. This, however, requires us to make it part of our regular workflow to prevent memory leaks from sneaking in.

Making it easy to test your app for memory leaks prevent us from introducing them without notice. This will not avoid all leaks, but it will decrease the chance at least.

Avoiding memory leaks using unit tests

Writing a unit test by combining a weak reference with an autoreleasepool makes it easy to verify deallocation. This can be seen as verifying that the deinit of a class is called and the memory is released.

In the following example, we’re verifying that a view controller is released. By creating an easy to use extension method on XCTestCase you make it easy to add this method to any of your view controller unit test classes. Besides, it's a great way to verify that your view controllers get released correctly.

/// Ensures that the OwnedBucketViewController gets deallocated after being added to the navigation stack, then popped.
func testDeallocation() {
    assertDeallocation { () -> UIViewController in
        let bucket = Bucket()
        let viewModel = OwnedBucketViewModel(bucket: bucket)
        return OwnedBucketViewController(viewModel: viewModel)
    }
}

The extension creates a weak reference to the view controller which is created in the closure. After that, we present and dismiss the created view controller after which we’re verifying that the weak reference is set to nil.

extension XCTestCase {

    /// Verifies whether the given constructed UIViewController gets deallocated after being presented and dismissed.
    ///
    /// - Parameter testingViewController: The view controller constructor to use for creating the view controller.
    func assertDeallocation(of testedViewController: () -> UIViewController) {
        weak var weakReferenceViewController: UIViewController?

        let autoreleasepoolExpectation = expectation(description: "Autoreleasepool should drain")
        autoreleasepool {
            let rootViewController = UIViewController()

            // Make sure that the view is active and we can use it for presenting views.
            let window = UIWindow(frame: CGRect(x: 0, y: 0, width: 400, height: 400))
            window.rootViewController = rootViewController
            window.makeKeyAndVisible()

            /// Present and dismiss the view after which the view controller should be released.
            rootViewController.present(testedViewController(), animated: false, completion: {
                weakReferenceViewController = rootViewController.presentedViewController
                XCTAssertNotNil(weakReferenceViewController)

                rootViewController.dismiss(animated: false, completion: {
                    autoreleasepoolExpectation.fulfill()
                })
            })
        }
        wait(for: [autoreleasepoolExpectation], timeout: 10.0)
        wait(for: weakReferenceViewController == nil, timeout: 3.0, description: "The view controller should be deallocated since no strong reference points to it.")
    }

    /// Checks for the callback to be the expected value within the given timeout.
    ///
    /// - Parameters:
    ///   - condition: The condition to check for.
    ///   - timeout: The timeout in which the callback should return true.
    ///   - description: A string to display in the test log for this expectation, to help diagnose failures.
    func wait(for condition: @autoclosure @escaping () -> Bool, timeout: TimeInterval, description: String, file: StaticString = #file, line: UInt = #line) {
        let end = Date().addingTimeInterval(timeout)

        var value: Bool = false
        let closure: () -> Void = {
            value = condition()
        }

        while !value && 0 < end.timeIntervalSinceNow {
            if RunLoop.current.run(mode: RunLoop.Mode.default, before: Date(timeIntervalSinceNow: 0.002)) {
                Thread.sleep(forTimeInterval: 0.002)
            }
            closure()
        }

        closure()

        XCTAssertTrue(value, "➡️🚨 Timed out waiting for condition to be true: \\"\\(description)\\"", file: file, line: line)
    }
}

If any logic within the testing view controller retains the given view controller, this test would fail.

To validate that our weak reference is set to nil we're using another extension method on XCTestCase which is a very handy method to periodically check for a certain condition to match.

The XCTest API brings a great API for creating expectations for notifications, predicates or key-value observation, but none of these make it possible to validate that the weak reference is eventually set to nil. Our new extension method does make this possible. It checks for the given amount of time whether the condition is matched and if not, it fails.

The use of an autoreleasepool

Without the autoreleasepool we would’ve not been able to verify that the weak reference would eventually be released. All the references within the autoreleasepool closure should be released when it’s drained. This only happens if no strong references exist.

The above view controller example can be used to build more unit tests to verify the deallocation of your objects.

More on memory debugging

WWDC over the years dedicated quite a few sessions to memory debugging. For example, the iOS Memory Deep Dive session of WWDC 2018 which helps you understand the true memory cost of an image and gives you tips and tricks for reducing the memory footprint of an app.

Originally published at SwiftLee.

More posts and updates: @twannl

$\"\"$

Memory leaks prevention using an autoreleasepool in unit tests was originally published in Swift Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/ccd6319979","Memory leaks prevention using an autoreleasepool in unit tests",{"_2445":2448},{"_8":2754,"_30":2755,"_2456":2728,"_2458":2756,"_2445":2448,"_2460":2757,"_36":2758,"_2463":2759},436,"2019-01-08T15:01:28+00:00","

A QR Code is used a lot to share content or to add a new user in apps like Twitter and Snapchat. Since iOS 11 it’s possible for users to scan a QR code with the built-in camera app. This makes it even nicer to integrate a QR code in your own app.

Generating a QR code in iOS

Generating a QR code in iOS is easier than ever since the introduction of the CIQRCodeGenerator Core Image filter. It generates a plain black and white QR for the given input string.

guard let qrFilter = CIFilter(name: "CIQRCodeGenerator") else { return nil }
let qrData = absoluteString.data(using: String.Encoding.ascii)
qrFilter.setValue(qrData, forKey: "inputMessage")

let qrTransform = CGAffineTransform(scaleX: 12, y: 12)
let qrImage = qrFilter.outputImage?.transformed(by: qrTransform)

This QR code works already, but it is not really appealing and it is probably not aligned with the awesome design of your own app. Therefore, it would be really nice if we could customize it to fit our app design.

Changing the color of a QR code

The first step in customizing the QR code is to change the color. We do this in three steps:

Invert the colors black and white
Mask the black color to transparent
Change the color

To make this code easier to use we create an extension on CIImage.

extension CIImage {
    /// Inverts the colors and creates a transparent image by converting the mask to alpha.
    /// Input image should be black and white.
    var transparent: CIImage? {
        return inverted?.blackTransparent
    }

    /// Inverts the colors.
    var inverted: CIImage? {
        guard let invertedColorFilter = CIFilter(name: "CIColorInvert") else { return nil }

        invertedColorFilter.setValue(self, forKey: "inputImage")
        return invertedColorFilter.outputImage
    }

    /// Converts all black to transparent.
    var blackTransparent: CIImage? {
        guard let blackTransparentFilter = CIFilter(name: "CIMaskToAlpha") else { return nil }
        blackTransparentFilter.setValue(self, forKey: "inputImage")
        return blackTransparentFilter.outputImage
    }

    /// Applies the given color as a tint color.
    func tinted(using color: UIColor) -> CIImage?
    {
        guard
            let transparentQRImage = transparent,
            let filter = CIFilter(name: "CIMultiplyCompositing"),
            let colorFilter = CIFilter(name: "CIConstantColorGenerator") else { return nil }

        let ciColor = CIColor(color: color)
        colorFilter.setValue(ciColor, forKey: kCIInputColorKey)
        let colorImage = colorFilter.outputImage

        filter.setValue(colorImage, forKey: kCIInputImageKey)
        filter.setValue(transparentQRImage, forKey: kCIInputBackgroundImageKey)

        return filter.outputImage!
    }
}

A QR code is often linking to a URL. Therefore, it’s nice to create an extension on URL as well.

extension URL {

    /// Creates a QR code for the current URL in the given color.
    func qrImage(using color: UIColor) -> CIImage? {
        return qrImage?.tinted(using: color)
    }

    /// Returns a black and white QR code for this URL.
    var qrImage: CIImage? {
        guard let qrFilter = CIFilter(name: "CIQRCodeGenerator") else { return nil }
        let qrData = absoluteString.data(using: String.Encoding.ascii)
        qrFilter.setValue(qrData, forKey: "inputMessage")

        let qrTransform = CGAffineTransform(scaleX: 12, y: 12)
        return qrFilter.outputImage?.transformed(by: qrTransform)
    }
}

Which can be used as followed:

let swiftLeeOrangeColor = UIColor(red:0.93, green:0.31, blue:0.23, alpha:1.00)
let qrURLImage = URL(string: "https://www.avanderlee.com")?.qrImage(using: swiftLeeOrangeColor)

A QR code with a custom logo

To make it a really outstanding QR we can add our own custom logo. As a QR code has a certain error correction it allows us to replace a certain part of it with our custom logo. To do this, we create another extension on CIImage which takes our logo and returns a new CIImage which is a combination of the QR and our logo.

extension CIImage {

    /// Combines the current image with the given image centered.
    func combined(with image: CIImage) -> CIImage? {
        guard let combinedFilter = CIFilter(name: "CISourceOverCompositing") else { return nil }
        let centerTransform = CGAffineTransform(translationX: extent.midX - (image.extent.size.width / 2), y: extent.midY - (image.extent.size.height / 2))
        combinedFilter.setValue(image.transformed(by: centerTransform), forKey: "inputImage")
        combinedFilter.setValue(self, forKey: "inputBackgroundImage")
        return combinedFilter.outputImage!
    }
}

Combined with our updated URL extension we can create a nice new QR code including our own custom logo.

extension URL {
        /// Creates a QR code for the current URL in the given color.
    func qrImage(using color: UIColor, logo: UIImage? = nil) -> CIImage? {
        let tintedQRImage = qrImage?.tinted(using: color)

        guard let logo = logo?.cgImage else {
            return tintedQRImage
        }

        return tintedQRImage?.combined(with: CIImage(cgImage: logo))
    }
}

let swiftLeeOrangeColor = UIColor(red:0.93, green:0.31, blue:0.23, alpha:1.00)
let swiftLeeLogo = UIImage(named: "swiftlee_qr_logo.png")!

let qrURLImage = URL(string: "https://www.avanderlee.com")?.qrImage(using: swiftLeeOrangeColor, logo: swiftLeeLogo)

\"A — A QR Code generated in Swift using a custom color and logo

A Playground to play around

A complete version of this code can be found on Github here. It’s a Playground to allow you to play around and create your own custom QR code.

If you want to read more about the QR code filter or any other Core Image filters, check out the Apple Documentation.

Originally published at SwiftLee.

More posts and updates: @twannl

$\"\"$

QR Code generation with a custom logo and color using Swift was originally published in Swift Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/e1d0a44adbe3","QR Code generation with a custom logo and color using Swift",{"_2445":2448},{"_8":2761,"_30":2762,"_2456":2728,"_2458":2763,"_2445":2448,"_2460":2764,"_36":2765,"_2463":2766},748,"2019-01-08T15:00:53+00:00","

A cheat sheet can be a handy tool to quickly reference Xcode, Swift or iOS logic from a compact overview. Ideally, you can print them out and lay them down on your desk. This makes it really easy to access and use them often. Therefore, I’ll show you a few useful cheat sheets which you can use during development.

Assert, precondition or fatalError

Marcin Krzyzanowski created a great blog post called Swift asserts — the missing manual about the differences between assert, precondition, and fatalError. He explains each of them and what the impact is in terms of termination when using each in a production app without a debugger attached.

The cheat sheet

Make sure to check out the original version from Marcin in his blog post.

\"Swift — Swift Assertions Cheat Sheet from Marcin Krzyzanowski

Xcode Shortcuts

A lot of Xcode cheat sheets exists. Some are just a big list of shortcuts like the one from ShortcutFoo while others are more visual and useful to print out. Personally, I like to use the one from Craig Grummitt which is very visual and covers most of the basic shortcuts in Xcode 10.

GIT Cheat Sheet

GIT is what we use on daily basis to manage version control and if you’re a terminal GIT user it can sometimes be hard to remember all commands. Therefore, it can be very handy to use the GIT cheat sheet provided by GIT tower. It’s especially handy for those commands you don’t often use. Besides, it’s also worth to mention their Xcode cheat sheet.

More Xcode Shortcuts

If you would like to read more about Xcode shortcuts, you can check out my blog post on Shortcuts essentials in Xcode to speed up your workflow.

Originally published at SwiftLee.

More posts and updates: @twannl

$\"\"$

Cheat sheet examples for Xcode and Swift development was originally published in Swift Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/c263b6328a67","Cheat sheet examples for Xcode and Swift development",{"_2445":2448},{"_8":2768,"_30":2769,"_2456":2770,"_2458":-5,"_2445":2448,"_2460":2771,"_36":2772,"_2463":2773},750,"2018-12-16T01:58:12+00:00",2018,"https://medium.com/p/6a3af1b800f5","Create Xcode file templates and share them with your team",{"_2445":2448},{"_8":2775,"_30":2776,"_2456":2770,"_2458":-5,"_2445":2448,"_2460":2777,"_36":2778,"_2463":2779},434,"2018-12-16T01:56:25+00:00","https://medium.com/p/e64ef54864f3","Managing secrets within an iOS app",{"_2445":2448},{"_8":2781,"_30":2782,"_2456":2770,"_2458":2783,"_2445":2448,"_2460":2784,"_36":2785,"_2463":2786},435,"2018-12-12T09:36:58+00:00","

Especially the rulers can help you stop using the Mac screenshot pixel feedback to measure distance in your UI.

Simulator tools give you access to more functionalities within the iOS simulator and make it often easier to access features like recording a video with xcrun.

Some of the tools are paid while others are open sourced and free.

Antoine v.d. Lee 🇳🇱 on Twitter

I'm looking for a list of Mac apps to interact with the Xcode simulators, like https://t.co/V22L4e4BIk Anyone using a similar tool? #ios #xcode #swift

SimPholders

Website: simpholders.com
Price: €9.90

Although this app seems outdated, it does still work on Mojave. Feature highlights include quick access to the user defaults and the App Groups Container, but nothing really big to make it an outstanding added value. With open-source alternatives, you might want to save yourself the money.

\"The — The SimPholders application window opened.

simMagnifier

Easily access apps on your iOS Simulators. Explore folders, edit Core Data content and much more!

Website: microedition.biz/simMagnifier
Price: $18.00

simMagnifier comes with a bit more features compared to SimPholders, but is a bit more expensive as well. This might be the tool for you if you’re using Core Data as it comes with a Core Data browser with even the possibility to change data. Access to common folders and the user defaults are included as well.

xScope 4.0

Measure. Inspect. Test.

Website: xscopeapp.com
Price: $49.99

Although xScope is the most expensive one from this simulator tools list, it comes with the most features as well. It could easily be listed with the UI Tools blog post from a few weeks ago. It’s not a tool to access Core Data or User Defaults and it does not provide quick access to common folders, but it does add a lot of tools to verify your UI. These tools include rulers, guides and a loupe which follows your mouse for a more detailed view of a piece of UI. Especially the rules can help you stop using the Mac screenshot pixel feedback to measure distance in your UI.

\"The — The Loupe enabled in xScope to measure distance in the UI.

Unmentioned Open Source alternatives

Apart from these paid tools, some open source alternatives are available to use as well and worth to explore.

Originally published at SwiftLee.

More posts and updates: @twannl

$\"\"$

Simulator tools to get more out of the simulator was originally published in Swift Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.

","https://medium.com/p/fa6f3132f2b8","Simulator tools to get more out of the simulator",{"_2445":2448},"officialBlogs",[2789,2795],{"_8":9,"_2790":2791,"_2445":2792,"_2793":2794},"blog_url","https://reactnative.dev/blog","React Native","parsing_code","const nav = document.querySelector('nav.sidebar_brwN');\r\nconst result = {};\r\n\r\nlet currentYear = null;\r\n\r\nnav.querySelectorAll('ul.sidebarItemList_QwSx > *').forEach(el => {\r\n if (el.tagName === 'H5') {\r\n // Update current year when encountering an

\r\n currentYear = el.textContent.trim();\r\n if (!result[currentYear]) {\r\n result[currentYear] = [];\r\n }\r\n } else if (el.tagName === 'LI') {\r\n const a = el.querySelector('a[href*=\"/blog/\"]');\r\n if (a) {\r\n // Extract year, month, day from the href\r\n const match = a.getAttribute('href').match(/\\/blog\\/(\\d{4})\\/(\\d{2})\\/(\\d{2})/);\r\n if (match) {\r\n const [_, year, month, day] = match;\r\n result[currentYear].push({\r\n year,\r\n month,\r\n day,\r\n title: a.textContent.trim(),\r\n url: a.href\r\n });\r\n }\r\n }\r\n }\r\n});\r\n\r\nconsole.log(result);",{"_8":19,"_2790":2796,"_2445":2797,"_2793":-5},"https://lynxjs.org/blog","Lynx","reactNativeBlogContents",{"_2800":2792,"_2801":2802},"framework","data",{"_2803":2804,"_2828":2829,"_2882":2883,"_2932":2933,"_2981":2982,"_3020":3021,"_3038":3039,"_3085":3086,"_3133":3134,"_3159":3160,"_3181":3182},"2015",[2805,2816,2822],{"_2456":2803,"_2806":2807,"_2808":2809,"_36":2810,"_2811":2812,"_2813":2803,"_2814":2815,"_2800":2792},"month","11","day","23","Making React Native apps accessible","url","https://reactnative.dev/blog/2015/11/23/making-react-native-apps-accessible","yearKey","content","With the recent launch of React on web and React Native on mobile, we've provided a new front-end framework for developers to build products. One key aspect of building a robust product is ensuring that anyone can use it, including people who have vision loss or other disabilities. The Accessibility API for React and React Native enables you to make any React-powered experience usable by someone who may use assistive technology, like a screen reader for the blind and visually impaired.\nFor this post, we're going to focus on React Native apps. We've designed the React Accessibility API to look and feel similar to the Android and iOS APIs. If you've developed accessible applications for Android, iOS, or the web before, you should feel comfortable with the framework and nomenclature of the React AX API. For instance, you can make a UI element accessible (therefore exposed to assistive technology) and use accessibilityLabel to provide a string description for the element:\n\nLet's walk through a slightly more involved application of the React AX API by looking at one of Facebook's own React-powered products: the Ads Manager app.\nRead more\n\nThis is an excerpt. Read the rest of the post on Facebook Code.",{"_2456":2803,"_2806":2817,"_2808":2818,"_36":2819,"_2811":2820,"_2813":2803,"_2814":2821,"_2800":2792},"09","14","React Native for Android: How we built the first cross-platform React Native app","https://reactnative.dev/blog/2015/09/14/react-native-for-android","Earlier this year, we introduced React Native for iOS. React Native brings what developers are used to from React on the web — declarative self-contained UI components and fast development cycles — to the mobile platform, while retaining the speed, fidelity, and feel of native applications. Today, we're happy to release React Native for Android.\nAt Facebook we've been using React Native in production for over a year now. Almost exactly a year ago, our team set out to develop the Ads Manager app. Our goal was to create a new app to let the millions of people who advertise on Facebook manage their accounts and create new ads on the go. It ended up being not only Facebook's first fully React Native app but also the first cross-platform one. In this post, we'd like to share with you how we built this app, how React Native enabled us to move faster, and the lessons we learned.\nRead more\n\nThis is an excerpt. Read the rest of the post on Facebook Code.",{"_2456":2803,"_2806":2823,"_2808":2824,"_36":2825,"_2811":2826,"_2813":2803,"_2814":2827,"_2800":2792},"03","26","React Native: Bringing modern web techniques to mobile","https://reactnative.dev/blog/2015/03/26/react-native-bringing-modern-web-techniques-to-mobile","We introduced React to the world two years ago, and since then it's seen impressive growth, both inside and outside of Facebook. Today, even though no one is forced to use it, new web projects at Facebook are commonly built using React in one form or another, and it's being broadly adopted across the industry. Engineers are choosing to use React every day because it enables them to spend more time focusing on their products and less time fighting with their framework. It wasn't until we'd been building with React for a while, though, that we started to understand what makes it so powerful.\nReact forces us to break our applications down into discrete components, each representing a single view. These components make it easier to iterate on our products, since we don't need to keep the entire system in our head in order to make changes to one part of it. More important, though, React wraps the DOM's mutative, imperative API with a declarative one, which raises the level of abstraction and simplifies the programming model. What we've found is that when we build with React, our code is a lot more predictable. This predictability makes it so we can iterate more quickly with confidence, and our applications are a lot more reliable as a result. Additionally, it's not only easier to scale our applications when they're built with React, but we've found it's also easier to scale the size of our teams themselves.\nTogether with the rapid iteration cycle of the web, we've been able to build some awesome products with React, including many components of Facebook.com. Additionally, we've built amazing frameworks in JavaScript on top of React, like Relay, which allows us to greatly simplify our data fetching at scale. Of course, web is only part of the story. Facebook also has widely used Android and iOS apps, which are built on top of disjointed, proprietary technology stacks. Having to build our apps on top of multiple platforms has bifurcated our engineering organization, but that's only one of the things that makes native mobile application development hard.\nRead more\n\nThis is an excerpt. Read the rest of the post on Facebook Code.","2016",[2830,2835,2840,2845,2849,2855,2861,2867,2872,2877],{"_2456":2828,"_2806":2817,"_2808":2831,"_36":2832,"_2811":2833,"_2813":2828,"_2814":2834,"_2800":2792},"08","Expo Talks: Adam on Unraveling Navigation","https://reactnative.dev/blog/2016/09/08/exponent-talks-unraveling-navigation","Adam Miskiewicz from Expo talks about mobile navigation and the ex-navigation React Native library at Expo's office hours last week.",{"_2456":2828,"_2806":2831,"_2808":2836,"_36":2837,"_2811":2838,"_2813":2828,"_2814":2839,"_2800":2792},"12","San Francisco Meetup Recap","https://reactnative.dev/blog/2016/08/12/react-native-meetup-san-francisco","Last week I had the opportunity to attend the React Native Meetup at Zynga’s San Francisco office. With around 200 people in attendance, it served as a great place to meet other developers near me that are also interested in React Native.\n\nI was particularly interested in learning more about how React and React Native are used at companies like Zynga, Netflix, and Airbnb. The agenda for the night would be as follows:\n\nRapid Prototyping in React\nDesigning APIs for React Native\nBridging the Gap: Using React Native in Existing Codebases\n\nBut first, the event started off with a quick introduction and a brief recap of recent news:\n\nDid you know that React Native is now the top Java repository on GitHub?\nrnpm is now part of React Native core! You can now use react-native link in place of rnpm link to install libraries with native dependencies.\nThe React Native Meetup community is growing fast! There are now over 4,800 developers across a variety of React Native meetup groups all over the globe.\n\nIf one of these meetups is held near you, I highly recommend attending!\nRapid Prototyping in React at Zynga\nThe first round of news was followed by a quick introduction by Zynga, our hosts for the evening. Abhishek Chadha talked about how they use React to quickly prototype new experiences on mobile, demoing a quick prototype of a Draw Something-like app. They use a similar approach as React Native, providing access to native APIs via a bridge. This was demonstrated when Abhishek used the device's camera to snap a photo of the audience and then drew a hat on someone's head.\nDesigning APIs for React Native at Netflix\nUp next, the first featured talk of the evening. Clarence Leung, Senior Software Engineer at Netflix, presented his talk on Designing APIs for React Native. First he noted the two main types of libraries one may work on: components such as tab bars and date pickers, and libraries that provide access to native services such as the camera roll or in-app payments. There are two ways one may approach when building a library for use in React Native:\n\nProvide platform-specific components\nA cross-platform library with a similar API for both Android and iOS\n\nEach approach has its own considerations, and it’s up to you to determine what works best for your needs.\nApproach #1\nAs an example of platform-specific components, Clarence talked about the DatePickerIOS and DatePickerAndroid from core React Native. On iOS, date pickers are rendered as part of the UI and can be easily embedded in an existing view, while date pickers on Android are presented modally. It makes sense to provide separate components in this case.\nApproach #2\nPhoto pickers, on the other hand, are treated similarly on Android and iOS. There are some slight differences — Android does not group photos into folders like iOS does with Selfies, for example — but those are easily handled using if statements and the Platform component.\nRegardless of which approach you settle on, it’s a good idea to minimize the API surface and build app-specific libraries. For example, iOS’s In-App Purchase framework supports one-time, consumable purchases, as well as renewable subscriptions. If your app will only need to support consumable purchases, you may get away with dropping support for subscriptions in your cross-platform library.\n\nThere was a brief Q&A session at the end of Clarence’s talk. One of the interesting tid bits that came out of it was that around 80% of the React Native code written for these libraries at Netflix is shared across both Android and iOS.\nBridging the Gap, Using React Native in Existing Codebases\nThe final talk of the night was by Leland Richardson from Airbnb. The talk was focused on the use of React Native in existing codebases. I already know how easy it is to write a new app from scratch using React Native, so I was very interested to hear about Airbnb’s experience adopting React Native in their existing native apps.\nLeland started off by talking about greenfield apps versus brownfield apps. Greenfield means to start a project without the need to consider any prior work. This is in contrast to brownfield projects where you need to take into account the existing project’s requirements, development processes, and all of the teams various needs.\nWhen you’re working on a greenfield app, the React Native CLI sets up a single repository for both Android and iOS and everything just works. The first challenge against using React Native at Airbnb was the fact that the Android and iOS app each had their own repository. Multi-repo companies have some hurdles to get past before they can adopt React Native.\nTo get around this, Airbnb first set up a new repo for the React Native codebase. They used their continuous integration servers to mirror the Android and iOS repos into this new repo. After tests are run and the bundle is built, the build artifacts are synced back to the Android and iOS repos. This allows the mobile engineers to work on native code without altering their development environment. Mobile engineers don't need to install npm, run the packager, or remember to build the JavaScript bundle. The engineers writing actual React Native code do not have to worry about syncing their code across Android and iOS, as they work on the React Native repository directly.\nThis does come with some drawbacks, mainly they could not ship atomic updates. Changes that require a combination of native and JavaScript code would require three separate pull requests, all of which had to be carefully landed. In order to avoid conflicts, CI will fail to land changes back to the Android and iOS repos if master has changed since the build started. This would cause long delays during high commit frequency days (such as when new releases are cut).\nAirbnb has since moved to a mono repo approach. Fortunately this was already under consideration, and once the Android and iOS teams became comfortable with using React Native they were happy to accelerate the move towards the mono repo.\nThis has solved most of the issues they had with the split repo approach. Leland did note that this does cause a higher strain on the version control servers, which may be an issue for smaller companies.\n\nThe Navigation Problem\nThe second half of Leland's talk focused on a topic that is dear to me: the Navigation problem in React Native. He talked about the abundance of navigation libraries in React Native, both first party and third party. NavigationExperimental was mentioned as something that seemed promising, but ended up not being well suited for their use case.\nIn fact, none of the existing navigation libraries seem to work well for brownfield apps. A brownfield app requires that the navigation state be fully owned by the native app. For example, if a user’s session expires while a React Native view is being presented, the native app should be able to take over and present a login screen as needed.\nAirbnb also wanted to avoid replacing native navigation bars with JavaScript versions as part of a transition, as the effect could be jarring. Initially they limited themselves to modally presented views, but this obviously presented a problem when it came to adopting React Native more widely within their apps.\nThey decided that they needed their own library. The library is called airbnb-navigation. The library has not yet being open sourced as it is strongly tied to Airbnb’s codebase, but it is something they’d like to release by the end of the year.\nI won’t go into much detail into the library’s API, but here are some of the key takeaways:\n\nOne must preregister scenes ahead of time\nEach scene is displayed within its own RCTRootView. They are presented natively on each platform (e.g. UINavigationControllers are used on iOS).\nThe main ScrollView in a scene should be wrapped in a ScrollScene component. Doing so allows you to take advantage of native behaviors such as tapping on the status bar to scroll to the top on iOS.\nTransitions between scenes are handled natively, no need to worry about performance.\nThe Android back button is automatically supported.\nThey can take advantage of View Controller based navigation bar styling via a Navigator.Config UI-less component.\n\nThere’s also some considerations to keep in mind:\n\nThe navigation bar is not easily customized in JavaScript, as it is a native component. This is intentional, as using native navigation bars is a hard requirement for this type of library.\nScreenProps must be serialized/de-serialized whenever they're sent through the bridge, so care must be taken if sending too much data here.\nNavigation state is owned by the native app (also a hard requirement for the library), so things like Redux cannot manipulate navigation state.\n\nLeland's talk was also followed by a Q&A session. Overall, Airbnb is satisfied with React Native. They’re interested in using Code Push to fix any issues without going through the App Store, and their engineers love Live Reload, as they don't have to wait for the native app to be rebuilt after every minor change.\nClosing Remarks\nThe event ended with some additional React Native news:\n\nDeco announced their React Native Showcase, and invited everyone to add their app to the list.\nThe recent documentation overhaul got a shoutout!\nDevin Abbott, one of the creators of Deco IDE, will be teaching an introductory React Native course.\n\n\nMeetups provide a good opportunity to meet and learn from other developers in the community. I'm looking forward to attending more React Native meetups in the future. If you make it up to one of these, please look out for me and let me know how we can make React Native work better for you!",{"_2456":2828,"_2806":2823,"_2808":2841,"_36":2842,"_2811":2843,"_2813":2828,"_2814":2844,"_2800":2792},"28","Dive into React Native Performance","https://reactnative.dev/blog/2016/03/28/dive-into-react-native-performance","React Native allows you to build Android and iOS apps in JavaScript using React and Relay's declarative programming model. This leads to more concise, easier-to-understand code; fast iteration without a compile cycle; and easy sharing of code across multiple platforms. You can ship faster and focus on details that really matter, making your app look and feel fantastic. Optimizing performance is a big part of this. Here is the story of how we made React Native app startup twice as fast.\nWhy the hurry?\nWith an app that runs faster, content loads quickly, which means people get more time to interact with it, and smooth animations make the app enjoyable to use. In emerging markets, where 2011 class phones on 2G networks are the majority, a focus on performance can make the difference between an app that is usable and one that isn't.\nSince releasing React Native on iOS and on Android, we have been improving list view scrolling performance, memory efficiency, UI responsiveness, and app startup time. Startup sets the first impression of an app and stresses all parts of the framework, so it is the most rewarding and challenging problem to tackle.\nRead more\n\nThis is an excerpt. Read the rest of the post on Facebook Code.",{"_2456":2828,"_2806":2807,"_2808":2831,"_36":2846,"_2811":2847,"_2813":2828,"_2814":2848,"_2800":2792},"Introducing Button, Faster Installs with Yarn, and a Public Roadmap","https://reactnative.dev/blog/2016/11/08/introducing-button-yarn-and-a-public-roadmap","We have heard from many people that there is so much work happening with React Native, it can be tough to keep track of what's going on. To help communicate what work is in progress, we are now publishing a roadmap for React Native. At a high level, this work can be broken down into three priorities:\n\nCore Libraries. Adding more functionality to the most useful components and APIs.\nStability. Improve the underlying infrastructure to reduce bugs and improve code quality.\nDeveloper Experience. Help React Native developers move faster\n\nIf you have suggestions for features that you think would be valuable on the roadmap, check out Canny, where you can suggest new features and discuss existing proposals.\nWhat's new in React Native\nVersion 0.37 of React Native, released today, introduces a new core component to make it really easy to add a touchable Button to any app. We're also introducing support for the new Yarn package manager, which should speed up the whole process of updating your app's dependencies.\nIntroducing Button\nToday we're introducing a basic

Mobile

Youtube

Flutter62 VideosLast updated at Oct 8, 2025(2 days ago)

Android60 VideosLast updated at Sep 30, 2025(10 days ago)

Android Developers131 VideosLast updated at Oct 7, 2025(3 days ago)

Apple Developer53 VideosLast updated at Oct 3, 2025(7 days ago)

Medium

Flutter19 ArticlesLast updated at Oct 8, 2025(2 days ago)

Swift Programming10 ArticlesLast updated at May 2, 2020(5 years ago)

Android Developers18 ArticlesLast updated at Aug 6, 2025(2 months ago)

Official Blog

React Native89 Articles Last updated at October 8, 2025(2 days ago)

Lynx5 Articles Last updated at December 25, 2024(9 months ago)