ICYMI, Android Dev Summit returned last week after a four-year hiatus (Oct. 28–29), featuring over 50 sessions covering agentic development workflows (Android CLI, Agent Client Protocol support in Android Studio [i.e. Bring Your Own Agent], and declarative builds with Lightbuild), on-device and hybrid AI (Gemini Nano 4, Gemma 4, and Android MCP), our shift to a Compose-first UI architecture, and building across form factors like Googlebook and Android XR. If you couldn't make it out in person, the recorded session VODs are now live on YouTube so you can catch up on the talks relevant to your stack at your own pace—I've rounded up all of the links and descriptions by track below so everything is in one place.
Also worth noting if you'd rather skim or feed sessions straight into your coding workflow: the Android Dev Summit site is set up for agents this year:
📄 Download any talk as Markdown: Includes a summary, resource links, a speaker-labeled transcript, and code blocks in one file—drop a few into your agent and ask what changed for your app.
🗂️ Point an agent at one JSON feed: Structured metadata covering every session.
🧩 Grab theAgent Skills: Install the modular instruction sets each talk references.
If you're short on time and want to quickly catch up on the biggest announcements from ADS, start with the Android Dev Summit 2026 Keynote and check out these three recap posts on the Android Developers Blog:
Android is evolving into an intelligence system where agents like Gemini orchestrate tasks across apps. To unlock new user experiences and participate in these agentic workflows, your app must expose its core capabilities.
This session is a practical guide to integrating your app with Android's intelligence layer. We'll survey key integration paths - including on-device Android MCP, server-side MCP, and Task Automation - and provide a decision framework for choosing the right path for your use case. We'll also explore proactive experiences with Personal Context.
You will learn how to: * Select the optimal integration path for your app's needs. * Implement both reactive and proactive intelligence features. * Balance performance and security in agentic integrations.
Gemma 4 brings capable, multimodal AI directly to Android devices. In this session, we'll trace how Gemma evolved into a model family built for efficiency and explore what the edge-optimized E2B and E4B models can do on-device, from vision and audio understanding to agentic function calling. We'll cover the architecture behind that efficiency, including Per-Layer Embeddings (PLE), and show how Gemma and Gemini Nano work together through AICore. You'll learn how Quantization-Aware Training (QAT) preserves model capability within 1.1–3.5 GB RAM footprints, while Multi-Token Prediction (MTP) accelerates decoding speeds 1.5x–3x for responsive, real-time experiences.
In this session, we'll explore different GenAI use cases using ML Kit APIs to understand when on-device GenAI is ideal for an app and also understand how to evaluate existing GenAI use cases to see if on-device models can satisfy their quality bar.
Building production-ready generative AI into Android apps requires more than connecting to an LLM—it demands enterprise-grade security and cost controls. In this session, discover how Firebase AI Logic empowers developers to deploy secure, budget-conscious AI experiences at scale.
We will cover from security foundations and Firebase App Check, cost management, dynamic model routing to leveraging the multimodal capabilities.
Explore how to connect your applications seamlessly to Gemini, Search and the Android intelligence system.
The new Connected Apps Platform lets you integrate your app's services directly into Gemini, AI Mode in Search, and the Android intelligence system. This session provides a practical guide to getting started. Using code examples and learning from real-life case studies, we’ll walk through the development lifecycle: building, testing, and publishing your first connected app to reach users within their AI-powered workflows.
By the end of this session, you'll be able to: * Integrate your service with the Connected Apps Platform. * Test your integration across different AI surfaces. * Publish your app’s features into users' AI workflows.
Stop choosing between plug-and-play AI convenience and custom model flexibility—you can deploy both in a single, ultra-lean app without adding megabytes of binary bloat.
In this session, we’ll demonstrate how to build this exact dual-stack architecture in a single Android app. You’ll see how to leverage ML Kit for ready-to-use classical ML tasks (like doc scan) alongside LiteRT standalone in Play services for your custom computer vision or audio workloads. We’ll dive deep into how both implementation paths unite under the hood to utilize the modern LiteRT runtime, giving your app seamless, hardware-accelerated performance on CPU and GPUs with a virtually zero-byte download footprint.
Key takeaways for developers: * Uncompromised performance: Both turnkey and custom models are hardware-accelerated automatically using the unified CompiledModel API. * Micro-APKs: Dramatically reduce your app’s download size by offloading both the ML Kit and LiteRT runtimes to Play services. * Hybrid integration: Master running multiple ML workflows side-by-side in production without resource conflicts.
Take your Android AI features to the next level by building autonomous on-device agents. In this session, we dive into ML Kit’s new agentic APIs, built directly on top of the direct model access APIs you already know.
Using the open-source Jetpacker app, you’ll learn how to chain multi-step actions across local data, manage stateful multi-turn sessions with isolated contexts, and wire up Android MCP to power both in-app assistants and Android system-level surfaces with a single codebase.
While large frontier models dominate the headlines, small language models (SLMs) like Gemma 4 offer low-latency, cost-effective, and fully offline intelligence to augment daily developer workflows.
This talk explores practical patterns for integrating small models into Android development, from smart task routing to cost optimization, using Gemma 4 as our primary hands-on case study to demonstrate real-world use cases and how to configure developer tools and agentic workflows.
A2UI is transitioning from web-centric components to native Android. The new Jetpack Compose renderer for A2UI v0.9 enables developers to render dynamic, LLM-generated UI natively. Instead of webviews, it leverages a Coroutine-driven actor framework, sealed-class lifecycles, and native Material 3 integration.
This session walks through the new architecture, explaining how server-driven component trees translate into reactive Compose nodes, and how built-in layout transitions handle structural updates smoothly without blocking the UI.
A racing car is a demanding environment of high speed, heat, and telemetry constraints. How can an on-device agent help process real-time vehicle data for sports and engineering applications?
This technical session explores an experimental hybrid architecture combining edge hardware and cloud agents. We'll walk through a research proof-of-concept using a Raspberry Pi to stream CAN bus telemetry, a Pixel phone running an on-device conversational agent powered by ML Kit and Gemini Nano, and an agent-to-agent (A2A) Cloud connection for post-race workflows.
Stop copy-pasting into AI chat windows and start delegating to your agent. This practical, example-driven session shows you how to level up your agentic engineering using Claude Code and the Android CLI. We will walk through a complete workflow to automate complex development tasks and ship features faster.
You will learn to: * Optimize the token efficiency of your harness using Android CLI, Skills, Hooks and MCP. * Offload and parallelize long-running tasks to subagents. * Set up continuous verification loops that stop early termination and run until tests pass.
Discover what’s next for Android development across Android Studio and the terminal with Android CLI. In this session, we unveil the latest in Android Studio Canary and Stable—from AI-assisted code migrations to Compose and Agent Client Protocol (ACP) support, to Lightbuild’s declarative architecture. We’ll also dive into the latest updates to the Android CLI toolchain. Learn how you can use it to automate your inner-loop workflows with improved access to devices, diagnostics tools for local and production issues, profiling workflows that let your agents test and validate optimizations and much more.
As Android apps grow and AI coding assistants become essential, using executable code to configure your build can create bottlenecks with slow sync times, fragile logic, and added complexity.
Enter Lightbuild: Google's declarative, config-driven interface to the build engine, designed for modern Android development.
In this session, we'll explore Lightbuild's new approach to managing builds and how to use it to build a demo app. Learn how decoupling build config from execution delivers faster project opens with lightning-fast sync in Android Studio, while offering a predictable schema for safer, more reliable AI editing. We’ll also cover Lightbuild's agent-friendly CLI tools for creating reproducible builds across local machines, teams, and CI/CD pipelines.
This presentation explores the strategic shift from viewing AI as a generic coding assistant to leveraging it as a context-aware, automated security peer reviewer integrated directly into the Android development lifecycle. We discuss how specialized AI agents, connected to the Android toolchain via skills, can help improve app security. By bridging the gap between raw LLM capabilities and deep project context, this approach empowers development teams to maintain high-velocity feature delivery without compromising rigorous security and policy standards.
Optimizing Android apps requires deep visibility into concurrent workflows and coroutine suspensions. While local profiling offers a useful snapshot, scaling these insights to production without overhead remains a challenge.
This session delivers an architectural blueprint for a continuous performance feedback loop: * androidx.tracing 2.0: Swap backends dynamically and propagate coroutine contexts (Perfetto flows) across threads. * Smart Instrumentation: Use local ART tracing to find hotspots, then automate the injection of low-overhead trace points. * Macrobenchmarking: Track regressions and verify performance gains on physical devices in CI. * Field Tracing: Go beyond local and CI tracing, with ProfilingManager.
Android apps often ship under-optimized due to overly conservative keep rules often from third-party libraries, leading to bloated APKs, slower cold starts, and degraded runtime performance.
With Google Play’s new performance thresholds for DEX optimization, app visibility now directly depends on staying ahead of the optimization curve.
This talk introduces a modern R8 workflow to tackle rule bloat. You will learn to: * Use the R8 config analyzer and skill to identify legacy rule overhead. * Transition from broad wildcard keep rules to precise, type-safe, generated annotations. * Prevent optimization regressions with new Android CLI tools.
As AI tools rapidly reshape modern software engineering, this panel will explore how developers are leveraging AI-assisted coding, automated agents and specialized developer tooling in their daily workflows. We aim to highlight practical applications, discuss measurable productivity improvements and candidly address the challenges engineering teams face when integrating AI at scale.
Keep your app's memory footprint lean-and-mean and non-segfaulty with Firebase Crashlytics. This session explores our comprehensive suite of memory troubleshooting tools available in the Firebase console and in Android Studio. We’ll start by covering how to leverage ANR insights and GWP-ASan reports to diagnose elusive memory bugs and then dive into our latest tooling for Out-Of-Memory (OOM) and Memory Limiter Kill (MLK) events, designed specifically to help you navigate and adapt to the new memory limits introduced in Android 17.
As the Android ecosystem expands across wrists, living rooms, vehicles, and XR, the opportunity to reach users on new screens is growing. However, distributing across Wear OS, Android TV, Android Auto, Android Automotive OS, or Android XR introduces distinct considerations for testing, store listings, and app reviews.
This session explores how to effectively utilize Google Play Console for non-mobile form factors to help streamline a predictable multi-device launch. We will cover key distribution decisions, including how to structure track strategies and package names, configure targeted testing tracks, and tailor store listings. You'll get a practical walkthrough of form-factor App Quality guidelines to help avoid common review pitfalls and publish on Google Play with greater confidence.
Android Developer Verification is crucial for a safer ecosystem. This session breaks down the compliance pathways for all developers, from large studios to hobbyists. We will outline the key requirements for publishing on Google Play and third-party app stores. The talk will feature a live demo of the new Limited Distribution accounts, showing how students and hobbyists can easily and safely share apps.
By the end of this session, you will be able to: * Understand the 3 main developer verification paths. * See the new Limited Distribution account flow live. * Identify your specific next steps for compliance.
Jetpack Compose makes it easy to design high-quality user interfaces, but it can be difficult to track down issues that affect UI performance. These kinds of issues can lead to problems that your users notice, like startup latency, and dropped frames that appear as scroll jank or choppy animations.
In this talk, we’ll introduce tools to uncover what’s impacting your UI’s performance, focusing on Perfetto and (re-)composition tracing. We’ll then explore specific anti-patterns you may be using that are secretly costing you, how you can find them in your code, and what positive patterns you can replace them with. By the end of this talk, you’ll understand how to think in Compose with a performance mindset, and how to profile, analyze, and verify performance optimizations in your app.
Managing Bitmap memory is critical for mitigating Out-Of-Memory (OOM) risks in visually rich Android apps. While developers know to reduce image sizes, achieving long-term app stability comes from mastering two other key pillars: Reuse and Recycle. This session delivers a practical playbook for optimizing memory performance using modern tools, open-source libraries like Glide and Coil, and system-level APIs.
In this session, you will learn how to diagnose real-world memory regressions using Android Vitals, implement advanced caching (Reuse) patterns with Glide and Coil, and proactively release memory (Recycle) using the onTrimMemory callback.
AI models can generate entire features in minutes, but is the code correct? We built Android Bench, our AI evaluation benchmark, to answer this question after analyzing thousands of generated code changes.
This talk shares insights from our journey, including all the ways we saw models cheats, how prompt specificity leads to higher code quality and how different agents approach the same task.
The Android ecosystem is vast, with users shifting seamlessly across phones, tablets, foldables, and desktop environments. Now that we are Compose First, this session explores how to architect your app for resizable windows and diverse aspect ratios—where traditional layout assumptions break down, leading to stretched UIs and lost state.
Explore how the latest capabilities in Jetpack Compose, Navigation 3, and WindowManager can help you build dynamic layouts that naturally scale from compact screens to dual-pane displays. Walk away with strategies to accelerate your development workflow using Gemini and our skills, like the adaptive skill, to automatically refactor legacy codebases for larger screens.
This year, Android officially became Compose-first for building all UI, placing legacy Views into maintenance mode. For Google Play, that journey began back in 2020. Across an engineering footprint spanning nearly two decades and billions of users, migrating to Jetpack Compose was achieved through proven best practices, close collaboration with the core Compose team and continuous tooling evolution.
Discover how modernizing Google Play with Compose delivered measurable improvements in velocity and long-term stability. The session walks through connecting agentic Figma design workflows with Compose implementation, automating quality to prevent unnecessary recompositions and crafting expressive interfaces with dynamic color, rich typography and layered shapes. You will leave with tested strategies to triage bugs faster and scale your own Compose migration with confidence.
Ready to take your Android UI from "it works" to "it’s a work of art"?
Join us for a tour of the latest graphics capabilities in Jetpack Compose. We’ll show you how to build new visual effects, from delightful mesh gradients to progressive blurs, and using the powerful new graphics features in Android. We will also show you how to improve the performance of your graphics features, without sacrificing battery life or frame rates.
As in-car displays expand across Android Auto and Android Automotive OS vehicles, developers face a unique dual challenge: delivering rich, adaptive experiences while parked, and driver-safe, template-driven experiences while driving. In this comprehensive 30-minute technical session, we explore the end-to-end architecture and development approaches to adapting Android apps to cars.
From the fundamentals of designing apps for use in cars, to the newest approaches for building media experiences that shift from audio to video as the car shifts from drive to park, you'll leave with everything you need to know to get your app on the road.
Users expect third-party apps to capture photos and videos with the same high fidelity as their device's native camera, regardless of lighting conditions or hardware tier. Delivering this consistency across the expanding Android ecosystem comes with key architectural considerations. This session demonstrates how to construct robust, professional capture pipelines that maximize device capabilities while remaining reliable across all form factors.
We will explore the latest advancements in CameraX, showing you how to integrate cutting-edge capabilities like Motion Photos and on-device AI enhancements through Google Play services, alongside spatial experiences using the Jetpack XR SDK. We will also look at our CameraX skill, which allows the coding agent of your choice to automatically implement the concepts in this talk, and more!
Media consumption accounts for a large portion of user time spent on mobile devices, which requires the playback experience to be flawless, highly efficient and mindful of battery life. Furthermore, users expect these experiences to seamlessly transition across their devices, from phones to living room TVs and beyond.
Explore how architectural updates in Media3 and ExoPlayer power seamless playback across form factors. The discussion centers on crafting responsive interfaces with the Media3 Compose UI toolkit, eliminating buffering in feeds using the new PreloadManager and extending your app to living room screens and Android XR with CastPlayer and spatial audio.
The journey to reliable text editing in Compose culminated in the complete rewrite of BasicTextField. This shift to a buffer-driven architecture eliminated IME race conditions once and for all. This session unpacks why legacy input syncing had to go and how TextFieldState keeps keyboard updates in sync. From there, take a deep dive into formatted editing to explore the mechanics of TrackedRange, the performance costs of edit blocks, and the real-world catches behind style boundaries, before taking an early peek at Markdown rendering.
Remote Compose introduces a new way to project expressive and interactive UI onto remote surfaces like widgets. By serializing layouts into compact binary payloads, RemoteCompose decouples UI from host execution to deliver significant advantages.
Key benefits include edge interactivity that enables high-performance rendering through local execution on the remote device, fluid scaling that allows UIs to reflow across diverse form factors via remote-side component evaluations, and a unified developer workflow that removes the need for platform-specific remote UI frameworks through familiar Jetpack Compose APIs.
This session unpacks these benefits and provides live production examples, including modern Wear OS Widgets and the glanceable Wear Workout Tracker experience in Runkeeper.
The launch of Googlebook opens up a new frontier for high-fidelity, desktop-grade experiences. In this session, we go behind the scenes with two pioneering partners who built for this platform from the ground up.
Notability will share their journey creating a desktop-class Android app using Jetpack Compose. Learn about their journey moving from other app platforms with desktop top-of-mind. Second, Logitech will dive into the hardware side, discussing how they are building and customizing peripherals to integrate seamlessly with Googlebook. Join the session to get practical, real-world insights on optimizing inputs, leveraging large-screen APIs, and delivering a premium, cohesive user experience across hardware and software.
As new form factors move beyond the touchscreen, Compose's input system has evolved to meet the challenge. Its layered architecture provides the foundation for supporting everything from advanced trackpad gestures to novel hardware inputs seamlessly.
Through clear architectural breakdowns and hands-on code examples, follow the lifecycle of an input event all the way from the OS platform layer up to Compose gesture detectors and UI components. You will discover how to trace events across the entire stack, apply key architectural patterns for emerging input types, and confidently debug complex gesture interactions in your own apps.
Compose’s snapshot runtime, automatic dependency tracking, and atomic updates don’t have to stop at the UI layer. Jetpack AppState lets you move Compose state upstream—streamlining what reaches your screens by hoisting and deriving state with the snapshot system before it ever hits the UI.
In this session, you’ll learn about AppState’s two foundational libraries. We’ll dive into StateStore for hoisting state, and Transform for using composition to derive state with plain Kotlin control flow—eliminating complex Flow combine chains and keeping your UI effortlessly in sync.
As the industry moves away from passwords and physical wallets, delivering a modern user journey demands both seamless authentication and trusted identity verification. While passkeys establish secure one tap logins, switching devices remains one of the largest drop off points in user engagement. Learn how to reduce migration friction using the Restore Credentials API to meet the new Google Play Zero Tap Sign In standard.
This session explores how a single integration with Android Credential Manager unifies passkeys, silent device restoration, and Digital Credentials, allowing you to verify identity attributes directly from the device and build an effortless, secure onboarding flow.
In this session, we will take a technical deep dive into the evolution from full-screen Tiles to dynamic, partial-height Wear Widgets.
We will explore the technical benefits of the unified Jetpack Glance API and the new Remote Compose engine, detailing how they seamlessly align with Modern Android Development.
Finally, we will share the latest UX guidance and walk through practical migration strategies to help you build the next generation of glanceable UI.
Managing deep links across modular Android apps can easily lead to broken routes and runtime surprises. This session unpacks Jetpack Navigation 3’s new type-safe deep linking architecture for Compose to help you build a robust and scalable routing system. We'll explore how to implement out-of-the-box deep link matching APIs, write custom serializers for complex type-safe arguments, and construct dynamic hierarchical back stacks that keep user navigation predictable.
Hear directly from WhatsApp engineers on how they upgraded their Wear OS app at scale. This session covers the architectural and UX decisions behind integrating Material 3 and adopting Wear Widgets.
Gain direct insight into the lessons, patterns and tools the team used to update their app and deliver a cohesive user experience.
As users move between phones, wearables, and audio peripherals, delivering fluid cross-device experiences has become essential for engagement. However, relying on standard networking approaches often leads to battery drain, latency spikes, and fragmented user sessions.
This deep dive introduces specialized Android APIs built for multi-device communication, offering memory- and power-efficient patterns to keep transitions between devices instant, reliable, and intuitive.
Learn how to integrate 3D game engines (Godot & Unity) with Jetpack Compose into a single codebase for mobile and Android XR. We'll explore embedding 3D scenes into spatial containers, setting up Kotlin-to-engine communication—featuring an exclusive look into how the NBA built their live basketball experience on Android XR.
Go beyond screen-space and anchor your apps in the real world with Android XR. This session teaches you how to build geospatially aware Android XR experiences using Jetpack Compose Glimmer and ARCore's Geospatial API. We will start by covering how to get a device's geospatial pose with ARCore. Then, you'll see how Glimmer’s minimal UI components can be anchored to real-world locations via the Visual Positioning System (VPS). We'll combine these to build a simple, location-aware spatial experience.
Discover how to anchor and persist 3D experiences in the real world using Unity and Android XR. This session covers the Spatial Entities framework, Cloud Anchors, and Geospatial APIs, demonstrating how to build context-aware apps that remember physical placements and sync multi-user spatial data across sessions.
We will examine the architecture behind spatial entities, understand how to anchor digital assets to physical objects, surfaces, and geographic locations. You will walk away with practical Unity workflows for mapping spaces, persisting content across sessions, and creating shared, location-aware AR/XR experiences.
Bringing conversational AI into immersive experiences opens up huge possibilities, yet there’s a constant friction between low response latency and sustainable cloud costs. In this session, Devin Reimer (Founder & CEO of AstroBeam) breaks down how the team behind Stellar Cafe achieved industry-leading voice interaction response times (1.15s–1.4s) while keeping the business model commercially sustainable.
Explore the hybrid architecture behind these low latency pipelines, focusing on intelligent orchestration between on-device models and optimized cloud inference to cut expensive API calls without degrading dialogue. You’ll walk away with a practical blueprint covering Time-to-First-Token optimization across Speech-to-Text and streaming Text-to-Speech pipelines, parallel safety guardrails that bypass latency overhead, and unit economics per active user session.
When we say XR is for everyone, that principle has to guide how we build from day one. In this introductory guide for developers new to XR, Jazmin Cano shares the foundational accessibility principles honed at Owlchemy Labs. Engine-agnostic and universally applicable to both games and apps, this session explores how early consideration of motor, visual, auditory, and cognitive needs leads to better experiences for all users. Discover how to build an inclusive development culture, conduct meaningful testing, and design spatial interactions that remove barriers without sacrificing quality.
Discover how to build robust, hands-free audio experiences powered by on-device AI. We’ll cover everything you need: setting up your glasses activity, capturing mic and camera feeds, and using voice along with other audio cues as your ultimate UI. Through an exciting real-world showcase of the open-source XR Language Teacher built in the Google AI Edge Gallery app, learn to orchestrate Gemini Nano 4 (built on Gemma 4 and optimized for Android devices), and ML Kit, and leverage the LiteRT runtime to build fast XR experiences that hear, see, and speak naturally.
Transitioning your Android applications from traditional 2D screens into spatial environments requires a new approach to constructing shapes.
In this session, we will explore the Custom Mesh API in the Jetpack XR SDK, which allows you to programmatically generate procedural 3D geometry directly at runtime. We will walk through the core workflow, from defining vertex layouts to rendering dynamic objects seamlessly within the user's physical space.
By the end of this talk, you will have the practical skills to build interactive, custom 3D geometry completely from code.
Which sessions or announcements stood out to you this year? Let us know what you're testing out in the comments!
Comment here to discuss the recent trend of long Play Store review times for app submissions and updates.
Do not make a new post about this subject, as it will be removed.
This is an unofficial developer community, so we are not on the Play team and cannot help your app/update pass review. No, we don't have tips to speed things up.
Yes, Play Store developer support is present on this sub and may answer questions or assist you on a case-by-case basis. The mod team is not affiliated with and has no influence over that account. We make no guarantees as to their effectiveness, but we are grateful they exist and that they continue to communicate with users here.
Hi.. I am in the process of making an ar viewer in vulkan for android to run natively.
For rendering i am following a hybrid structure mixing Raster IBL approximations and path tracing, the gems are traced with tracing the ray directions and metals with split sum approximations and only traced for inter reflections once the movement stops.
The engine is general purpose focusing on jewellery embedded in an sdk to integrate with 3 lines of kotlin.
The c++ engine takes care of initializing the context based on the hardware capabilities like vulkan 1.1 support, hardware RT cores and compute path fallbacks.I have tested on mali, adreno and xclipse(Exynos) gpus.
Most of the optimization i did are around the memory and cache coherency on mobile gpus, since last couple of years got really obsessed with graphics maths and its implementations but i come from c++ background so pls let me know about the visuals of the same and how can i improve further.
It is closed source for now but happy to share any details to any one interested.
Hello! I'm a little stumped about this because while I do code for work, I'm no android developer, so I'm taking a shot here to see if someone could help with this problem.
So I have these two devices that I'm trying to get to work as intended.
Veikk VK430 - It's a 4:3 aspect ratio screenless drawing tablet with android compatibility in portrait orientation.
Anbernic RG Rotate - An Android 12 handheld gaming console with a 1:1 aspect ratio. The screen is 720x720 and 3.5" with a DPI of 290.
So what's going on here is that when I connect the two devices, the tablet is able to map the whole screen from corner to corner on the handheld, but since the aspect ratios are different, tracing a coin on the tablet will result in an oval on the screen.
I've tried to see if turning the screen into a 540x720 (largest 4:3 aspect ratio I can get on the rotate) using adb shell wm size 540x720 would do the trick, but the tablet is still recognizing the screen as a 720x720. If this were Android 11, I'd have tried wm overscan, but it's not an option anymore.
Is there anyway I can adjust the screen's input area to 540x720? Technically I can still draw on the rotate for fun as is, though it's going to mess up my circles, or I can just do the more reasonable thing and draw on an actual computer...But now I'm kind of invested.
I extracted the Cast stack from an app I maintain and published it as a library: Castwire. It finds Chromecasts, Google TVs and other Cast devices and plays media on them without Google's Cast SDK or Play Services.
The Android artifact is castwire-android. You create it with AndroidCastwire.create(context). It is a regular Android library (minSdk 24, Java 8 bytecode). The AAR declares INTERNET, CHANGE_WIFI_MULTICAST_STATE, ACCESS_WIFI_STATE and WAKE_LOCK. During discovery it holds the multicast lock; while a session is open it holds a Wi-Fi lock and a partial wake lock, because the TV often plays through a small HTTP relay on the phone (local files, links that need headers, cookies, this device's IP, or CORS).
The library does not include a foreground service and does not depend on Media3 or ExoPlayer. Dependencies are kotlinx-coroutines, kotlinx-serialization-json and OkHttp. You keep the process alive yourself, the usual way, with a mediaPlayback foreground service, and you keep using whatever player you already have on the phone.
val castwire = AndroidCastwire.create(context)
val tv = castwire.discover().first()
val session = castwire.connect(tv)
session.load(CastMedia(
CastSource.Url("https://example.com/movie.mp4", "video/mp4"),
MediaMetadata(title = "Movie"),
))
session.pause(); session.seek(90_000); session.setVolume(0.4f)
Separate video and audio streams can be joined into a DASH manifest on the device. Live HLS playlists can be rewritten and relayed. There is also CastDevice.at(ip) if you already know the address, and you can launch a custom receiver by app id.
License is AGPL-3.0, with a commercial license if you need to use it in a closed-source app. This is 0.1.0. The coordinates the build is set up for are io.github.biolend83:castwire:0.1.0 and io.github.biolend83:castwire-android:0.1.0, but they are not on Maven Central yet, so for now clone the repo.
I’m an indie developer, and for years, creating screenshots has been part of the release process that I’ve always found a bit of a chore. The commercial tool I used so far was slow, clunky and had no MCP.
So I built Vitrine Studio: a 100% free, open-source desktop app (macOS, Windows, Linux) for App Store and Google Play screenshots. You design one continuous canvas, and Vitrine renders it for every language, device size and store.
MCP: Vitrine has a built-in MCP server, so AI agents can build complete screenshot sets for you – layout, copy, translations, validation, export. You watch the changes live in the editor, the agent renders previews to check its own work, and you only step in if something needs a personal touch. Most of the templates in the gallery were designed this way.
CI/CD: A headless CLI validates, exports and uploads directly to App Store Connect and Google Play – with a container image, fastlane support and reports for GitHub/GitLab. Validate on every PR, export as a build artifact, upload from your release job. Projects are plain YAML + images, so they live in Git next to your code.
I’ve been fighting background BLE beacon scanning on Android and wrote up what I measured on a Samsung (Android 14, One UI 6.1). Short version:
A filtered LOW_LATENCY scan gets silently downgraded to LOW_POWER after scan_timeout_millis: 300 s on my device (AOSP default was 30 min, 10 min on Android 15+). Detections dropped from ~80/min to ~10/min. No callback, no error, just Moving filtered scan client to downgraded scan in logcat.
An empty ScanFilter is treated as no filter: with the screen off the scan is suspended and you get ~0 results.
The quota of 5 starts per 30 s: the 6th startScan was rejected, and onScanFailed was never called.
With a Foreground Service, turning the screen off didn’t kill the scan by itself. The timeout did.
Restarting the scan every 4 min through a single start counter, plus a silence watchdog, kept it at ~90/min with the screen on and ~48/min with the screen off.
Curious what you see on your devices: what does adb shell device_config get bluetooth scan_timeout_millis return? Especially Pixel, Xiaomi and OnePlus.
I recently found out that if you ship Android app updates every week. Your app's performance could suffer if you're not using good Baseline Profiles. In this article I get into why this happens.
So I have this one somewhat critical function that I want to be fast. I want to profile it with either method tracing, or callstack sample, to find what I can optimize in it. I've got two issues:
If I just run profiling in Android Studio, I'm getting a humongous file (>300MB) as I'm trying to get the method to run in a realistic scenario. It's not run often, and to trigger it I must do things that run a lot of other code.
This function is called from multiple places and multiple threads. Ideally, I would like to see the statistics for it, such as the flame chart, as a single entity. Instead, in the charts I see it in multiple places.
To overcome these issues, and primarily the first one, I would like to have profiling enabled as I enter the function and disabled as I exit it. Sounds simple? Well, I couldn't find a sensible way to do this. There are methods such as startMethodTracingSampling which work.. but they create a new file for invocation, while what I want is some aggregate statistics. And this file is on the device so I have spend some effor getting it from there.
Otherwise, I'm left with dealing with the humongous trace files. My computer can handle those, but again, very slowly, and finding my method of interest takes so much time that comparing the impact of code changes is just not viable.
Is there sensible way to quickly profile a single method? Or am I stuck with the above options?
I am preparing my first Android app for release on Google Play Console and ran into a few questions regarding the testing tracks and the mandatory 12-tester / 14-day testing period:
- Internal Testing vs. Closed Testing URLs: Following the initial dashboard steps, I published a release to the Internal Testing track and shared the link with my testers. After completing the Store Listing steps, I also set up a Closed Testing release and noticed it uses a different opt-in URL. Since the final production checklist states that the testing period must be completed in Closed Testing, does time spent in Internal Testing count toward the requirement, or do I need to migrate my testers to the Closed Testing link?
- Internal App Sharing: I enabled Internal App Sharing in the settings. How does this differ from the Internal Testing track, and does it affect the release process?
- Play Store Errors for New Testers: When I add new users to my tester email list and share the link, some of them encounter an error or see a completely blank page when redirected to the Google Play Store, despite using the correct Google account. Occasionally it works if they retry a minute later, while for others the issue persists. Is this a propagation/caching issue, or is there a specific step I might be missing?
I have around 2.8 years of experience as an Android Developer, and I'm currently planning to switch companies. However, for the past six months, I haven't been receiving many interview calls. Even when I do get interview opportunities, I struggle to clear more than one or two rounds.
At this point, I'm stuck in a loop of figuring out where I should start and what I should focus on.
Should I start learning Jetpack Compose or Flutter? Or should I focus more on strengthening my existing Android skills and gaining a deeper understanding of the features I've implemented in my projects?
Another major concern is my reliance on AI-assisted development (vibe coding). To be clear, I'm not simply copying and pasting code. I understand the logic behind most of the implementations and know how things work, but I haven't developed the habit of writing everything independently from scratch.
Because of this, I sometimes struggle to take full ownership of the projects I've worked on. I'm also unsure how deeply interviewers might question me about my project implementations, and this makes me hesitant when attending interviews.
To be honest, my confidence has been dropping day by day, and I'm finding it difficult to figure out the right direction for my career preparation.
For those who are currently working as Android Developers or have recently switched jobs:
What skills and technologies should I focus on with 2–3 years of experience?
Should I prioritize mastering core Android concepts, learning Jetpack Compose, or exploring Flutter?
I'd genuinely appreciate your honest opinions and suggestions. I'm looking for practical guidance to help me get out of this phase and move forward in my career.
hello guys. am working on some games and today I came a cross some info about having to have 12 testers for the personal dev account and I read it can risk my personal assets in the case of some law suite. mean while running an LLC seems the better choice but registering with D&B can be tricky as using an agent or virtual office address will probably be declined.
so should I just register a normal LLC with my home address as it is the easiest , cheapest, and more guaranteed way? or how do you guys go through about this. (US based and LLC is cheap to register in my state)
any info from people who were in my situation and what they chose and why will be appreciated.
For the last few months I've been building an open-source YouTube client in Kotlin. One codebase covers Android phones, Android TV, Windows, macOS, Linux and iPad, with almost all of the UI in a shared Compose Multiplatform module. A few things I learned that might save someone time:
"It's fast on my phone" hides main-thread work that TV boxes can't handle. A user's TV box froze, the D-pad stopped responding, then the app crashed. Oddly, it only happened after the first launch: clearing app data fixed it once. The cause was JSON parsing of YouTube's (large) responses, plus ranking the home feed against watch history, both on the caller's dispatcher. On a fresh install there's no history, so it's cheap. A few days later it isn't, and a slow ARM box can't keep up. Moving the parse and the ranking to Dispatchers.Default cut skipped frames roughly in half on the emulator. The general lesson: test with a realistic amount of user data, not a clean install.
D-pad focus is its own UI. I first tried making the phone layout "focusable" for TV. It was miserable. What worked was a separate TV layer (rail, shelves, its own player screen), sharing the same state and data but not the same composables. Two things helped most: focusProperties { onExit = { cancelFocusChange() } } to trap focus inside panels, and a small retry loop for "move focus into the page after it loads".
Casting without Play Services is doable. I needed casting on desktop too, so the Cast stack is hand-written in the shared JVM code: mDNS discovery, a TLS socket to port 8009 with hand-encoded protobuf, the Default Media Receiver, and a tiny local HTTP server that feeds the TV. A gotcha: my Google TV ignored ordinary mDNS queries from an ephemeral port. It answered only unicast-response (QU) queries, or queries sent from port 5353, so now it sends all of them.
Off-screen screenshots of every screen are a great review tool. ImageComposeScene on desktop renders the whole app with no window. I render every screen at phone and desktop sizes and look at a contact sheet before I push. It caught clipped titles and a Shorts layout overflowing on phones that I'd never have noticed by clicking around.
Platform-only APIs go behind small interfaces, implemented natively. For example, comment translation uses Apple's Translation framework through a Swift helper on macOS and SwiftUI's translationTask on iOS. Compose only sees platform.translate(). A contributor wrote both. Watch out for availability, though: the framework needs weak linking when the app still supports older iOS versions.
The project, if you want to read the code: https://github.com/biolend83/tubehaus (AGPL-3.0, the app is on the android-app branch). Happy to go deeper on any of these.
Hey r/androiddev! I’ve been building ChromaTerminal XR, a next-generation spatial developer shell and 3D holographic AI assistant engine built entirely on the new Android XR SDK (androidx.xr.compose:1.0.0-beta02).💪
The main engineering challenge was handling complex 3D assets (anime_companion.glb) and real-time spatial windowing while maintaining a strict 90 Hz refresh rate and <14ms motion-to-photon latency.🚀
Architecture Highlights:
Spatial UI & SceneCore: Uses Subspace layouts, SpatialPanel, and Orbiter containers with real-time 6DoF floor anchoring.
AI Routing Core: An asynchronous coroutine pipeline (TerminalAIManager) powered by Gemini 1.5 Flash that maps natural language responses (<SYS>, <CODE>, <MSG>) directly into spatial UI elements.🤯
Developer Experience: Implemented LocalInspectionMode.current checks so developers can preview and render layouts safely on non-GPU desktop environments without crashing Android Studio Compose previews.
I’ve mapped out enterprise workflows for it across cybersecurity SOCs, medical telemetry, and education. Would love to hear your thoughts on the architecture or answer any questions about the Compose XR API!
Check out the full pitch deck breakdown attached. Roadmap targets Google and Meta XR developer enrollment for Q2 2027. I will be thrilled with your response; source code,links and contacts at https://github.com/murayijacquiline-max and email: [email protected]
Title: Moved to Canada after verifying my Google Play developer account—should I update my details?
Hi everyone,
I opened my Google Play developer account in 2022 and verified it using my home country’s address. I moved to Canada, but my account details still show my original address and country.
Should I update my developer account details to reflect my current Canadian address? Has anyone gone through a similar move and updated their details? Did it require additional verification or cause any issues with your account, published apps, or payments?
I want to keep everything compliant and avoid problems down the road. What would be the best way to handle this?
Asking because they used to reply within 48 hours, I've waited more than double that on two tickets now. Could it be the quota that they mention when you flag a user review for consideration?
I recently published my Android app, Intent – Quit Phone Addiction, on the Google Play Store.
The app uses Android's Accessibility Service exclusively for its core productivity functionality: blocking distracting applications during user-defined focus sessions.
A few important details:
The app is publicly available on Google Play.
It passed Google's Play Store review and is compliant with Accessibility Service policies.
Accessibility usage is explicitly disclosed to users.
Users manually enable the service and grant the required permissions.
The service is not used to read financial information, capture credentials, perform transactions, or interact with payment apps.
The problem:
When Google Pay (GPay) is opened, it displays the following warning:
"Payments blocked. Some apps have permission to make payments, take action."
It instructs users to disable Accessibility Services for all apps and restart their devices before making payments.
This happens even though Intent is a legitimate productivity application downloaded directly from the Play Store.
My questions:
Has anyone experienced a similar issue with Google Pay or other UPI applications?
Does Google Pay maintain its own list of Accessibility Services that it considers risky, independently of Google Play's app review?
Is there any way for legitimate apps using Accessibility Services to get reviewed or allowlisted for compatibility with financial applications?
Is this related to Google Play Integrity, Play Protect, or Google's separate fraud-detection mechanisms?
Are there any recommended implementation changes that could prevent this false positive without removing the core Accessibility functionality?
I understand why financial apps have strict security checks, and I fully support those protections. However, it seems problematic when legitimate, Play Store-approved productivity apps cause payment restrictions.
I’m a solo developer. My app makes subtitles from videos right on the phone. It’s free, has no ads, and works offline. It just crossed almost 1,000 installs on Google Play, but Play Console shows 700+ uninstalls, and I can’t figure out the reason.
Some context:
After installing, the user has to download a language model (a few hundred MB) before they can make subtitles. I suspect some people leave at this step.
Making subtitles takes a few minutes for longer videos, and the app has to stay open.
The rating is good (4.7), and the people who stay seem happy, so it’s mostly silent uninstalls.
I have Firebase Analytics and Crashlytics, and the crash-free rate is above 99%, so crashes don’t seem to be the cause.
My questions:
How do you find out why users uninstall? Is there a way to see at which step they drop off before uninstalling?
Is a ~70% uninstall rate normal for a utility app that people use for one job and then remove?
Has anyone tried an exit survey, or something similar, that actually worked?
Any tips on what to measure in Play Console or Firebase would really help. Thanks!
I released an app a few days ago and have about 80 users, and see someone already hacked it to make about $1000 in in app purchases. (In game $). I don't really care because they were unlikely to make a real purchase, and in 2 days they've played more than 2 hrs. So at least they're engaged. :)
I have no leaderboards or anything, they're really just cheating themselves.
I recently downloaded the rabbit 2 patch for Windows. Now the classic ai code completion is not working. Not the pop up auto complete intellisense stuff, but the one that tries to predict what you want to do and auto filla it in gray and you have to tab to use it.
I have turned off the Next Edit Prediction. Which is supposed to bring back the classic ai auto completion, but it does not. The NEP doesn't seem to work great either for that matter. But maybe that's just the way it is.
The classic AI auto completion worked great before this update. Maybe it's a but? I filed one here
Running a few coding agents in parallel, one worktree each, means one Android Studio per worktree just to check the Compose UI. Each one drags along a Gradle daemon and a Kotlin daemon, around 8GB. Three of those and a 36GB Mac swaps all day.
Prevue is for that. It shows your `@Preview` functions in the browser and redraws them about a second after you save. to check the Compose UI. Each one drags along a Gradle daemon and a Kotlin daemon, around 8GB. Three of those and a 36GB Mac swaps all day.
Prevue is for that. It shows your `@Preview` and redraws them about a second
Easy to start
Nothing to install in your project. No Gradle plugin, no build file changes
One skill. Run /prevue in Claude Code or Codex, tell it the file name, done. Nothing to configure (macOS only for now)
What it does
Hot swap : Every `@Preview` in the they all redraw on save. Change just a padding or a color and it's more like 0.2s
