Posted by Daniel Trócoli Head of Play Partnerships for Games - LATAM
In 2022, we first launched the Indie Games Fund in Latin America as part of our commitment to helping developers of all sizes grow on Google Play. Check out the 10 selected studios who received a share of the fund last year.
Today, we’re bringing back the Indie Games Fund for 2023. We will award $2 million dollars in non-dilutive cash awards in addition to hands-on support, to selected small games studios based in Latin America, helping them build and grow their businesses on our platform.
The program is open to indie game developers who have already launched a game - whether it’s on Google Play or another mobile platform, PC or console. Each selected recipient will get between $150,000 and $200,000 dollars to help them take their game to the next level, and build successful businesses.
Check out all eligibility criteria and apply now. Applications close at 12:00pm BRT September 1, 2023. Priority will be given to applications received by 12:00pm BRT August 16, 2023.
Posted by Márton Braun, Developer Relations Engineer
The Kotlin compiler is being rewritten for Kotlin 2.0. The new compiler implementation–codenamed K2–brings with it significant build speed improvements, compiling Kotlin code up to twice as fast as the original compiler. It also has a more flexible architecture that will enable the introduction of new language features after 2.0.
Try the new compiler
With Kotlin 1.9, K2 is now available in Beta for JVM targets, including Android projects. To help stabilize the new compiler and make sure you’re ready for Kotlin 2.0, we encourage you to try compiling your projects with the new compiler. If you run into any issues, you can report them on the Kotlin issue tracker.
To try the new compiler, update to Kotlin 1.9 and add the following to your project’s gradle.properties file:
kotlin.experimental.tryK2=true
Note that the new compiler should not be used for production builds yet. A good approach for trying it early is to create a separate branch in your project for compiling with K2. You can find an example of this in the Now in Android repository.
Tooling support
Plugins and tools that depend on the Kotlin compiler frontend will also have to be updated to add support for K2. Some tools already have experimental support for building with K2: the Jetpack Compose compiler plugin supports K2 starting in 1.5.0, which is compatible with Kotlin 1.9.
Android Lint also supports K2 starting in version 8.2.0-alpha12. To run Lint on K2, upgrade to this version and add android.lint.useK2Uast=true to your gradle.properties file. Note that any custom lint rules that rely on APIs from the old frontend will have to be updated to use the analysis API instead.
Adding K2 support in other tools is still in progress: KSP and KAPT tasks currently fall back to using the old compiler when building your project with K2. However, compilation tasks can still run using K2 when these tools are used.
Android Studio also relies on the Kotlin compiler for code analysis. Until Android Studio has support for K2, building with K2 might result in some discrepancies between the code analysis of the IDE and command line builds in certain edge cases.
If you use any additional compiler plugins, check their documentation to see whether they are compatible with K2 yet.
Get started with the K2 compiler today
The Kotlin 2.0 Compiler offers significant improvements to help you ship updates faster, be more productive, and spend more time focusing on what makes your app unique.
It already works with Jetpack Compose and we have a roadmap to improve support in other tools, including Android Studio, KSP, and compiler plugins. Now is a great time to try it in your app's codebase and provide feedback related to Kotlin, Compose, or Lint.
Today, we are excited to announce the beta release of Credential Manager with a finalized API surface, making it suitable for use in production. As we previously announced, Credential Manager is a new Jetpack library that allows app developers to simplify their users' authentication journey, while also increasing security with support of passkeys.
Authentication provides secure access to personalized experiences, but it has challenges. Passwords, which are widely used today, are difficult to use, remember and are not always secure. Many applications and services require two-factor authentication (2FA) to login, adding more friction to the user's flow. Lastly, sign-in methods have proliferated, making it difficult for users to remember how they signed in. This proliferation has also added complexity for developers, who now need to support multiple integrations and APIs.
Credential Manager brings support for passkeys, a new passwordless authentication mechanism, together with traditional sign-in methods, such as passwords and federated sign-in, into a single interface for the user and a unified API for developers.
End-to-end journey to sign in using a passkey
With Credential Manager, users will benefit from seeing all their credentials in one place; passkeys, passwords and federated credentials (such as Sign in with Google), without needing to tap three different places. This reduces user confusion and simplifies choices when logging in.
Unified account selector that support multiple credential types across multiple accounts
Credential Manager also makes the login experience simpler by deduping across sign-in methods for the same account and surfacing only the safest and simplest authentication method, further reducing the number of choices users need to make. So, if a user has a password and a passkey for a single account, they won’t need to decide between them when signing in; rather, the system will propose using the passkey - the safest and simplest option. That way, users can focus on choosing the right account instead of the underlying technology.
A passkey and a password for the same account are deduped
For developers, Credential Manager supports multiple sign-in mechanisms within a single API. It provides support for passkeys on Android apps, enabling the transition to a passwordless future. And at the same time, it also supports passwords and federated sign in like Sign in With Google, simplifying integration requirements and ongoing maintenance.
Who is already using Credential Manager?
Kayak has already integrated with Credential Manager, providing users with the advantages of passkeys and simpler authentication flows.
"Passkeys make creating an account lightning fast by removing the need for password creation or navigating to a separate app to get a link or code. As a bonus, implementing the new Credential Manager library also reduced technical debt in our code base by putting passkeys, passwords and Google sign-in all into one new modern UI. Indeed, users are able to sign up to Kayak with passkeys twice as fast as with an email link, which also improves the sign-in completion rate."
– Matthias Keller, Chief Scientist and SVP, Technology at Kayak
Something similar is observed on Shopify.
“Passkeys work across browsers and our mobile app, so it was a no-brainer decision for our team to implement, and the resulting one-tap user experience has been truly magical. Buyers who are using passkeys to log in to Shop are doing so 14% faster than those who are using other login methods (such as email or SMS verification)”
– Mathieu Perreault, Director of Engineering at Shopify
Support for multiple password managers
Credential Manager on Android 14 and higher supports multiple password managers at the same time, enabling users to choose the provider of their choice to store, sync and manage their credentials. We are excited to be working with several leading providers like Dashlane on their integration with Credential Manager.
“Adopting passkeys was a no-brainer for us. It simplifies sign-ins, replaces the guesswork of traditional authentication methods with a reliable standard, and helps our users ditch the downsides of passwords. Simply put, it’s a big win for both us and our users. Dashlane is ready to serve passkeys on Android 14!”
– Rew Islam, Director of Product Engineering and Innovation at Dashlane
Get started
To start using Credential Manager, you can refer to our integration guide.
We'd love to hear your input during this beta release, so please let us know about your experience integrating with Credential Manager, using passkeys, or any other feedback you might have:
From foldable innovations to seamless connectivity, Google and Samsung have continued to work together to create helpful experiences across Android phones, tablets, smartwatches and more. Today at Galaxy Unpacked in Seoul, Samsung unveiled the new Galaxy Z Flip5 and Z Fold5, Galaxy Watch6 series, and Galaxy Tab S9 series.
With these new devices from Samsung, there are four more reasons to ensure your app looks great across all your user’s favorite screens. Here are three ways you can ensure your app is ready for these great new Samsung devices:
1. Provide a great foldable experience
The launch of the new Galaxy Z Flip5 and Z Fold5 brings two brand new foldables to the Android ecosystem, so it is important to provide experiences that have fully adaptive UIs. The bottom line is that layout and app behavior should be based on device configuration and available features, and not the physical type of the device.
When it comes to providing a great foldable experience, here are a few of our top recommendations:
Use window size classes to guide layout decisions based on your current windowing state using opinionated breakpoints that are derived from common device types.
Observe folding features with Jetpack WindowManager, which provides the set of folding features that intersect your app's current window.
Make dynamic, runtime decisions based on whether a feature is available, instead of assuming that a feature is or is not available for a certain kind of device.
Referring in the UI to the user’s device as simply a “device” covers all form factors and is the simplest to implement. However, differentiating between the multiple devices a user may have provides a more polished experience and enables you to display the type of the device to the user using heuristics relevant to your particular use case.
You can learn more about how (and why) to implement the recommendations above in this detailed blog and, to find best practices for updating your app, check out the Support different screen sizes page.
2. Design with multi-device experiences in mind
With new devices, big and small, it is important to think through the user experience you hope to accomplish. A large part of that is the UI and design of your app – with specific consideration to account for based on screen sizes and types.
Ensuring your app looks great on large screens is a critical part of your users’ experience. Material You supports beautiful, efficient tablet and foldable experiences – and, at Google I/O this year, the team dove into the latest updates to large screen guidelines for designers and developers. You can also get inspired with the latest design guidance and mockup in check out the Large Screens Gallery.
To help with the challenges of designing and building great watch experiences that work for all, we created ourthe Wear OS Gallery This blog and the series of videos that accompany it are built to get you started designing inclusive smartwatch apps. For even more information on beautiful smartwatch design, discover the new Wear OS Gallery where you can find general design tips, verticalized use cases, and implementation ideas.
3. Get ready for Wear OS 4
The next generation of Wear OS is here! The Galaxy Watch6 series comes with the newest version of Google’s smartwatch platform, Wear OS 4. This platform update is also coming soon to other Samsung Galaxy watches, including the Watch4 and Watch5.
Wear OS 4 is based on Android 13, which is several versions newer than the current Wear OS version, so your app will need to handle the system behavior changes that took effect in Android 12 and Android 13. We recommend you start by testing your app and releasing a compatible update first – as devices get upgraded to Wear OS 4, it’s a basic but a critical level of quality that provides a good app experience for users.
Download the Wear OS 4 emulator in Android Studio Hedgehog to explore new features and test your app on Wear OS 4 Developer Preview.
The release of Wear OS 4 comes with many exciting changes – including a new way to build watchfaces.
The new Watch Face Format is a declarative XML format that allows you to configure the appearance and behavior of watch faces. This means that there's no executable code involved in creating a watch face, and there's no code embedded in your watch face APK. The Wear OS platform takes care of the logic needed to render the watch face so you can focus on your creative ideas, rather than code optimizations or battery performance.
Get started with watch faces using our documentation or create your own watch face with Samsung’s Watch Face Studio design tool.
Get started building a multi-device experience today!
With all the amazing additions to the Android ecosystem coming from Galaxy Unpacked, there has never been a better time to be sure your app looks great on all the devices your users know and love - from tablets to foldables to watches.
Learn more about building multi-device experiences from Deezer, where they increased their monthly active users 4X after improving multi-device support. Then get started with Jetpack WindowManager to help you build a responsive app for large screens by checking out the documentation and sample app. Finally, get to know Wear OS 4 and try it out with your app!
Deezer is a global music streaming platform that provides users access to over 110 million tracks. Deezer aims to make its application easily accessible, letting users listen to their audio when, where, and how they want. With the growing popularity of Wear OS devices and large screens and foldables, the Deezer team saw an opportunity to give its users more ways to stream by enhancing its multi-device support.
Increasing smart watch support
Over the past few years, users increasingly requested Deezer to make its app available on Wear OS. During this time, the Deezer team had also seen rapid growth in the wearable market.
“The Wear OS market was growing thanks to the Fitbit acquisition by Google, the Pixel watch announcement, and the switch to Wear OS on Galaxy watches,” said Hugo Vignaux, a senior product manager at Deezer. “It was perfect timing because Google raised the opportunity with us to invest in Wear OS by joining the Media Experience Program in 2022.”
Deezer’s developers initially focused on providing instant, easy access to users’ personalized playlists from the application. To do this, engineers streamlined the app’s Wear OS UI, making it easier for users to control the app from their wrist. They also implemented a feature that allowed users to download their favorite Deezer playlists straight to their smartwatches, making offline playback possible without requiring a phone or an internet connection.
The Deezer team relied on Google’s Horologist and its Media Toolkit during development. Horologist and its libraries guided the team and ensured updates to the UI adhered to Wear best practices. It also made rolling out features like audio and bluetooth management much easier.
“The player view offered by the Media Toolkit was a source of inspiration and guaranteed that the app’s code quality was up to par,” said Hugo. “It also allowed us to focus on unit testing and resiliency rather than developing new features from scratch.”
More support for large screens and foldables
Before updating the app, Deezer’s UX wasn’t fully optimized for large screens and foldables. With this latest update, Deezer developers created special layouts for multitasking on large screens, like tablets and laptops, and used resizable emulators to optimize the app’s resizing capabilities for each screen on foldables.
“Supporting large screens means we can better fit multiple windows on a screen,” said Geoffrey Métais, engineering manager at Deezer. “This allows users to easily switch between apps, which is good because Deezer doesn’t require a user's full attention for them to make use of its UI.”
On tablets, Deezer developers split pages that were displayed vertically to be displayed horizontally. Developers also implemented a navigation rail and turned some lists into grids. These simple quality-of-life updates improved UX by giving users an easier way to click through the app.
Making these changes was easy for developers thanks to the Jetpack WindowManager library. “The WindowManager library made it simple to adapt our UI to different screen sizes,” said Geoffrey. “It leverages Jetpack Compose’s modularity to adapt to any screen size. And Compose code stays simple and consistent despite addressing a variety of different configurations.”
Updates to large screens and foldables and Wear OS were all created using Jetpack Compose and Compose for Wear OS, respectively. With Jetpack Compose, Deezer developers were able to efficiently create and implement a design system that focused on technical issues within the new app. The Deezer team attributes their increased productivity with Compose to Composable functions, which lets developers reuse code segments, and Android Studio, which helps developers iterate on features faster.
“The combination of a proper Design System with Jetpack Compose’s modularity and reactive paradigms is a very smart and efficient solution to improve usability without losing development productivity,” said Geoffrey.
The impact of increased multi-device support
Increasing multi-device support was easy for Deezer developers thanks to the tools and resources offered by Google. The updates the Deezer team made across screens improved the app’s UI, making it easier for users to navigate the app and listen to audio on their own terms.
Since updating for Wear OS and other Android devices, the Deezer team saw a 4X increase in user engagement and received positive feedback from its community.
“Developing for WearOS and across devices was great thanks to the help of the Google team and the availability of libraries and APIs that helped us deliver some great features, such as Horologist and its Media Toolkit. All those technical assets were very well documented and the Google team’s dedication was tremendous,” said Hugo.
Posted by Allison Chang, Product Manager, Google Play
Last year at Google I/O, we shared some big changes coming to the Play Store for large screen devices. Since then, we’ve seen even more people using large screens for work and play, across millions of active Android devices. Apps and games play a critical role in shaping the on-device experience, so we’ve redesigned the Play Store to help users get the most from their tablets, Chromebooks, and foldables.
Today, we’re introducing four major updates to help users find high-quality large screen apps on Play: refreshed app listing pages, ranking and quality improvements, streamlined store navigation, and a split-screen search experience.
1. Refreshed app listing pages for high-quality apps
Your store listing page is the best way to demonstrate the functionality and value of your app, so we’ve revamped the experience to put your content front and center. Games with high-quality videos will show a video banner at the top of their app listing page, allowing users to get a sense of gameplay in an immersive way. We've also reorganized apps and games details pages in a multi-column layout, bringing more of your content higher up the page.
2. Ranking and quality improvements
To promote high-quality apps that shine on large screens, we’ve made several ranking changes to boost quality across Play. Apps and games that adhere to our large screen app quality guidelines will now be ranked higher in search and Apps and Games Home. This helps users find apps that resize well, aren't letterboxed, and support both portrait and landscape orientations. Editors’ Choice and other curated collections and articles will also consider these criteria going forward, creating new featuring opportunities for optimized apps.
Last year, we also announced app listing warnings and reduced visibility for apps and games that do not meet Play’s per-device technical quality bar. This extends our phone technical quality requirements for phones to large screens, and affects apps and games with an 8% user-perceived crash rate or 8% user-perceived ANR rate on the user’s device.
These warnings will appear on your app details page, with the goal of setting user expectations for how apps will look and function on their devices. We’ll begin rolling out these changes in late August, so there’s still time to use Android vitals in Play Console or the reporting API to monitor and improve your app’s stability metrics.
Finally, to help users better understand the in-app experience up front, we are increasingly featuring your store listing assets directly on Apps and Games Home.
New content forward formats will use form factor specific screenshots, videos, and descriptions to display a preview of the app experience and help users make install decisions. As part of this change, apps with large screen assets that follow our content quality guidelines can take advantage of these richer formats, and will occupy more screen real estate on Play homepages. As you audit your large screen assets, here are some best practices to help your app stand out:
Upload separate screenshots for each form factor. Demonstrate the actual in-app or in-game experience, focusing on the core features and content so users can anticipate what the app or game experience will be like.
Use high-quality images with the proper aspect ratio.
Avoid overloading screenshots with text or time-sensitive copy that requires frequent updates.
We don’t recommend including device imagery, as this can become obsolete quickly or alienate some user groups.
For more tips and guidelines to building high quality apps, visit our quality hub.
3. Streamlined store navigation
For more seamless browsing, we’ve simplified our store navigation and moved to a left-side navigation rail on larger screens. This puts menu items closer to users’ thumbs and makes them more accessible, especially when holding a device in landscape mode.
We’ve also made certain aspects of the store easier to find to help users discover useful and popular apps. For example, we’ve moved the Top Charts and Categories sections to Apps and Games Home. On tablets and Chromebooks, we’ve made the Kids experience a primary tab, since these devices are often shared with children.
4. Split-screen search
Lastly, we’re excited to announce a new search experience that makes it easy to discover and compare apps from within the search results page.
We’re launching a split-screen search experience on large screens, displaying search results and app details pages side by side. This prevents users from switching back and forth when exploring new apps and streamlines the discovery process.
These changes will begin rolling out over the coming weeks, and are just the beginning of our journey in creating a tailored Play Store experience for large screens. For more inspiration and examples of high-quality large screen apps, visit our app design gallery or check out our recent session on app quality from Google I/O.
Posted by Alan Leung, Staff Software Engineer, Fabien Sanglard, Senior Software Engineer, Juan Sebastian Oviedo, Senior Product Manager
A closeup look into how the Android Studio team built Live Edit; a feature that accelerates the Compose development process by continuously updating the running application as code changes are made.
What’s Live Edit and how can it help me?
Live Edit introduces a new way to edit your app’s Jetpack Compose UI by instantly deploying code changes to the running application on a physical device or emulator. This means that you can make changes to your app’s UI and immediately see their effect on the running application, enabling you to iterate faster and be more productive in your development. Live Edit was recently released to the stable channel with Android Studio Giraffe and can be enabled in the Editor settings. Developers like Plex and Pocket Casts are already using Live Edit and it has accelerated their development process for Compose UI. It is also helping them in the process of migrating from XML views to Compose.
Live Edit in action on Android Studio Hedgehog
When should I use Live Edit?
Live Edit is a different feature from Compose Preview and Apply Changes. These features provide value in different ways:
[Kotlin only, supports live recomposition] Make changes to your Compose app’s UI and immediately see their effect on the running application on an emulator or physical device.
Quickly see the effect of updates to UX elements (such as modifier updates and animations) on the overall app experience while the application is running.
Deploy code and resource updates to a running app without restarting it—and, in some cases, without restarting the current activity.
Update code and resources in a non-Compose app without having to redeploy it to an emulator or physical device.
How does it work?
At a high level, Live Edit does the following:
Detects source code changes.
Compiles classes that were updated.
Pushes new classes to the device.
Adds a hook in each class method bytecode to redirect calls to the new bytecode.
Edits the app classpath to ensure changes persist even if the app is restarted.
Live Edit architecture
Keystroke detection
This step is handled via the Intellij IDEA Program Structure Interface (PSI) tree. Listeners allow LE to detect the moment a developer makes a change in the Android Studio editor.
Compilation
Fundamentally, Live Edit still relies on the Kotlin compiler to generate code for each incremental change.
Our goal was to create a system where there is less than 250ms latency between the last keystroke and the moment the recomposition happens on the device. Doing a typical incremental build or invoking an external compiler in a traditional sense would not achieve our performance requirement. Instead, Live Edit leverages Android Studio’s tight integration with the Kotlin compiler.
On the highest level, the Kotlin compiler’s compilation can be divided into two stages.
Analysis
Code generation
The analysis performed as the first step is not entirely restricted to a build process. In fact, the same step is frequently done outside the build system as part of an IDE. From basic syntax checking to auto-complete suggestions, the IDE is constantly performing the same analysis (Step 1 of Diagram 1) and caching the result to provide Kotlin- and Compose-specific functionality to the developer. Our experiment shows that the majority of the compilation time is spent in the analysis stage during build. Live Edit uses that information to invoke the Compose compiler. This allows compilation to happen within 200ms using typical laptops used by developers. Live Edit further optimizes the code generation process and focuses solely on generating code that is only necessary to update the application.
The result is a plain .class file (not a .dex file) that is passed to the next step in the pipeline, desugaring.
How to desugar
When Android app source code is processed by the build system, it is usually “desugared” after it is compiled. This transformation step lets an app run on a set of Android versions devoid of syntactic sugar support and recent API features. This allows developers to use new APIs in their app while still making it available to devices that run older versions of Android.
There are two kinds of desugaring, known as language desugaring and library desugaring. Both of these transformations are performed by R8. To make sure the injected bytecode will match what is currently running on the device, Live Edit must make sure each class file is desugared in a way that is compatible with the desugaring done by the build system.
Language desugaring:
This type of bytecode rewrite aims to provide newer language features for lower targeted API level devices. The goal is to support language features such as the default interface method, lambda expression, method reference, and so on, allowing support down to the min API level. This value is extracted from the .apk file's DEX files using markers left in there by R8.
API desugaring:
Also known as library desugaring, this form of desugaring aims to support JAVA SDK methods and classes. This is configured by a JSON file. Among other things, method call sites are rewritten to target functions located in the desugar library (which is also embedded in the app, in a DEX file). To perform this step, Gradle collaborates with Live Edit by providing the JSON file used during library desugaring.
Function trampoline
To facilitate a rapid “per-key-stroke” speed update to a running application, we decided to not constantly utilize the JVMTI codeswap ability of the Android Runtime (ART) for every single edit. Instead, JVMTI is only used once to perform a code swap that installs trampolines onto a subset of methods within the soon-to-be modified classes inside the VMs. Utilizing something we called the “Primer” (Step 3 of Diagram 1), invocation of the methods is redirected to a specialized interpreter. When the application no longer sees updates for a period of time, Live Edit will replace the code with traditional DEX code for performance benefits of ART. This saves developers time by immediately updating the running application as code changes are made.
Function trampoline process
How code is interpreted
Live Edit compiles code on the fly. The resulting .class files are pushed, trampolined (as previously described), and then interpreted on the device. This interpretation is performed by the LiveEditInterpreter. The interpreter is not a full VM inside ART. It is a Frame interpreter built on top of ASM Frame. ASM Frame handles the low level logistics such as the stack/local variables's push/load, but it needs an Interpreter to actually execute opcode. This is what the OpcodeInterpreter is for.
Live Edit interpretation flow
Live Edit Interpreter is a simple loop which drives ASM/Interpreter opcodes interpretation.
Some JVM instructions cannot be implemented using a pure Java interpreter (in particular invokeSpecial and monitorEnter/Exit are problematic). For these, Live Edit uses JNI.
Dealing with lambdas
Lambdas are handled in a different manner because changes to lambda captures can result in changes in VM classes that are different in many method signatures. Instead, new lambda-related updates are sent to the running device and loaded as new classes instead of redefining any existing loaded classes as described in the previous section.
How does recomposition work?
Developers wanted a seamless and frictionless new approach to program Android applications. A key part of the Live Edit experience is the ability to see the application updated while the developer continuously writes code, without having to explicitly trigger a re-run with a button press. We needed a UI framework that has the ability to listen to model changes within the application and perform optimal redraws accordingly. Luckily, Jetpack Compose fits this task perfectly. With Live Edit, we added an extra dimension to the reactive programming paradigm where the framework also observes changes to the functions’ code.
To facilitate code modification monitoring, the Jetpack Compose compiler supplies Android Studio with a mapping of function elements to a set of recomposition group keys. The attached JVMTI agent invalidates the Compose state of a changed function in an asynchronous manner and the Compose runtime performs recomposition on Composables that are invalidated.
How we handle runtime errors during recomposition
Live Edit handling a runtime error
While the concept of a continuously updating application is rather exhilarating, our field studies showed that sometimes when developers are writing code, the program can be in an incomplete state where updating and re-executing certain functions would lead to undesirable results. Besides the automatic mode where updates are happening almost continuously, we have introduced two manual modes for the developer who wants a bit more control on when the application gets updated after new code is detected.
Even with that in mind, we want to make sure common issues caused by executing incomplete functions do not cause the application to terminate prematurely. Cases where a loop’s exit condition is still being written are detected by Live Edit to avoid an infinite loop within the program. Also, if a Live Edit update triggers recomposition and causes a runtime exception to be thrown, the Compose runtime will catch such an exception and recompose using the last known good state.
Consider the following piece of code:
var x = y / 10
Suppose the developer would like to change 10 to 50 by deleting the character 1 and inserting character 5 after. Android Studio could potentially update the application before the 5 is inserted and thus create a division-by-zero ArithmeticException. However, with the added error handling mentioned, the application would simply revert to “y / 10” until further updates are done in the editor.
What’s coming?
The Android Studio team believes Live Edit will change how UI code is written in a positive way and we are committed to continuously improve the Live Edit development experience. We are working on expanding the types of edits developers can perform. Furthermore, future versions of Live Edit will eliminate the need to invalidate the whole application during certain scenarios.
Additionally, PSI event detection comes with limitations such as when the user edits import statements. To solve this problem, future versions of Live Edit will rely on .class diffing to detect changes. Lastly, the full persisting functionality isn't currently available. Future versions of Live Edit will allow the application to be restarted outside of Android Studio and retain the Live Edit changes.
Get started with Live Edit
Live Edit is ready to be used in production and we hope it can greatly improve your experience developing for Android, especially for UI-heavy iterations. We would love to hear more about your interesting use cases, best practices and bug reports and suggestions.
Java is a trademark or registered trademark of Oracle and/or its affiliates.
Today, we are thrilled to announce the stable release of Android Studio Giraffe 🦒 : The official IDE for building Android apps!
In this Android Studio release, we have upgraded the IntelliJ platform to 2022.3, including a brand new visual look and feel in Android Studio, improvements to Live Edit, Compose animation previews, a new Device Explorer, a new SDK upgrade assistant, ability to use Kotlin DSL in your Gradle build scripts and much more. Read on to learn more about how Android Studio Giraffe 🦒 can help supercharge your developer productivity.
Thank you to all of you who have given us feedback and used Android Studio since we launched our initial version just over 10 years ago. Download the latest stable version today and we look forward to continuing to deliver on our commitment of delivering a best-in-class integrated development environment (IDE) focused on Android app development!
IDE Enhancements
New UI for Android Studio (Preview)
Along with the much anticipated IntelliJ Platform update, we are excited to share a preview of the visual look that we call the “New UI” for Android Studio Giraffe. The redesigned theme aims to reduce visual complexity, provide easier access to essential features, and disclose complex functionality as needed—resulting in a modern, cleaner look and feel.
The New UI was first released as an early preview in IntelliJ 2022.2 to gather feedback from users and other IntelliJ-based IDEs to ensure it could fully replace the previous UI. Since then, it’s progressed to beta in IntelliJ 2022.3, with many bug fixes and improvements.
With the Giraffe release, we’ve started adopting the new UI, with several Android Studio specific changes, such as optimizing the default main toolbar and tool windows configurations for Android and refreshing our iconography in the style. We are excited by this new design direction and will continue adoption through the Hedgehog release and onward.
To use the New UI, enable it in Settings > Appearance & Behavior > New UI. For a full list of changes, see the IntelliJ New UI documentation.
The New UI adopted from IntelliJ
New diagnostic & bug reporting tool
As you try the New UI, please provide us detailed feedback through our new diagnostic & bug reporting tool that makes it easier to report bugs with relevant log files already attached. The new bug reporting tool is found at Help > Collect Logs and Diagnostic Data.
New diagnostic & bug reporting tool
Updated Device Explorer
Also shipping with the new UI, is an updated Device Explorer (known as the Device File Explorer in previous versions of Android Studio). In the Device Explorer, files and related actions are located in the Files tab. Additionally, in the new Processes tab, you can view a list of debuggable processes for the connected device. From there you can also select a process and perform a kill , force-stop, or attach the debugger to a given process.
Updated Device Explorer
Coding Productivity
Use Live Edit to update composables in real time
Live Edit lets you update composables in Android emulators and physical devices in near real time. You can now edit composables and see the UI changes on the running device without re-deploying your app.
This helps you by minimizing the context switching between writing and building your app, letting you focus on writing code longer without interruption. To try Live Edit, enable it via Settings > Editor > Live Edit and use Android Gradle Plugin (AGP) 8.1 or higher and Jetpack Compose Runtime 1.3.0 or higher.
Use Live Edit to update composables in real time
Compose Animation Preview - Extend animation support
Compose Animation Preview now supports a number of additional Compose APIs, such as animate*AsState, CrossFade, rememberInfiniteTransition, and AnimatedContent (in addition to updateTransition and AnimatedVisibility). Additionally, now there are new pickers that let you set non-enum or boolean states to debug your Compose animation using precise inputs. For all supported Compose Animation APIs, you can play, pause, scrub & control speed.
Compose Animation Preview - Extend animation support
Android SDK Upgrade Assistant
The new Android SDK upgrade assistant lets you see the steps required to upgrade the targetSdkVersion, or the API level that your app targets, directly in the IDE. It also pulls upgrade-related documentation directly from the Android Developer site into its tool window, so you don't have to jump back and forth between your browser and the IDE. For each migration step, it highlights the major breaking changes and how to address them, and even filters the full list of changes to only show steps relevant to your app.
To open the Android SDK Upgrade Assistant, go to Tools > Android SDK Upgrade Assistant.
Android SDK Upgrade Assistant
Improvements to the build system
Kotlin DSL in your Gradle build scripts
Kotlin is not only more readable, it also offers better compile-time checking and IDE support. With Android Studio Giraffe, we are excited to offer the official support for Kotlin DSL in your Gradle build scripts. This means that Kotlin is the default language used in your project code, including UI with Jetpack Compose, and now editing the build scripts too!
Now, when you are creating new projects or modules starting from Android Studio Giraffe, you get the Kotlin DSL by default. And if you want to migrate existing builds, check out the Kotlin DSL migration guide.
We've been working with the Gradle and JetBrains teams on this improvement, and you can read more in their related announcements: Gradle Blog; JetBrains Blog.
Additionally, we’ve also added experimental support for TOML-based Gradle Version Catalogs, a feature that lets you manage dependencies in one central location and share dependencies across modules or projects. Android Studio now makes it easier to configure version catalogs through editor suggestions and integrations with the Project Structure dialog, plus the New Project Wizard.
Kotlin DSL in your Gradle build scripts
Download info during Gradle sync
If you’ve ever wondered if any unexpected dependency downloads are negatively impacting your sync performance, the new Sync tool window now includes a summary of time spent downloading dependencies, and a detailed view of downloads per repository. This view updates live as sync takes place. It can even help you identify inefficiencies in how you configure your repositories.
Download info during Gradle sync
Automatic per-app language support
Typically, multilingual users set their system language to one language—such as English—but they want to select other languages for specific apps, such as Dutch, Chinese, or Hindi. Android 13 introduced support for per-app language preferences, and now Android Gradle plugin 8.1 and higher can configure your app to support it automatically based on your project’s resources. Learn more.
Make selected modules toolbar button
With Android Studio Giraffe, you can now build only the current module you're working on by selecting the Make Selected Modules build option in the toolbar. This new option lets you check that the code you just wrote compiles without building more than needed. Learn more.
Kotlin DSL in your Gradle build scripts
Summary
To recap, Android Studio Giraffe includes these new enhancements and features. You can always learn more with our detailed release notes.
IDE Enhancements
Upgraded to IntelliJ Platform 2022.3: Includes a number of features and bug fixes
New UI for Android Studio : Android Studio now adopts a number of improvements from the IntelliJ's modern design language
Updated Device Explorer : Offers two new tabs : Files & Processes from where you can view a list of debuggable processes, perform a kill, force-stop, or attach the debugger
New diagnostic & bug reporting tool : Easier to report bugs for Android Studio with relevant log files already attached
Coding Productivity
Use Live Edit to update composables in real time : Update composables in real time, edit composables and see the UI changes on the running device without re-deploying your app
Compose Animation Preview - Extend animation support : Now supports a number of additional Compose APIs and new pickers that let you set non-enum or boolean states to debug your Compose animation using precise inputs
Android SDK Upgrade Assistant : Now lets you see the steps required to upgrade the targetSdkVersion, or the API level that your app targets directly in Studio
Improvements to the build system
Kotlin DSL in your Gradle build scripts : With official support for Kotlin DSL in your Gradle build scripts, Kotlin is now the single default language for project code, UI with Jetpack Compose, and now for build scripts
Download info during Gradle sync : Shows a summary of time spent downloading dependencies and a detailed view of downloads per repository
Automatic per-app language support : AGP can now automatically configure per-app language preferences
Make selected modules toolbar button : build only the current module you're working on by selecting the Make Selected Modules build option in the toolbar
Download Android Studio Today!
Now is the time to download Android Studio Giraffe 🦒 to incorporate the new features into your workflow. As always, we appreciate any feedback on things you like and issues or features you would like to see. If you find a bug or issue, please file an issue and also check out known issues. Remember to also follow us on Twitter, Medium, or YouTube for more Android development updates!
Posted by Sarat Tummala, Product Manager, Google Play services
The Android KitKat (KK) platform was first released ~10 years ago and since then, we’ve introduced many innovative improvements and features for Android, which are unavailable on KK. As of July 2023, the active device count on KK is below 1% as more and more users update to the latest Android versions. Therefore, we are no longer supporting KK in future releases of Google Play services. KK devices will not receive versions of the Play Services APK beyond 23.30.99.
Posted by Sarat Tummala, Product Manager, Google Play services
The Android KitKat (KK) platform was first released ~10 years ago and since then, we’ve introduced many innovative improvements and features for Android, which are unavailable on KK. As of July 2023, the active device count on KK is below 1% as more and more users update to the latest Android versions. Therefore, we are no longer supporting KK in future releases of Google Play services. KK devices will not receive versions of the Play Services APK beyond 23.30.99.
Posted by Daniel Trócoli Head of Play Partnerships for Games - LATAM
Posted by Márton Braun, Developer Relations Engineer
Posted by 
.png)
.png)
.png)
Posted by the Android team
Posted by the Android team
Posted by Allison Chang, Product Manager, Google Play
Posted by Alan Leung, Staff Software Engineer, 
.png)
.png)
.png)
Posted by Mayank Jain, Product Manager
.gif)
Posted by Sarat Tummala, Product Manager, Google Play services
