r/androiddev • • 19d ago

News ICYMI: Every Android Dev Summit 2026 VOD is now live, and it’s now easier than ever to get caught up!

Post image
50 Upvotes

Hi r/AndroidDev,

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 the Agent 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 intelligent apps

Integrate your app with the Android intelligence system

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.

Inside Gemini Nano and Gemma 4 powering on-device intelligence

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.

On-device intelligence: Optimized performance and quality using Android ML Kit APIs

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.

Build optimized Android Apps with Firebase AI Logic and Gemini Nano 4

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.

Extend your app to Gemini and Search with the Connected Apps Platform

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.

Mastering on-device intelligence with ML Kit and LiteRT in Google Play services

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.

Unlock agentic capabilities in your app with ML Kit GenAI

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.

Agentic coding workflows with small models

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.

Let agents generate UI in your Android apps with A2UI

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.

Building a Formula E co-driver on Android with ML Kit and Gemini Nano

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.

Android tools & performance

Agentic engineering with Claude Code and Android CLI

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.

The latest in Android dev tools from Android Dev Summit 2026

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.

Declarative, agent-ready Android builds with Lightbuild

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.

Decoding Play Policy AMA

An open and honest panel about Play policies to keep your app compliant and quickly published.

App security in the agentic era

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.

Trace me if you can: Automated instrumentation and field profiling

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.

Type safe keep rules and DEX optimization

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.

Agentic coding: A roundtable with industry leaders

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.

Memory troubleshooting with Firebase Crashlytics

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.

Navigating multi-device quality & publishing beyond mobile on Google Play

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: Publishing paths for all developers

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.

Outperform yourself in Compose

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.

Actionable strategies for reducing your app's Bitmap memory footprint

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.

Insights into agent code generation from Android Bench

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.

Android apps foundation

Scale your app for every screen with Compose

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.

Migrating two decades of the Google Play app to Jetpack Compose

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.

Graphics features in Jetpack Compose that can elevate your app

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.

The car is your canvas: Unlocking Android development for the road

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.

Elevating camera experiences across devices with CameraX and on-device intelligence

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!

Optimize media playback and maximize reach with Jetpack Media3 APIs

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.

Building reliable text editing experiences in Compose

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.

Powering interactive surfaces with Remote Compose

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.

Inside the first wave on Googlebook with Notability and Logitech

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.

Scaling input interactions beyond the touchscreen with Jetpack Compose

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.

Take Compose state beyond the UI with Jetpack AppState

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.

Delivering Seamless Sign In and Digital Credentials on Android

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.

Evolving Tiles to Wear Widgets using Jetpack Glance and Remote Compose

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.

Building type-safe deep links with Jetpack Navigation3

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.

Lessons from WhatsApp's Wear OS journey

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.

Enabling seamless cross-device interactions

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.

Android XR

Elevate immersive experiences with 3D Engines in Jetpack Compose for XR

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.

Build world anchored experiences for wired XR glasses

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.

Architecting Spatial Content on Android XR with Unity

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.

Balancing ultra-low latency and cloud economics in virtual voice agents

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.

XR is for everyone: Designing accessible spatial experiences

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.

Building audio-first experiences for intelligent eyewear with Gemini Nano 4

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.

Moving beyond 2D with custom 3D geometry in the Jetpack XR SDK

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!


r/androiddev • • Oct 05 '26

Megathread: Play Store review times

21 Upvotes

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.


r/androiddev • • 2h ago

I built WebView Inspector to inspect WebView URLs and navigation right inside Android apps

1 Upvotes

Hi everyone,

I built WebView Inspector, an Android library that adds a floating inspector to your app so you can see what your WebViews are loading.

It lets you:

  • Highlight a WebView in a card, banner, or full-screen page, inspect its query parameters, and copy its exact URL.
  • Review observed navigation history and revisit saved records after leaving the screen using Live / Recent.
  • Inspect the URL and headers your app supplied through an optional loadUrl helper.

My usual workflow was to search Logcat for the URL, copy it, and open it in Chrome to see what had loaded. That gets tedious when reproducing an issue, especially with multiple WebViews on the same screen. I wanted to check the URL and retrace navigation directly inside the app.

Basic inspection needs one installation in your Application. The optional load helper adds capture of app-supplied URLs and headers. Setup and usage

I see it fitting into the debugging workflow alongside these tools:

  • Chucker shows the Android app’s OkHttp requests and responses. Chucker
  • WebView Inspector shows which URL a particular WebView loaded and where it navigated.
  • Chrome DevTools shows requests made inside the web page, including fetch/XHR calls and their responses. WebView remote debugging

Navigation capture covers observed top-level URLs. Older WebView providers use sampling, which can miss fast redirects. Captured headers are the inputs your app supplied, and records stay in process memory. Capture details

Version 0.5.0 supports Android API 24+ and is available on Maven Central, with a matching no-op artifact for production builds. Release details

The repository includes the source code, integration instructions, and a sample app. Explore WebView Inspector on GitHub

I’d be interested to hear how others handle WebView URL debugging and which cases you find hardest to inspect.


r/androiddev • • 11h ago

Anyone have any idea why my Android Studio emulator isn't refreshing the layout automatically when I save?

2 Upvotes

Literally just started using it.

EDIT:

For anyone else having this problem you have to click on the checkmark / cycle icon in the preview panel and select refresh automatically


r/androiddev • • 16h ago

Question What tools do you guys use to design professional high-end Android app UIs?

1 Upvotes

Hey everyone, I'm new to Android app development and looking for some advice. I've been using Android Studio, but honestly, its UI designer feels more like making a PowerPoint slide, not the high-end quality UIs that i see in other apps.

What tools do you guys use to create app UIs? And are there any good tutorials or guides you'd recommend for someone just starting out?


r/androiddev • • 16h ago

Android developers: Native TTS vs. third-party speech engines for a commercial app?

0 Upvotes

I'm evaluating speech recognition and text-to-speech options for an Android project and would appreciate some real-world experience.

I'm particularly interested in:

  • The quality and consistency of Android's built-in TTS voices across different devices.
  • Whether Sherpa-ONNX, Piper, or other speech engines offer meaningful advantages.
  • Latency when combining cloud-based speech recognition with local TTS.
  • Reliability of interruptible speech playback.
  • Commercial licensing issues with open-source speech models.

For those who've worked with these technologies, which approaches have proven reliable, and which would you avoid?

I'm especially interested in solutions that minimize development complexity and recurring API costs.

Thanks for any practical advice or links to useful implementations.


r/androiddev • • 19h ago

Open Source I'm experimenting with an open-source Android flight recorder for diagnosing user-journey failures

1 Upvotes

Hey everyone!

I've been working on an open-source project called Argus - SystemSleuth.

The idea started with a problem I've encountered while thinking about application debugging:

When a user reports that something didn't work, a stack trace or API error often tells us where something failed, but not necessarily whag happened across the enire user journey.

For example:

A user selects a PDF, attaches it to an email and taps Send. The upload times out.

A conventional log might tell us that an HTTP request failed. But understanding the sequence of user actions, screen transitions and network events leading up to that failure can be equally important.

I'm exploring whether a structured runtime trace can make this kind of debugging easier.

What Argus currently explores:

● An in-memory, bounded flight recorder for capturing session events.

● Android Activity/Fragment lifecycle and user-interaction tracking.

● Network-event instrumentation through OkHttp.

● Session-level diagnostic analysis using AI providers, with a heuristic fallback.

● A sample Android app that reproduces an attachment-upload timeout and demonstrates the diagnostic flow.

A little context about it's current state:

This is still an early-stage experiment, not a production-ready observability SDK. The expected-workflow-versus-observed-execution comparison is also still a work in progress, rather than a fully integrated Android feature.

Privacy and sensitive-data handling need further work too, so I'd currently treat it as something to experiment with using test data rather than real user sessions.

Github: https://github.com/Deven264/Argus-SystemSleuth

It's liscensed under Apache 2.0.

I'd particularly appreciate feedback from people working on Android, debugging tools, observability or developer infrastructure.

  1. Do structured user-journey traces provide meaningful value beyond conventional logs and crash reports?
  2. Which events would you consider essential to capture when diagnosing application failures?
  3. What privacy safeguards would you expect before using a tool like this in a real application?

I'm sharing this to get honest technical feedback and improve the project. Criticism and suggestions are welcome!

Disclosure: I'm the developer of Argus.


r/androiddev • • 1d ago

Experience Exchange Takeaways after building an app and publishing it to Google Play

0 Upvotes

Hello,

My goal here is not to advertise my app. This is why I won't share its name. I would just like to share my experience building an app, from starting from scratch to publishing it to google play store.

I hope this share of experience will help someone. I know that most of the advice I'll share here will feel amateurish (because they are, indeed) but perhaps some amateurs might find them useful. I don't pretend that I know everything and I know that I have still much to learn.

Goal of the app: The initial idea was simple: Everyday, I watch videos to learn but never remember anything. The idea is you take a picture of a course, you share a youtube video link, upload a pdf file and this piece of knowledge is converted into cards that can be learned through spaced repetition. The exercises are generated "on the fly" so that you don't learn from the card content but are always truly tested for the specific content.

Stack

PartTechnologyWhy?
FrontReact NativeI thought it was more suited than flutter if I wanted in the future to make a web app, but I might be wrong.
Local DataBaseWatermelonDBIt makes it easier to sync a local database with supabase without using PowerSync.
BackSupabaseSupabase has a more generous free tier and I was afraid with the pay as you go pricing of firebase
AI (dev)Google Vertex AI(1) It's very fast and stable in comparison with other platforms I tried (azure and deepseek). (2) I has a 3-month trial with $300 credits (3) it's quite secure because you don't rely only on api keys (you can only accept requests from specific IP for ex). But the initial setup can be heavy.
AI (prod)OpenRouterIt's easier using open router to just switch from a claude model to a deepseek model, with the same price as the official platform. The only problem I had at first was reliability. The "nitro" mode allowing you to automatically select the best provider doesn't work well so I had to cherry-pick myself the best providers.

Some lessons I learnt

Don't develop directly. I might seem stupid by saying that, but the pleasure to develop could take the upper hand and you could miss so many important steps.

What I missed

  1. Might the app interest someone ? I know now that it might not interest anyone. When talking about it to other people, i most of the time feel ashamed by the uselessness of the idea. I think it is useful for my own use but I guess we're all very different.
  2. If so, who could be interested ? What is the potential customer ? From my part, I completely miss that students could be interested with it so all the functionalities I developed at first completely missed this target.
  3. Does any other app offer the same service ? I checked that after almost finishing the app. When comparing with the "competitors", I found many similarities with what my app.
  4. The app name : The initial name I took was already taken in every domain (.com, .app, etc.) and very expensive so I had to change it everywhere.
  5. Take the time to just design in a piece of paper (or whatever mean) what you want: All the menus, everything. It can take several days but you gain so much time afterwards.

Other lessons, but not from a mistake I made but more due to some principles I have

  • Help from AI: It's quite impossible to ignore the help of AI now. It's a very important help but don't let it take architectural decisions for you. Take the time to choose the schema of your database, the best stack for your need, how to organize your codebase.

Publishing the app

Everyone seems to talk about the compulsory 12-testers internal test to publish an app in google play.

  • This constraint is "only" for physical persons. If you're an organization, you're not required to do that. In France, you can just create what we call a "micro enterprise" (which is free in France). After accepting that your "company" gets listed in public repositories, you can get easily a "DUNS" number to get identified as an organization for google. I know the process is completely different across countries but it might be useful to check that out. Also, if you're french and need help, tell me (i got it to work!).
  • This is a useful constraint. After checking reddit posts, someone answered that, if you really want your app to work, doing an closed test is a basic step to get feedback to truly improve it. Take the time to consider really doing this step seriously.

Please, if you disagree with this post, or if you have anything to share, I am at your disposal.


r/androiddev • • 2d ago Bravo

Yalın — a Rust-based JSON parser optimized for Android ARM devices

Post image
37 Upvotes

I've been working on Yalın, a JSON parser written in Rust for Android.

It uses ARM NEON SIMD and tries to keep JNI calls to a minimum. The idea was to see how much performance I could get out of native parsing compared to existing Java libraries.

In benchmarks against fastjson2, selective field reads were up to 4.6x faster, while parsing a full 1 MB JSON tree was around 1.3x faster.

Small payloads are a different story. JNI overhead is still a bottleneck, and there's room for improvement.

Curious what other Android developers think about using Rust for this kind of thing, especially whether the performance gains are worth the native dependency.

https://github.com/0xberkay/yalin


r/androiddev • • 1d ago

Hiring for a Job [Hiring] Senior Android Engineer — Shenzhen, China (on-site)

1 Upvotes

A well-known internet company is hiring a hands-on Android engineer to build a personal communications product for global users. This is an on-site role in Shenzhen, China.

We are looking for an individual contributor who combines:

  • Maintenance, performance tuning or feature optimization on a large production app, with concrete examples involving startup time, memory, smoothness, crashes or ANRs.
  • End-to-end delivery experience: building an app from scratch, independently owning a complex business line within an established app, or delivering a major client architecture build or upgrade.

Requirements: a full-time bachelor's degree or above, 5+ years of Android development, strong Java/Kotlin, practical multithreading and performance-debugging experience, familiarity with modular/component-based architecture, and an app or core product area you have independently owned or led to production. Experience with e-commerce, short video, audio/video or consumer utility apps is relevant; a big-tech background is not required.

Practical use of AI coding tools, international products or IM development is a plus. This is a hands-on engineering role, not a management opening.

If interested, please send a private message with a short overview of a project you owned, the technical problems you solved and the results. Referrals are welcome.


r/androiddev • • 1d ago

Open Source Jetpack Compose version of Fade-out particle

Thumbnail github.com
9 Upvotes

Implemented the Jetpack Compose version of the fade-out particle animation, which was originally released for XML and wasn't supported in Compose at the time.


r/androiddev • • 2d ago

My engineering lead wants to commit API keys, etc to our repository, am I crazy for pushing back on this?

67 Upvotes

My lead wants to make it easier for anyone on the team to spin up the android repository (to make vibe coding easier), and their solution is to just check in all of our API keys into git and do away with the idea of keeping keys and secrets in a separate secrets vault that employees have access to.

At the last few startups I've worked at, we've pulled secrets in CI via environment secrets, and locally via a separate non-VCS file, and injected the keys into BuildConfig. I know BuildConfig is far from bulletproof for bad actors that want to decompile the app, but just checking everything into git "because it can just be decompiled anyway" is setting off all my alarms.

Am I crazy for pushing back on this? What are the best practices for this in 2026? Are people out there really encrypting API keys with KeyStore or pulling API keys from a backend server? How do you handle API keys that the application needs at startup?


r/androiddev • • 2d ago

Open Source I built a draggable fast scrollbar for LazyColumn and lazy grids. One modifier, and it also works on iOS and desktop

26 Upvotes

Compose has no draggable scrollbar for lazy lists on Android or iOS (desktop has one).

There are a few community implementations, but none of the ones I tried handled feeds and chats well: the thumb would jump around when items had different heights, or when the next page loaded.

The hardest part was exactly that last one. When a page loads while you're dragging, the list grows under your finger, so the thumb used to jump away from it. Now the thumb stays where your finger is and only the mapping underneath changes, so you can still reach the end in the same drag.

Usage is one modifier on the list:

LazyColumn(
    state = listState,
    modifier = Modifier.scrollbar(listState),
) { ... }

Works on LazyColumn, LazyRow and both lazy grids.

Stuff I spent most of the time on:

  • dragging feels right even when items have different heights (thumb has a fixed length by default so it doesn't jitter around)
  • infinite feeds. Pass hasMore and the thumb won’t pretend you’re at the end while more pages can still load
  • gesture nav. The thumb is excluded from the back swipe so grabbing it doesn't send you back
  • no recompositions while scrolling or dragging

There's also an optional bubble that shows a letter/date while you drag (with a little haptic tick per section), you can use your own icon as the thumb, and it handles contentPadding, RTL and reverse layouts.

It's Compose Multiplatform so it also runs on iOS and desktop (desktop gets hover + click to jump), but it's just a regular Maven Central dependency if you only do Android.

One thing to know: lazy lists only know the size of items they've already measured, so with really uneven items the jump can land a bit off. It's best on long lists.

Needs Compose 1.10+, minSdk 24. Still 0.1.x so the API might change.

GitHub: https://github.com/Amaanprobably/compose-fast-scrollbar

I also created an easy guide with short videos everyone can follow -

Guide: https://github.com/Amaanprobably/compose-fast-scrollbar/blob/master/GUIDE.md

It's my first library so I'd really appreciate feedback, especially if you have a weird list setup (chats, paging, sticky headers, mixed grid spans).

If something breaks, an issue with a screen recording would help a ton.


r/androiddev • • 2d ago

Play Console told me my R8 optimization was 48%. Turns out years of "scary R8 rules I didn't understand" doubled my DEX size (9.25 MB → 16.7 MB)

31 Upvotes

I have to confess something I suspect a lot of solo Android devs are quietly guilty of: R8 / ProGuard rules terrified me.

The syntax never clicked for me (-keepclassmembers, -keepclasseswithmembers, { *; }, ** vs *, -if...). Every time a release build crashed in production or threw a wall of R8 warnings, I'd panic, search StackOverflow or copy a "standard Android ProGuard file" from an old Medium post, paste in a -keep class something.** { *; }, see the build turn green, and vow never to touch proguard-rules.pro again.

Fast-forward a few years of migrating the app to Compose Multiplatform / Kotlin Multiplatform: my proguard-rules.pro was 437 lines long and still had rules for RxJava, Retrofit, Glide, and android.support — none of which were even in the project anymore.

This week, Google Play Console finally called me out on a new upload:

textImprove your app's memory and performance with R8 optimization
- Low optimization rate (48%)
- Low obfuscation rate (49%)
- Low shrinking rate (49%)

Instead of poking at rules blindly again, I let Gemini (in Antigravity / agy**)** inspect the actual R8 build artifacts (r8-metadata.dat, seeds.txt, and configuration.txt) and audit them against my codebase. Seeing what R8 was actually doing was humbling.

What was actually happening under the hood

In my build's seeds.txt (every class R8 is forbidden from shrinking/obfuscating/optimizing), 9,645 classes were pinned untouched — producing 2 DEX files totaling 16.70 MB.

Over 80% of those kept classes came from just a handful of panic-pasted blanket rules in my own proguard-rules.pro:

  • -keep class com.google.android.gms.internal.** { *; } → 3,416 classes
  • -keep class com.google.android.libraries.places.internal.** { *; } → 2,834 classes (meanwhile places:6.0.2 ALREADY ships 1,783 surgical consumer ProGuard rules of its own!)
  • -keep class kotlin.** { *; } → ~800+ stdlib classes
  • -keep class com.google.android.material.internal.** { *; } → 221 classes
  • -keep class com.firebase.ui.auth.** { *; } → 192 classes (my own reflection workaround only touched 3 specific classes!)
  • -keep class com.google.android.play.core.** { *; } → 140 classes
  • Plus -keepclassmembers enum * { *; }, -keep class my.app.data.** { *; } (even though kotlinx-serialization-core already ships full R8-friendly rules!), and 100+ lines of dead 2017 library rules.

The cleanup (437 lines → 59 lines)

We checked every library's bundled consumer rules in configuration.txt, grepped the codebase for every actual Class.forName / ServiceLoader call, and replaced the 437-line graveyard with ~59 surgical lines:

  1. Crashlytics line numbers (-renamesourcefileattribute SourceFile, -keepattributes SourceFile,LineNumberTable)
  2. The exact 4 classes/constructors accessed via Class.forName(...) in Application
  3. Coil 3's ServiceLoader target interfaces + constructors
  4. A small block of -dontwarn lines for optional JVM TLS/Ktor classes

Then we verified seeds.txt and usage.txt to make sure reflection targets, ServiceLoader entries, and kotlinx.serialization serializers were all preserved.

Before vs. After (from r8-metadata.dat)

MetricBeforeAfterChange
Optimization rate48.67%86.39%+37.7 pts
Obfuscation rate49.14%87.07%+37.9 pts
Shrinking rate49.13%87.10%+38.0 pts
DEX bytecode16.70 MB (2 DEX)9.25 MB (1 DEX!)-44.6% (-7.45 MB)
Seeded classes9,6451,608-83.3%

(Most of the remaining ~13% comes from com.google.android.recaptcha:18.6.1*'s own AAR consumer rules keeping* recaptcha.***,* play.core.integrity.***, and* okhttp3.***.)*

Bonus plot twist that made me laugh

I uploaded the new .aab to Play Console — the R8 warning disappeared immediately! ...and was replaced by a new Play Console warning:

Your app uses deprecated APIs for edge-to-edge (Window.setStatusBarColor / setNavigationBarColor) starting in sv1.b, uv1.b, wv1.b.

I deobfuscated sv1, uv1, wv1 in mapping.txt:

  • sv1 → androidx.activity.EdgeToEdgeApi26
  • uv1 → androidx.activity.EdgeToEdgeApi29
  • wv1 → androidx.activity.EdgeToEdgeApi35

They're Google's own Jetpack enableEdgeToEdge() compatibility classes! Before the fix, they were un-obfuscated so Play's scanner ignored them; once R8 actually obfuscated them, Play's static analyzer stopped recognizing its own AndroidX library.

5 things I wish I'd known earlier (to avoid the same trap)

  1. You can check your R8 score locally in 5 seconds. Look at app/build/intermediates/r8_metadata/release/minifyReleaseWithR8/r8-metadata.dat — it literally contains the exact noOptimizationPercentage / noObfuscationPercentage / noShrinkingPercentage numbers Play Console uses.
  2. Group seeds.txt by package prefix. A 10-line Python script counting top packages in app/build/outputs/mapping/release/seeds.txt immediately exposes which -keep rule is quietly locking thousands of classes.
  3. Check configuration.txt before adding any third-party -keep rule. Modern AARs (places, material, credentials, kotlinx-serialization, play-services-*) almost always ship their own surgical rules. Adding a blanket -keep class com.library.** { *; } overrides all of their careful optimization.
  4. Never confuse -dontwarn with -keep**.** -dontwarn just tells R8 "yes, this optional JVM class isn't on Android, don't fail the build" and costs 0 bytes. -keep class foo.** { *; } turns off shrinking, obfuscation, and optimization for the entire package tree.
  5. If you inherited a "starter ProGuard file" from a blog post pre-2020, burn it. Start from proguard-android-optimize.txt, grep your own repo for Class.forName, ServiceLoader, and reflection-based JSON/Parcelable models, and add only what fails or is explicitly missing in seeds.txt.

Hope this saves someone else from accidentally shipping 7.5 MB of un-shrunk Play Services and Kotlin stdlib bytecode!


r/androiddev • • 1d ago

News Android Studio Rabbit 2 Patch 2 now available

Thumbnail androidstudio.googleblog.com
2 Upvotes

r/androiddev • • 1d ago

News Android Studio Stingray 1 Canary 2 now available

Thumbnail androidstudio.googleblog.com
2 Upvotes

r/androiddev • • 2d ago

Question How did AppBlock get approved to be listed on playstore?

6 Upvotes

I am trying to implement a feature similar to AppBlock's strict mode but Google Play explicitly restricts using Accessibility to prevent users from disabling or uninstalling an app or service.

How is AppBlock still listed on playstore despite violating the above policy.

should i just implement the feature similarly and just submit it for review?

Thankyou

Link of the app i was talking about: https://play.google.com/store/apps/details?id=cz.mobilesoft.appblock


r/androiddev • • 1d ago

15 Days of Google Play Verification: What I Learned

0 Upvotes

Today I finally received the email confirming that my identity was verified by Google Play Console! 🎉

It took 15 days, several attempts, countless emails, and quite a bit of frustration.

I wanted to share my experience because I know other developers, especially those outside the US and Europe, might run into similar problems.

My situation

I'm a developer from Lebanon, and this was a bigger challenge than I expected.

I don't have a passport or driver's license, and the standard Lebanese national ID doesn't have a photo.

Google requested a government-issued photo ID, so finding a document that met their requirements was already a challenge.

I started the verification process through Google's email, scanned the QR code, and submitted my information.

Then came the problems:

  • My identity verification was initially rejected because of a name mismatch.
  • I received different messages from Google Payments and Google Play Support.
  • I wasn't always sure which information or document needed to be corrected.
  • I made several attempts and exchanged multiple emails trying to understand what was wrong.

Eventually, after 15 days, I received the confirmation email.

What I learned and what I'd recommend

After going through this process, here are a few things I wish I'd known from the beginning:

1. Don't waste too much time asking for manual or special reviews.

At least in my experience, contacting support didn't result in a manual review or an alternative verification process. Don't assume support can bypass the standard requirements.

2. You need an acceptable identity document.

There is no workaround for the document requirement. If you don't have a document that satisfies Google's requirements, your verification is unlikely to succeed.

3. Don't keep guessing when something goes wrong.

If your verification gets rejected, understand the exact reason before submitting another attempt. Repeating the process without knowing what's wrong can waste time.

4. A driver's license is probably one of the most straightforward options.

If you have one, it may save you a lot of trouble compared with trying to find an alternative document that meets Google's requirements.

5. Pay attention to the language of your document.

This is something I wouldn't overlook. Make sure the information you enter in your Google account matches the document, including the name in the appropriate language and script. Don't assume that entering a translated or differently written version will be accepted.

What I'd do differently next time

I'd prepare my documents first, double-check that my account information matches them, and contact support before making repeated attempts if something doesn't meet the requirements.

Most importantly, I'd be more patient. The process can take time, and not every email means you need to start over.

Final thoughts

I'm sharing this because I know how frustrating identity verification can be, especially when you're a developer from a country where the available documents don't necessarily fit Google's standard requirements.

I'm not claiming to know exactly what made my verification successful, but I hope sharing my experience saves someone else a few days of frustration.

If you're going through the same process, feel free to ask questions. I'll share what I can from my experience.

And now... my app is one step closer to launch! 🚀


r/androiddev • • 2d ago

Cuttlefish on Mac: Running Android's Virtual Device Framework Natively on Apple Silicon

Thumbnail
engineering.fb.com
20 Upvotes

Can someone explain what is the difference between Cuttlefish and an Android emulator? Don't they both run on QEMU?


r/androiddev • • 2d ago

Discussion Handing Coding without AI , Google or IDE AutoComplete

13 Upvotes

SDE2 with 4 yoe here.
Had an interview round asking me to implement a Simple RecyclerView Paging with dummy data they gave, from scratch on an Empty XML only ( No compose ) Project structure. live

No AI, No Google and ..... No IDE AutoComplete allowed. I was made to switch it off before interview.

Out of the 45 Mins. It Took me 15 Minutes to properly write the xml tags for the layouts. yet it showed error
( have been used to compose ).
had to request to allow me to see the documentation atleast googling. which they agreed.
Still couldn't complete the task,

I was also not supposed to use Paging libraries as they wanted me to implement Paging from scratch on a RecyclerView.
Coulnd't do that either ( Completely my fault here, needed sometime to think how to implement paging from scratch )

I was just able to have an overview of everything. That too because I type a bit fast ( 130+ wpm).
But i was completely demotivated after the interview.

-----------------------------------------

Not blaming the Org. or the method of evaluation here, it is my fault as I have been a bit rusty with hand coding at this level since the advent of AI or before I think. Would have been okay during my college days.

But I wanted to know somethings, people with experience here could really help me.

- is the above method some kind of new norm in the current industry ( I haven't attended an interview in the past 4 years ). Since testing people with take home projects have gotten pointless ?

- If yes. How do I navigate my learning. Not being familiar with AI tools or Not using them significantly slows down the progress.
But at the same time it completely diminishes my ability to hand code by myself or heck even understand my code or even what it happening. feels very .... idk the word.

- is there hope in this industry ? is there any point ? Apologies for the Grimness but
unemployment + the reality check from the interview + everything happening with AI ...
kinda takes the life out...

Any help or opinion or perspective ... Would love it.l


r/androiddev • • 3d ago

Open Source Material 3 Expressive is (finally) stable. To celebrate, I redesigned 8 apps. It took months of work.

164 Upvotes

You heard right. Eight. I started in March (2026). I saw the Kotlin Conf community awards happening and tried to compete. There were 5 people competing in the creativity category (including me): 3 to be selected as finalists (winner only wins prestige, but finalists won travel costs + ticket to conf, in other words, a free vacation!). Unfortunately for me, they didn't choose me. So I stayed here, working. And when I had some free time, I would call GPT 5.3-codex, Claude 4.5 and GLM-5. A lot has changed since then.

This is the story of https://kotlin-reforge.vercel.app/ (the webpage is also open-source)

By April, I had 2 apps (WordKeep and QuietGuard) and part of Keepout (which is the largest and also the one that people showed the most interest). I kept going. For me, it is much easier to develop and design than promote (please follow me on X. I have only ~300 human followers). Instead of pausing to get Play Store working well, README to look good, I just kept working. I found that AI helps in the first 80% tremendously, but the other 20% became as consuming as the 80%.

I filtered popular F-Droid apps that were really ugly/dated. I gave preference for MIT/Apache-2 (only QuietGuard is GPL, and Keepout is much more complete) since I wanted my code to be freely copied without worries. I kept going. I love Calculator++, to this day I think it is the best/easiest calculator app out there. So I forked it and put a fresh paint of colors, shapes, animations and icons. Calcula was born. My own Change Detection app was removed from Play Store because it was old and users gave me 4* because it didn't have a way to check websites in less than 15 min. I added turbo mode, redesigned it (it was hard). Then I had Wi-Fi issues and wow, those apps are ugly. They have a bunch of ads and feels like they weren't updated in the past 15 years. So I used them as inspiration and made Wifi-Weakspot. Then I started using Omarchy and wow, there is no decent solution to access my computer remotely. Sunrise was extremely buggy and rustdesk was ugly/hard to use. So I made my own, Lumina (to be open sourced in the next few weeks, there are some bugs still). I've also been redesigning VLC into KMP and TrailSense. Almost done.

Speaking of KMP, every app is KMP and most got a web demo. Sure, it won't be functional for Keepout (demo), QuietGuard (demo), or Wifi-Weakspot (demo), but who cares, I want you to be able to click around, to see the animations, to ask Claude to copy my components. QuietGuard has a delightful shader when you enable the firewall (just open it and click on the switch you see).

As the number of apps grew, I started taking things more like a factory. When I identified a pattern, I would modularize and isolate so every other app could benefit. First, diagonal-wipe-icon was born (pattern is used in both QuietGuard and Keepout). Then, KMPwright, my own take at wrapping Browser into a more delightful API to help AI agents do anything, from full screen screenshot to running commands.

Finally, I needed README screenshots, play store images, icons. I didn't know what to do. Screenshot Studio was born. It is a mini image editor that allows you to support multiple themes, apps and languages, in a coherent way (so all 8 screenshots have the same fluid background, which some apps do). Sure it is not perfect, sometimes gets repetitive, but it is what I have and it is what I made. I'm using in all my apps and as I struggle or face difficulties, I just update it and it benefits all the apps. The icon part of screenshot studio is very useful to generate everything from Play Store image to monospaced icons to favicons. My agents use it a lot. The 3d part is also fun.

Well, this is what I made this year. This marks my return as an Android developer (yes, technically I had already redesigned SDK Monitor last year, but I redesigned it again). Older people might recognize me, I was popular in this sub in 2017-2018. In 2019 I was in Flutter, in 2022 I was in TypeScript and I'm still in all of them, but I miss Android, I miss Kotlin. I feel this community has a very high technical level that isn't as high as Rust (which makes me look dumb) but much higher than any other I know.

I plan in the coming weeks/months as Play Store approves the apps (Keepout and QuietGuard are still not there) to re-share in this community each app individually (also good to get GitHub stars, they are valuable), so please don't say "oh, you shared that before". Today I'm sharing everything as a preview, I plan to go in deeper detail on each soon (and also finalize Lumina, VLC and TrailSense).

My GitHub webpage has all the demos: https://bernaferrari.github.io/

My personal website has most my projects: https://bernaferrari.com

If you like, please send good comments, follow my on X, star in GitHub the project(s) you liked, follow me on GitHub. Everything helps. As always, if you have any questions, feedback or anything, feel free to comment, dm or ask.

FAQ:

> Did I use AI? Yes, absolutely, a lot.

> Which AI models were used? Every one you can think of. GPT 5.3, 5.5, 5.6, 6 astra/sol/terra/luna, 6.1, 6.2, Opus 4.5/5.5, Grok 4.5/4.6/4.7, GLM 5/5.1/5.2/5.3/5.3-flash. I made diagonal-wipe-icon with GPT 5.3-spark (it was an extremely bad model, like Gemma-level, I only noticed after it was almost done. I noticed it was bad but thought it was the regular model struggling). For app icons and icons inside the apps it is 95% Opus 5.5.

> Who made the video? Opus 5.5. I don't have time for that. I hope it is enjoyable.

> So, anyone can do the same? Well, yes and no. Good luck. I hope you see in the screenshots, videos and web demos that there is a lot of care and polish and even though models help a lot, no models would produce any of those apps (at least not without a human guiding and months of work).


r/androiddev • • 3d ago Bravo

PS1 cd games animation

116 Upvotes

A small side project: a 3D shelf of PS1 games. You can swipe through the cases, open one to see the disc and manual

Source code:
https://github.com/mejdi14/KMPOddScroll


r/androiddev • • 2d ago

The mouse clicks on Android studio stopped working entirely!!!

0 Upvotes

On Android Studio Rabbit 2 | 2026.2.2

2 days ago it started happening on my company MacBook, thought it could be due to a special configuration or something, then I checked on my personal one, same thing.

I can't click or scroll or whatever with my mouse or trackpad.

I tried to submit the bug report and the "Create" button somehow stopped working too.

I doubt it is just me. Has anyone encountered the same issue?


r/androiddev • • 2d ago

Discussion Android Developer Verification for limited distribution doesn't allow you to claim your own personal package if you or someone installed it before

0 Upvotes

Context: I made an app for my own use case.

Now I wanted to put it into limited distribution as a hobbyist (because realistically only I will use something like this, it's too specific to my use case), except, you cannot register a package name that have been seen on Android before with Google.

So if Google scanned your phone looking for all apps and found your personal package ID (presumably as Play Protect), your app is now no longer eligible to be registered for limited distribution, it will throw a warning that "The package name you've entered already exists on Android" in Developer Console:

So... that means if I want to install or update my own app after the verification deadline without using ADB on my devices from GitHub automated builds, even when I'm under the 50 registered devices limit, I have to turn on that switch, because I'm an "unverified developer", when I literally own the thing.