Sessions List

Join droidcon CEO Greg Fawson for some insights on the event and some exciting news about what's next for the mobile dev community.

In this keynote, you'll hear from well-known Android experts about their hot-takes, predictions, wishes and advice about how they expect the Android ecosystem to change and how to best prepare for that future. Join us as they answer the question: Where do you see Android Development in three years, and how do you think developers should prepare for that future? After all experts are done making their pitch for the future...its your turn to ask the questions in a rapid-fire Q&A format.

Lauren Darcey's keynote speech will be live streamed in room Material Meetup

Navigating between screens should be simple, yet it's often a source of complexity. In this live-coding session, we'll explore Jetpack Navigation 3 - a new library for navigation that reduces this complexity and puts you in control. Learn how to create screens, navigate between them and encapsulate your navigation code using this new API. Also learn how to create beautiful, animated layouts that are optimised for the current window size. So whether your app is running on small screens, large screens or in extended reality (XR), it will always provide a delightful experience as users navigate through it.

Compose Multiplatform, the declarative framework by JetBrains for building shared UIs, is now stable and production-ready on iOS – so it’s time to start building! In this talk, you will get an overview of the technology, and see what we’ve done to get to the stable release. This includes the evolution of our APIs, under-the-hood changes, and new tooling that we’re premiering for building Compose Multiplatform apps in your favorite development environments, IntelliJ IDEA and Android Studio. You’ll see that there’s a rich ecosystem available for you that has already grown to cover all major areas of app development. Putting it all together, you’ll see how Compose Multiplatform enables you to write production-grade apps on iOS and Android while reusing much of the knowledge you already have – and you’ll also get some insights into what we have planned next in the journey of Compose Multiplatform, on iOS and beyond.

Firebender is an Android centric coding agent. This means there are quite a bit of custom approaches that we've had to take to make it actually useful for the many android engineers we serve today. Some of those tricks are relevant and give insight into how LLMs "think" about writing Android/Kotlin code. Join us for an in-depth look at the internal workings the Firebender coding assistant. This knowledge can help Android engineers form a good basis for how they can evaluate LLMs and better predict where these coding agents will be in the coming years. Separately, we'll show the limits of our coding agent and how we're planning on addressing these limits going forward. As an added bonus, we'll also talk about how we went about building Firebender, "Cursor for Android engineers", with just three people! https://firebender.com

Asynchronous code can be challenging to debug and optimize, especially when dealing with complex coroutine hierarchies and flow transformations. This session reveals practical techniques for tracking down elusive bugs, optimizing performance, and maintaining reliability in coroutine-heavy applications. Drawing from real production experience, we'll explore advanced debugging techniques, common performance pitfalls, and practical solutions for the most challenging scenarios. You'll learn how to effectively use built-in tools, recognize problematic patterns, and implement proven optimization strategies. Key takeways: - Using kotlinx-coroutines-debug - Using BlockHound - Measuring channel sizes, waiting for coroutines in network clients, and the number of active coroutines - Tracking threads use - Measuring buffer sizes - Tracking and finding memory leaks - Choosing appropriate synchronization - Thread management - Designing concurrency - Proper cancellation use

Compose Multiplatform is gaining serious traction. With iOS support recently declared stable and Android Studio Narwhal introducing @Preview support for shared Composables in common, the ecosystem is evolving rapidly. While @Preview is traditionally used for visual checks during UI development, what if we could transform these @Previews into powerful automated visual tests? That's exactly what we'll explore in this talk. We'll: - Briefly introduce screenshot testing and its key benefits - Show how any Compose Multiplatform @Preview can become an automated screenshot test - Walk through the full process with live coding examples After this session, you’ll have a solid grasp of how to level up visual testing in your Compose Multiplatform projects.

Flutter, React Native, Kotlin Multiplatform, Swift for Android, traditional native—mobile development in 2025 offers more choices than ever. But picking the right tool isn’t just a tech decision—it’s a strategic one that affects your product’s performance, team dynamics, and long-term maintainability. In this roundtable, we’ll compare experiences from across the mobile development spectrum. We'll discuss what tools teams are actually using (and why), how the cross-platform trade-offs have shifted, and what trends are shaping mobile engineering going forward. Whether you’re deep into one platform or navigating the tooling jungle for your next project, this is your chance to share your stack, your lessons learned, and your thoughts on what’s worth betting on. >What cross-platform approach (if any) is your team using in 2025—and how did you land on it? >Where have cross-platform tools helped you move faster—and where have they held you back? >How do you balance performance, native access, and dev experience when choosing your stack? >What has your experience been with Kotlin Multiplatform Mobile (KMP), and how does it compare to Flutter or React Native? >If you were starting a greenfield mobile project today, what would you choose—and what would you avoid?

Synopsis: How we rolled out AI across a 60+ Android team at Qonto - strategy, hands-on experiments, what worked (and what didn’t), and how we made it part of our actual dev flow without slowing things down Abstract: The trend, the industry, or maybe even your CTO - all saying “Use AI now.” Cool. But how do you actually make that work across a large Android team without messing with the dev experience? At Qonto, I manage part of a 60-person Android org working in a large, modular codebase with tight delivery timelines. We knew AI had potential, but things only started to click once we made it part of our existing flow This talk is about how we introduced AI into our Android work in a way that was practical, measurable, and actually helpful. No vendor pitches, no sci-fi promises - just things we tried, what worked, what didn’t, and what we’re doing next. You’ll hear: - How we approached AI as a series of small experiments, not a top-down mandate - Android-specific use cases that showed real value (test generation, CI/CD, reviews, refactoring, screen generation in Compose, and more) - Tactics we used to get buy-in from engineers (and what they ignored) - Metrics we used to measure adoption and actual time savings - What we’d do differently if we started today Whether you’re just starting with AI or already deep in it, this talk shows how to make it work in a big Android team without slowing things down. Takeaways: - A rollout strategy for introducing AI to a large Android team without disruption - Real examples of where AI actually helped in Android workflows - and where it didn’t - How to drive adoption with engineers who are focused on delivery, not tooling - Lessons from experiments that failed, and why they failed - How to think about measurement beyond just “Did they use the tool?”

Growing a great app means tending to it, and Android 16 brings new opportunities for a healthier, more robust codebase. While the August 2026 target SDK requirement for API level 36 is still on the horizon, Droidcon Berlin 2025 is the perfect time to plant the seeds for your app's future success. This talk offers a clear, practical guide to the most significant changes and key enhancements in Android 16 that will help your app flourish. We'll explore how to develop truly adaptive layouts for large screens, as Android 16 moves beyond old restrictions, encouraging flexible and responsive UIs that thrive on any device. Learn about new ways to nurture performance, like the refined fixed-rate work scheduling, designed to keep your app healthy and efficient. Plus, we'll delve into the latest connectivity updates in the Bluetooth stack, including new intents for more robust bond loss and encryption handling, ensuring your app's connections stay strong. Join us to deepen your understanding of Android 16's core changes. You'll leave with actionable insights to gradually integrate these best practices into your development cycle, ensuring your apps are well-rooted and ready to grow with the platform.

Building and testing apps for Android has specific requirements and unique challenges. Accelerating your mobile development process results in lower costs, happier developers, and quicker releases for your customers. Join me as we explore using build cache, parallelization and other critical approaches that drive efficiency in your CI/CD workflows; compare metrics, and learn practical tips to foster faster feedback loops and quicker iteration cycles.

Abstract In today’s mobile landscape, Android apps are prime targets for reverse engineering, key extraction, and tampering, especially with tools like Magisk, Frida, and advanced malware campaigns. This 20-minute talk breaks down the real-world threats Android apps face today and shows how to defend against them effectively, without compromising speed or usability. We’ll move beyond generic advice and focus on what actually works in production, covering advanced obfuscation, anti-tampering, runtime protection, and key management strategies. Whether you're building a high-scale consumer app or a work app, you’ll leave with practical guidance you can apply immediately from development through deployment. Key Takeaways - Learn how attackers use rooting, dynamic instrumentation, and reverse engineering to compromise Android apps. - Understand the limits of ProGuard/R8 and when to apply stronger protections like anti-tampering and advanced obfuscation. - Discover best practices for securing cryptographic keys and sensitive logic inside the app.

In the world of backend distributed systems, the process through which production data to used to answer questions about how your app is performing is called Observability (or o11y for short). The combination of telemetry and metadata goes way beyond monitoring p50s, and allows you to answer questions you hadn't anticipated at instrumentation time. On Android, most devs rely on benchmarking and profiling tools in internal environments to understand performance problems. In production, few have access to anything more than what the Android Vitals dashboard offers. This is partially because the infrastructure to support o11y workflows had been costly to setup and maintain. But with the rise of the open-source o11y platform OpenTelemetry as well as o11y vendors with mobile expertise, this is quickly changing. This talk will be a practical intro (complete with examples) to Observability for a group of devs who, for the most part, have not truly experienced it. It will cover: - How observability is different from crash monitoring and traditional RUM (Real User Monitoring) tools - Using practical use-case, show what you can achieve with o11y when you focused on users - How Android devs can get started in the world of user-focused observability, from startups to big-tech alike - Introduction to the OpenTelemetry project from CNCF and the newly proposed Kotlin API and SDK

Join us in this session to learn how to secure and streamline login access on Android devices and applications across enterprise and shared environments using Zebra’s Identity Guardian solution. In particular, attendees will learn about: - The architecture of the solution - How to implement the available APIs into an Android project, enabling persistent user sessions, including with third-party SSO IdPs - Deployment and customization of the solution using Managed Configurations

Let's take a deeper look at AnimationSpec and learn how to use it to customize animations! With music! Using Compose Multiplatform, we'll go over the different AnimationSpec types we have, and which personalization options they offer. We'll cover topics from how to use AnimationSpec, to how to create your own easing curves. And since animations are meant to be fun, we'll do all of this while creating a music visualizer! After this talk, you'll have a better understanding on how powerful animationSpec is, and how you can use it to create complex and fun animations. Keep it fun, keep it animated! :)

For over ten years, I lived and breathed Android. I knew the ecosystem inside out. Then, I decided to hit the reset button and become a full-stack developer. A scary moment, what was I thinking? This session is the story of that transition, one that is still ongoing. I'll take you through the highs of discovering new technologies and the lows of feeling like a beginner all over again. I'll share the eye-opening "aha!" moments, the skills that transfer, and the ones that don't, the frustrating "WTFs," and the practical lessons learned along the way. I'll also demonstrate how knowledge of Modern Android Development is a competitive advantage in the broader software landscape. It's not a journey away from Android, but a return with a renewed perspective.

What if we could drastically improve the JVM startup time? What if we could start a Kotlin-powered backend in milliseconds? Let's explore some exciting new JVM features like the experimental CRaC (Coordinated Restore at Checkpoint) and JEP 483 (Ahead-of-Time Class Loading & Linking) from Project Leyden, a feature of JDK 24! How fast are they, and how are they different from GraalVM and Kotlin Native? Plus, let's have a look at JEP 515 (Ahead-of-Time Method Profiling) from the brand new JDK 25! Finally, let's go completely wild, and experiment with a crazy idea: Let's see if we can apply these technologies to make our Gradle unit test workflows in Android projects faster as well!

This talk will explore how to simplify the development of AI applications for Android devices using the AI Suite SDK. By abstracting away the complexity, developers can harness edge intelligence to access rich contextual data from mobile device sensors—such as GPS, temperature, and image capture—to derive actionable insights about the environment provided by the capabilities of the Qualcomm Chipsets. Discover how these capabilities can augment frontline workers with a personal digital companion, leveraging agentic AI to automate mundane, repetitive tasks and empower them to focus on more meaningful work, like delivering exceptional customer support.

What is the accessibility focus? And why can't you control it with focus modifiers? Why can't I see where the focus is? And how do I debug focus issues? In this talk, I'll discuss all things focus with Compose. After listening to this talk, you'll know how to improve accessibility for users using the keyboard for navigation, what the difference between implementations for, e.g., screen reader and Switch Access users is, what the most important things to know about focus and accessibility, and why this all matters. The key takeaways of the talk are: - Learn about the differences between accessibility focus and input focus - Understand the requirements for focusable elements - Know why caring about focus is important for Android developers

Kotlin Coroutines simplify asynchronous programming, but that simplicity can mask complex challenges. Developers often run into subtle issues like unexpected cancellations or long-running operations that hurt app reliability and performance. This roundtable will focus on sharing real-world mistakes, troubleshooting strategies, and best practices for working with coroutines effectively. What’s a coroutine-related bug or performance issue you’ve encountered that took you a while to diagnose? How do you handle coroutine cancellations or timeouts in your production apps? Where do you draw the line between using structured concurrency and launching global or unstructured coroutines? What tools or techniques do you use to debug or trace coroutine behavior in complex apps? How do you onboard new team members to ensure they avoid common coroutine pitfalls from the start?

I can guess a few things you might be thinking now. Either I am lying, or I just don't know what technical debt is. Or maybe I am just bad at my job and these opinions will blow up in my face a year from now. Maybe the last one is true, time will tell! But I think a lot of technical debt is a mindset about your codebase. But over the last two years, we have taken our Android app, used by millions of Norwegians, from a place where you could see its legacy as an SDK to a codebase where we can make changes and add features so quickly it can be inconvenient. I think the way we got here is pretty simple: take ownership of your codebase. In this talk, I will explain what that loaded statement means, and how you too can be tech debt free in no time!

Creating an adaptive app is essential to ensuring you are reaching your users across the spectrum of Android devices but how do you get to a point where your app feels and functions beautifully across devices? Do I need to write a complicated architecture? How can I make sure my app behaves well on every surface without writing an infinite number of conditions? In this talk, we’re gonna explore two journeys, through the Androidify and Jetstream apps, that started from the two ends of the spectrum and reached the goal of adapting to different devices , with many tips and tricks along the way. Join us to learn how we got there!

When working on UI, you want to see the results of your code changes as fast as possible. Waiting for apps to rebuild and relaunch, then getting the app to the desired state again only gets in your way. Compose Hot Reload is a new JetBrains project that gives you live updates after code changes when running a Compose app on desktop - so you can see and feel how your app’s behaviour changes, without having to relaunch it at all. And you even get to keep your existing state! In this talk, we’ll experience coding with Compose Hot Reload enabled with exciting live demos, and also learn a bit about how it all works under the hood. If your project doesn’t have a desktop target yet… it might just be time to add one!

Developers want their inner loop to be fast: code, test, repeat. With Gradle, there are no extra steps—you run the test, and it takes care of the rest, whether you’re tweaking a single line of code or upgrading all your dependencies. Gradle’s Configuration Cache is a feature that can significantly speed up the dev loop but its adoption might pose challenges. In this Session we'll walk through the most common hurdles, and learn how the Configuration Cache works. We’ll cover how to migrate gradually to get performance benefits early and how to maximize them later on. Key takeaways: - For those new to Configuration Cache - learn about a new way to speed up the development loop with Gradle - For those already familiar with it - learn about new developments and improvements - Everyone: learn how Configuration Cache works by example - Everyone: learn how to get the most out of Configuration Cache - Everyone: get a collection of recipes for common problems

Learn how to use MATLAB and Simulink to simulate, optimize, and deploy deep learning models to Qualcomm Hexagon NPUs and DSPs. This session walks through a smart speaker audio demo, showing how to generate hardware-ready code, run simulations, and profile performance using MathWorks’ support package and Qualcomm tools.

What’s in a language? What does it mean to be idiomatic? Writing clean, intuitive APIs isn’t just about functionality — it’s about designing interfaces that feel natural and intuitive. With Kotlin and Compose, we have a powerful set of tools and syntax that, when used effectively, can reduce cognitive load and make your APIs both elegant and expressive. In this talk, we’ll dive into the principles of idiomatic Kotlin and explore how they apply to designing Compose APIs. You’ll learn how to leverage Kotlin’s language features, from DSLs and inline functions to advanced type safety and composable conventions, to craft APIs that are a joy to use. By mastering these techniques, you can deliver APIs that not only “work” but truly feel like Kotlin.

As AI tools like GitHub Copilot, ChatGPT, and code-generation models rapidly evolve, developers across the experience spectrum are grappling with how their roles will change. Will AI be the ultimate coding companion, or will it disrupt the craft of software engineering? This roundtable invites developers, team leads, and technologists to share how they’re currently using AI, where they see it helping or harming the development process, and what skills or roles might become more (or less) important in an AI-augmented future. How has AI already changed your day-to-day development workflow, if at all? Do you see AI as more helpful to junior developers or senior engineers—and why? Should developers be worried about job displacement, or is AI just another tool to master? What tasks or responsibilities should developers stop doing now that AI can help? What skills will be most valuable for a developer in an AI-augmented world?

Moving from an individual contributor role to a team lead position is an exciting yet challenging transition—especially for engineers with a strong technical background. How do you redefine your role when success is no longer measured by the code you write but by the impact you have on your team? This roundtable dives into the personal and professional evolution that mobile engineers—particularly Android and Flutter developers—undergo when stepping into leadership. We’ll explore the practical realities of leading without losing technical relevance, managing the tension between coding and coordinating, and fostering a strong, healthy engineering culture. Whether you're a new tech lead or mentoring one, this session is a chance to reflect on what makes a truly effective leader in today’s mobile engineering landscape. What mindset shifts were most important for you when you stopped measuring your success by your code contributions? How do you continue to leverage your technical expertise without becoming the team's single point of failure? What are some common leadership pitfalls you’ve encountered—or witnessed—during this transition? How do you balance being hands-on with empowering others to take ownership and grow? What practices have helped you shape and maintain a strong engineering culture within your mobile team?

Calling All Aspiring Space Adventurers: Join the Elite Crew of the USS Singleton (the Federation's greatest explorer class vessel) Today! Embark on the thrilling adventure of a lifetime with the intrepid crew of the Singleton, as you navigate an uncharted (possibly dangerous) galaxy, where mastering Regex is not just an option—it's a matter of life-or-death! During your travels you'll uncover; not only a deep understanding of Regex itself (from basics to advanced), but also how to wield Kotlin to conquer any pattern matching challenge you face, equipping you with invaluable lifelong regex power! If that excites you, then signing up to the legendary personnel of the USS Singleton is for you! Here are just a few of the Benefits of the Job: * Properly learn Regex - From Amateur to Professional, so that you can actually put the knowledge to use! * Learn Kotlin APIs to work with Regex * Explore the vast cosmos & become an Intergalactic Hero having your name sung through the ages! (...possibly) Due to § 213-B:USSF Mandatory disclosure of hazardous workplaces; we must add: Possible “Challenges” of the role: * Ship may crash, leaving the crew stranded on an alien world * Possible loss of sanity and/or limbs * High chance of death. …But no need to worry, with the Captain & the crew of the USS Singleton, you are in very safe hands…So, what are you waiting for? Become a fabled starfarer today and unlock the secrets of Regex… ... Before it’s too late…

Waiting on builds and pipelines wastes time and kills flow. In this talk, I’ll show how I cut both Gradle build times and CI pipeline durations by 50% on a production Android app, all without introducing new tools or rewriting existing code. We’ll start with Gradle: I’ll break down which gradle.properties changes actually moved the needle, how updating to newer Java and Kotlin versions improved performance, and how a comparison between Groovy and Kotlin DSL surfaced potential future wins. You’ll get a practical look at what worked, what didn’t, and how to measure impact in your own project. Then we’ll move to the CI pipeline: I’ll walk through how I restructured steps to increase parallel execution and reduce total pipeline time, not by adding complexity, but by thinking strategically about the build graph. These weren’t sweeping changes, just focused tweaks with big results. If you’re looking for real-world ways to reduce build and pipeline friction, this talk will give you a toolkit of practical optimizations you can apply immediately. Key Takeaways / Learning Points: - Which gradle.properties settings directly impact build performance and why. - How upgrading Java and Kotlin versions can unlock performance improvements with minimal effort. - A comparison of Kotlin vs Groovy DSL for build scripts — and how Groovy may still offer speed advantages in some cases. - How to redesign your CI pipeline to better utilize parallelism and minimize sequential slowdowns. - A strategy for measuring and iterating on build/pipeline performance using simple metrics and real impact.

The mobile development landscape has long been divided by framework wars: Native vs React Native vs Flutter vs Progressive Web Apps. While traditional comparisons often rely on synthetic benchmarks or oversimplified examples, this talk presents a unique approach: leveraging multiple AI coding agents to build identical, real-world applications across different mobile frameworks, then evaluating the results through objective metrics. This session will demonstrate how various AI agents tackle the same mobile app requirements using Kotlin/Swift (Native), React Native, Flutter, and modern web frameworks. We'll dive deep into the challenges each agent encountered, the quality of code produced, and provide a multi-dimensional evaluation framework that goes beyond surface-level comparisons.

Moving to a single-activity architecture is a well-known Android best practice—but what happens when your app already has 60+ activities, multiple teams working in parallel, complex navigation patterns, and deeply entangled module dependencies? In this talk, I’ll walk you through how we at SumUp tackled this architectural tech debt in our banking app. It wasn’t a greenfield rewrite—it was a carefully planned and executed migration within an actively developed, large-scale codebase. You’ll learn: Why we decided to take on this migration and how we built alignment around it How we approached navigation and module ownership in a fragmented system What architectural decisions we made (and changed) along the way How we handled real-world blockers like inter-module dependencies and feature rollouts What tools, strategies, and communication methods helped us drive this change The tangible impact it had on development velocity, stability, and maintainability This talk offers practical takeaways for any team trying to modernize their architecture incrementally—without stopping the world.

Publishing to Maven Central sounds simple… until it isn’t. In this talk, I’ll share a decade’s worth of lessons learned from publishing open source libraries to Maven Central and other repositories. From GPG key nightmares and Gradle plugin magic to simplify your publishing workflow: those are the tips wish you knew earlier. If you’ve ever fighted with .pom files, staging repositories, or just want to understand how to go from a gradlew publish to GitHub download badge, this talk is for you. Expect incident stories, practical tips, and a series of do’s and don’ts to don’t be miserable when publishing to Central and making your next release smooth and drama-free!

Many engineers hesitate to explore leadership roles due to persistent myths that misrepresent what engineering management actually involves. This session challenges common misconceptions—like the need to constantly promote yourself, the belief that only extroverts can lead effectively, or the fear that saying "no" is a sign of weakness. It also tackles concerns about spending all day in meetings or losing technical credibility. By sharing real-world examples and insights, the discussion aims to clarify what engineering leadership truly entails and help engineers assess whether it aligns with their strengths and values. Let's talk about: What assumptions did you have (or do you still have) about what engineering managers actually do day to day? Do you feel like leadership is only for certain types of personalities? Why or why not? Have you ever held back from pursuing a leadership opportunity because you were afraid it would pull you too far from technical work? What do you think “visibility” means in an engineering context—and is it always necessary for career growth? How do you balance saying “yes” to new opportunities with setting boundaries that support your team’s focus and well-being?

A strong engineering culture is crucial for mobile teams to scale efficiently, retain top talent, and drive innovation. This roundtable will explore strategies for fostering an adaptive, inclusive, and high-performing engineering culture across remote, hybrid, and in-person teams. > What are the most effective ways to document, spread, and reinforce engineering culture in mobile teams? > What common pitfalls can erode engineering culture, and how can leaders prevent them? > What metrics or signals indicate a thriving vs. struggling engineering culture? >What strategies to use for reducing knowledge silos >How to set stretch goals and maintain a healthy balance of context switching to keep the team members engaged and motivated? >Why is the skill/will matrix important when delegating tasks

In this lightning talk, we’ll highlight the importance of monitoring main thread performance. We’ll demonstrate how we enhanced our mobile observability tools at Bitdrift by leveraging JankStats, a useful library for identifying janky frames in your app. We'll also explore the main challenges and key learnings we encountered during our integration of JankStats, along with tips on how to avoid common pitfalls.

Frameworks like Mockito and MockK introduces an invisible abstraction layer with a huge API surface that make your tests complex and easy to break. In the presentation "Beyond the Mockery" on Droidcon Berlin 2023 by Ash Davies he discusses the pitfalls and traps associated with mocking frameworks and how Devs should never mock classes. In this talk we'll pick up where "Beyond the Mockery" ends and put its idea to practice by discussing a few easy to follow patterns to avoid mocks using pure Kotlin to achieve fully testable and mock-free ViewModels and Repositories. Those are battle-tested patterns that are in use in production on a 80+ gradle modules project that have been downloaded more than 3 million times in the PlayStore.

Learning about the latest developments in Watch Face Format v4 Using the new Watch Face Push API to develop Watch Face marketplaces Particularly on the second point, the hope is that Android developers will be enthused and inspired by the opportunities that the Watch Face Push API offers, and will seek to create new marketplace experiences that use it.

Learn how to transform any Android device into a powerful mobile AI sensor hub using Edge Impulse. In this session, we’ll guide you through the complete workflow with sample code, from activating your device’s built-in sensors and cameras to collecting real-world data, training machine learning models, and deploying them for real-time inference. You’ll discover how easy it is to bring machine learning to the edge without the need for purpose-built hardware, enabling you to deploy AI directly to Android apps and solve real-world problems using just your phone. The same process can be applied to Android wearable devices as well. We’ll showcase practical applications such as visual anomaly detection in manufacturing, motion and fall detection for wearables, and predictive maintenance for industrial equipment. Whether you're an app developer or an embedded engineer, you'll leave equipped to prototype your own edge AI solutions on Android devices without needing advanced AI expertise. Join us to accelerate your journey into edge intelligence! What to bring: A decent Android phone. No need for super advanced processors or hardware. Laptop with Android Studio installed Edge Impulse account (free to create) Preparation: Download Android Studio and register at edgeimpulse.com before the session. Is it a step-by-step walkthrough? Yes. It will be. We will also give sample code on accessing sensors and how to use Edge Impulse platform to train AI model and how to deploy them on Android devices via Android studio apps. What makes this a workshop? It is a step-by-step walkthrough guide on building Android apps that integrates AI. Developers can leverage any Android phones that have decent hardware. We will

As applications grow more complex, traditional testing struggles to keep up. Agentic apps—AI-powered autonomous agents—are changing the game by dynamically generating tests, diagnosing failures, and adapting to evolving user behavior. This talk explores how these intelligent systems integrate into QA workflows to boost test coverage, reduce manual effort, and improve release confidence. Learn how agentic apps are enabling a new era of scalable, adaptive, and intelligent testing.

Learn how to integrate in-app purchases into your Android app with minimal friction and maximum impact. In this talk I will explore the most effective monetization strategies from subscriptions to one-time purchases, showing you when to use each. You'll also discover key considerations around pricing, user experience, and compliance to set your app up for sustainable revenue growth.

In this talk, we will explore the importance of performance optimization in mobile app development and discuss common performance bottlenecks that can lead to issues such as ANRs and frame drops. We will then look into approaches to identify and address these issues. Attendees will learn best practices for optimizing UI rendering, data processing, memory management, as well as strategies for measuring the impact of micro-optimizations on app performance and perceived performance for users. The presentation will show real-world examples (based on experiences in large-scale applications, but turned into “generic” examples to make them applicable to other apps) of micro-optimizations (e.g. layout strategies, parallelization, caching), and their impact on a global user base. By the end of this talk, attendees will have a solid understanding of how to identify and address performance issues in their own Android apps, leading to faster, more responsive and more engaging user experiences.

Perfetto is one of the most powerful performance tracing tools Android developers have — but it’s also one of the most underused. In this talk, I’ll show you how to unlock its full potential. We’ll walk through real-world Perfetto traces and learn how to: - Capture and view traces from release builds (via traceur, adb, or Jetpack tools) - Identify slow startup, janky frames, and frozen UI events - Analyze rendering pipeline delays and heavy thread workloads - Connect traces back to real code in your app You’ll learn how to: - Use markers and trace sections (trace("tag")) in your app - Visualize lifecycle timing, DI setup, image loading, and more - Use Perfetto alongside Firebase Performance and FrameMetrics Whether you’re chasing a mysterious slow start or optimizing Compose performance, this session will help you turn messy timelines into actionable insights.

TLDR; What will you learn: - Why focus on Accessibility? - What's EAA and why it is so messy? - Examples and Lessons learned - How hackers may exploit Accessibility services - How to make the Top App Bar accessible I'll try to add a permissible dosage of memes to make the leaning more comfortable. TLDR; is over! EU Parliament voted that all apps until 28 June 2025 should be compliant with Accessibility Act. (*+5 years transition *kind of*) Many of you are already deep into this process, so in this talk, I’ll focus less on the basics and more on real-world examples and solutions, which I will back up by specific success criteria and legislation within the EAA. Over the past year, I’ve been working intensively to bring my company’s legacy app into compliance. It’s been a deep dive into regulations, guidelines, and scattered resources - a true rabbit hole. The lack of clear, practical guidance makes accessibility compliance both time-consuming and complex. In this talk, I’ll walk you through our journey -highlighting the unexpected challenges, non-intuitive pitfalls, and hard-earned lessons along the way. I’ll also share a surprising statistic that might help you advocate for accessibility when speaking to stakeholders or decision-makers. My goal is to save you weeks of research by giving you practical tips and simple rules and solutions that can get your app 90%+ of the way toward compliance. And maybe, just maybe, I can plant a small seed - one that encourages developers to think more often about people with disabilities, and to make every ticket, every commit, just a little more inclusive.

AI is reshaping how we write code—but for Android developers, the real question is: how do we make it genuinely useful, without slowing down, over-automating, or rewriting our process for the hype? In this roundtable, Android engineers and tech leads will share how they’re integrating AI tools like Gemini, Cursor, Copilot, and others into their Kotlin development workflows—from code generation to test scaffolding, refactoring, documentation, and more. We'll dig into what’s actually helpful in practice, how to avoid tool overload, and how to think critically about where AI fits into the developer experience. Whether you’re experimenting with AI tooling or trying to get buy-in from your team, this is your space to compare notes, ask questions, and learn what’s working (and what’s not) in real-world Android development. Which AI tools (e.g., Copilot, Gemini, Cursor) have you tried in your Android development workflow, and what stuck? What kinds of tasks—test generation, boilerplate reduction, code reviews—have you successfully offloaded to AI? How do you balance AI-generated code with code quality and maintainability in a Kotlin-heavy project? What risks or annoyances have you run into when trying to integrate AI into your daily work? Are your teams using AI collaboratively (e.g. shared prompts, memory banks, pair programming with AI), or is it still an individual tool?

Shipping a mobile app should be fast and reliable—but engineering leaders know how often release cycles are slowed by manual QA, late-stage bugs, and coordination overhead. The challenge: how can teams move faster without compromising product quality or team sanity? This roundtable is designed for engineering managers, tech leads, and mobile platform owners looking to optimize their release pipelines using AI. We’ll explore how AI is reshaping the mobile development lifecycle—from intelligent test generation and automated bug detection to smarter CI/CD workflows and release readiness checks. Whether your team ships weekly or quarterly, this is a space to share practical strategies for improving velocity, reducing risk, and scaling release processes with more confidence. Discussion topics may include: What’s your current release cadence—and what are the biggest friction points? How are you leveraging AI tools for testing, validation, or monitoring today? What’s worked, and what hasn’t? What metrics help you understand release performance and process health? How do you foster trust in AI-assisted QA, especially for mission-critical features? Where should you automate—and where is human oversight still essential? Join peers to exchange insights, ask tough questions, and walk away with ideas you can take back to your team.

Have you ever heard a rant from a developer and felt like you could have said or written it? Have you ever watched a talk, checked out an open source repo, read an engineering blog or listened to a podcast, and had it fundamentally change how you work? This talk is for every developer who's struggled with an invisible problem, thinking we were the only ones, only to have an answer (or key advancement in the right direction) emerge from the community. We'll explore why information sharing—the insights and wins, the misses and flops, and the surprises learned along the way—is the single most powerful force we have to keep our work relevant. I'll make the case for why embracing radical openness-especially in the face of AI-is the best strategy for individual developers and for keeping the Android ecosystem innovative, and show you concrete examples of how you can participate to influence your professional trajectory and the platform's future at large. The Takeaway This session is designed for mobile developers who want to build a career, not just write code, and influence the future of the Android platform. Attendees will leave with a new perspective on their place in the Android community and key learnings on how to leverage the power of shared knowledge. We'll explore why vocalizing pain points, celebrating small wins, and mentoring the next generation of developers are essential for both professional job security and personal satisfaction with real Android community examples of influence. By the end of this talk, you'll feel inspired to interact more with fellow engineers in the developer community and take agency in shaping your professional future and the future of Android yourself.

Over the past 12 years at Square I have investigated hundreds of Android app production crashes and performance regressions. Debugging Android production issues is hard, but there is a method to the madness. In this session, I will share practical tips & a structured approach to tackling these problems. I will walk you through some of the most outrageous bugs I have encountered (including one involving a fridge, a goat, the linux kernel, and a hair dryer), and highlight not just my process but the technical insights I gained along the way. By the end of this talk, I hope you’ll start seeing production issues as intriguing mysteries worth solving, and walk away with a few things you didn’t even know you needed to know.

ViewModels are a lifesaver—until they’re not. In growing codebases, they can become a subtle source of latency and instability. Logic inside a ViewModel can kick off too eagerly, drift across threads, or execute far too late—making it a hidden bottleneck in your app’s startup and rendering paths. This talk dissects how misuse of ViewModel scope, threading, and initialization patterns can degrade performance. We’ll demonstrate how to detect these patterns using traces, logs, and custom metrics, and we’ll share sustainable strategies to keep ViewModels lean, responsive, and maintainable. Ideal for teams striving for long-term stability, responsiveness, and architectural clarity.

In the JVM world, the virtual machine and its class loaders do the heavy lifting of linking and loading our applications with dependencies. When we use Kotlin Multiplatform to produce a native binary, we lose the simplicity of JAR archives and .class files. In this session, we'll explore the differences between how JVM and native platforms handle dependencies. We'll look at some of the common blockers that native platforms throw our way and possible workarounds. We'll also compare dependency management tools used on Apple platforms like CocoaPods and Swift Package Manager to see their strengths and weaknesses. Learn how native dependencies interact, how they are loaded and the unexpected complexities of the native world.

The core use case of the Tractive app is GPS tracking for pets — making the map the most critical part of the experience. But beyond simply showing a location, we draw live paths, show geofences, potential dangers and more. Moving this from our old MVP (RxJava) XML architecture to our new Redux-style approach with Compose came with its challenges. In this talk, I’ll walk you through why we made the switch, how we approached it, what we learned along the way, and what we ultimately gained from the rework.

* The automotive world is going Android Automotive OS (AAOS) across leading brands like Volvo, Ford, GM, BMW, Honda, Nissan and more, the in-car app ecosystem is growing fast. In this session, we’ll kick off with a snapshot of the Android Automotive market: who's using it, how it varies across OEMs, and why now is the perfect time to start building for it. * We’ll dive into how to build AAOS apps using official templates, walk through the distribution options, and discuss one of the platform’s biggest challenges — fragmentation. * You'll also get a look at how COVESA, the leading open alliance in the automotive software space, is tackling fragmentation with the Automotive AOSP initiative. * Finally, we’ll show a real-world developer demo: implementing push notifications in Android Automotive — yes, notifications for cars! See how this works under the hood, and how you can bring similar innovations into your apps.

Have a chat with Developer Advocates from JetBrains about anything Kotlin related on your mind. Language evolution, tooling, development practices, Kotlin Multiplatform and Compose Multiplatform... We're here for all of it!

When 50+ engineers contribute to a rapidly growing codebase, technical debt and executing migrations becomes an organizational challenge. At Qonto, we transformed our tech debt management by moving from vague group responsibility to empowering teams with a way to visualize and prioritize their debt, turning "someone should fix this" into "we’re on it." In this talk, you'll learn how we: - Built a first prototype in just one month with a single engineer without any new new tools, just clever use of existing APIs - Integrated it into our day-to-day processes, making tech health a routine - Designed a Health Score that teams actually want to improve - Orchestrated large-scale migrations with real-time tracking, no more guessing “are we there yet?” - Made debt reduction engaging with intuitive tooling and team-specific dashboards - Expanded the playbook to tackle dependency updates, flaky tests, and beyond We’ll also share hard-earned lessons and take a sneak peek at what's next. Join us to see how teams like yours can cut tech debt while boosting ownership, starting with what’s already in your toolkit.

Mobile application security, especially time spent on applying it, is often seen as a necessary evil. Security tools that are actually effective require additional configuration efforts, and that doesn't always line up with the skillset needed to build great mobile apps. To optimize apps for performance, another set of manual processes is required to configure the build tools. On top of that, even when developers manage to configure these tools, app security and performance improvements are not always guaranteed nor noticeable by the end users. What if the skillset required for using these protection tools would overlap with regular app development skills? What if using these tools would actually remove some of the manual work required to optimise your application and save you time? In this talk we will show how this is now a reality! Attendees will have the following take-aways: * A brief overview of advanced R8 optimisation features and the effort that goes into using them correctly. * Insight in the concept of profile based optimisations, its shared benefits for application protection and the amount of manual work it can prevent. * A demo show-casing how easy it can be to run through a profile based configuration step. Practical and concrete examples of the non-security related benefits of a profile based configuration approach, e.g. automatic R8 baseline profiles, auto-generated keep-rules tailored to your code, order files to speed up native code loading, additional app size reductions beyond R8

Managing a high volume of non-fatal issues is a common challenge for any engineer, often leading to inefficiencies and missed opportunities for improvement. At Qonto, we faced this issue head-on, dealing with over 600,000 non-fatal reports per month through Crashlytics. In this talk, I will provide a look into the strategies we used to effectively manage and leverage these reports. We implemented a robust alerting system, empowering teams to configure and manage alerts independently, promoting accountability and proactive issue resolution. I will discuss how we enhanced the usefulness of non-fatal issues by adding critical context, which led to a significant reduction in the number of reported issues.

With the European Accessibility Act coming into action, making your apps accessible to more users isn't just "a good thing to do" anymore, it becomes law. In this lightning talk I will show some best practices when working with TalkBack, a built in accessibility tool or blind users. The best practices are what I learned over the past year while refactoring a big app of a German telco company. Learn how you can improve the text-to-speech experience and help blind users to navigate your apps. Topics I will cover: - How to group information - How to make it clear what actions are available - Providing context to UI elements - Change how TalkBack reads text to improve clarity - How to highlight changes in the UI - Improve manual testing - TalkBack bugs - and more Tags: Accessibility

Go beyond the phone and discover how to create a truly premium experience for your users across the Android ecosystem of devices - including tablets, foldables, TVs and with a focus on desktop windowing and connected displays.

For many Kotlin developers, Gradle is a mysterious black box - a tool that somehow builds their app. On good days, it just works. On bad days, it becomes a source of endless frustration: trial-and-error, copy-pasting from Stack Overflow, and, more recently, help from our AI overlords. But what if it didn’t have to be this way? What if just a bit of foundational knowledge could make Gradle feel far less intimidating - and maybe even empowering? That’s the goal of this talk. This talk aims to demystify Gradle by giving you a practical understanding of its core concepts. We’ll cover: - What Gradle actually does during a build - How tasks, plugins, source sets, and dependencies fit together - How to debug Gradle scripts and plugins - Lazy configuration and the configuration cache (and how not to break them) You’ll also get concrete tips on how to keep learning Gradle without getting overwhelmed. This talk is for Kotlin developers who want to stop treating their build tool as a necessary evil and start using it with confidence.

Join us to learn how mobile teams are able to achieve world-class Android app quality using an AI-powered mobile observability platform. Designed specifically for mobile environments, this platform proactively identifies performance and stability issues, enabling teams to resolve problems before they affect end-users. You'll gain insights into how advanced AI-driven observability enhances app performance, boosts user engagement, and delivers measurable business value.

You built a beautiful Jetpack Compose UI... but it’s kinda laggy. The animations stutter, scrolling feels off, and you’re not sure where it all went wrong. In this talk, I’ll walk through how I hunt down these performance issues in real apps using tools like JankStats, Layout Inspector, and system tracing. I’ll show you how Compose actually renders under the hood, what triggers unnecessary recompositions, and how to spot the real culprits behind dropped frames. No fluff—just real examples, profiling tips, and practical fixes you can apply to your own project. Whether you're working on a side project or a production app, you’ll walk away with a better sense of how to keep things running at 60 FPS (or as close as we mortals can get).

You call ConnectivityManager.requestNetwork() and boom - Wi-Fi connects. Feels like magic. But somewhere deep in the OS, daemons are dancing, HALs are handshaking, and the Wi-Fi stack is sweating bullets to make it happen. This talk is for anyone who’s ever thought: "Wait… how did that actually work?" We’ll trace the full journey - from the moment you call the WifiManager APIs to the instant your phone says "Connected." Along the way, we’ll break down what’s happening under the hood: who talks to whom, what parts of the system are involved, and how Android makes Wi-Fi feel effortless. If you’ve ever been curious about how Wi-Fi really works beneath the surface, this deep dive is for you.

System design questions like “Design YouTube” or “Build a chat app” are now common in senior Android interviews—but they’re also highly relevant to real-world technical leadership. Whether you’re preparing for your next role or making high-impact decisions on your current team, mobile system design is a must-have skill. In this roundtable, we’ll explore how Android engineers and leaders approach system design—from interview prep to production-scale architecture. We’ll discuss real-world trade-offs in mobile-first systems, share frameworks for breaking down complex design questions, and compare strategies across experience levels and org sizes. Join fellow developers, tech leads, and managers to swap insights, case studies, and templates you can apply immediately—whether you’re building for performance, scale, or clarity in the next big interview. How do you approach open-ended mobile system design questions—whether in interviews or real-life planning sessions? What patterns or frameworks help you break down large, vague problems into concrete components (e.g., for chat, video, or sync)? What are the most common blind spots or mistakes you’ve seen in mobile system design—especially among less experienced devs? How do you factor in mobile-specific concerns like offline support, battery impact, caching, and flaky networks when designing systems? For leads and managers: how do you evaluate system design skills during hiring, and how do you help team members grow in this area on the job?

Everyone’s talking about AI. But how do you actually introduce it into a large mobile engineering team without derailing delivery, bloating workflows, or creating tool fatigue? This roundtable brings together Android and Flutter tech leads, managers, and senior developers to swap lessons on rolling out AI in real-world dev environments. Inspired by a case study from Qonto’s 60+ Android team, we’ll dive into what it takes to move past the hype and make AI adoption stick—across CI, test generation, reviews, UI scaffolding, and more. We’ll talk practical rollout strategies, developer resistance, failed experiments, and measurable wins. Whether you're early in your AI journey or managing adoption at scale, this is your chance to learn what’s working (and what isn’t) from peers doing the same. How are you currently introducing AI tools to your dev team—top-down, bottom-up, or somewhere in between? What mobile-specific use cases (e.g. test generation, Compose/UI code, linting, PR reviews) have actually shown value with AI? What friction have you encountered from engineers? How are you driving engagement without mandating adoption? How are you measuring success—developer happiness, time saved, code quality, or something else? What AI experiments failed for you—and what did you learn from them?

Composing content for the first time has always been a synchronous, uninterruptible process. The performance of this model is not ideal for computationally expensive compositions, affecting lazy layouts and heavy screen transitions the most. In the next release of Compose runtime we are introducing pausable composition that addresses this problem. It enables finer control over initial composition, allowing for much more efficient scheduling. This talk provides a deep technical overview of the feature, discussing implementation details and capabilities it unlocks. You will learn why pausable composition is the hottest new feature in Jetpack Compose and how your apps can benefit from it.

In the past, Android developers struggled with bloated Activities and Fragments. Then MVVM, MVI, and Jetpack Compose helped us push presentation logic into ViewModels, business logic into UseCases, and data handling into Repositories — making the UI layer thin and reactive. But a new problem has quietly emerged: we still tie ViewModels to entire screens, exposing the whole screen state and handling all user intents. As screens grow more complex, ViewModels become longer, harder to test, and harder to maintain. What if we had multiple ViewModels per screen, each tied to a smaller UI component? This leads to two important questions that haven't been answered yet: - Where do you hold the common state that multiple UI components of a screen might need? - How can ViewModels communicate with each other when one needs to update the UI state that another ViewModel observes? Repositories aren’t the answer — they expose domain models and shouldn’t know anything about the UI. Other state holder patterns that have been proposed do not fully address this problem either — they typically manage global or domain state, and they aren't designed to coordinate shared, screen-specific UI state across multiple ViewModels. Clearly, there’s a missing piece in our architecture. Introducing the Mediator Pattern — a pattern that allows you to break a large ViewModel into smaller ones by moving the screen-specific UI state into a Mediator, with each smaller ViewModel deriving and updating only the part it needs. Join this session to see the pattern applied in a real-world Android app and learn how to: - Break a large ViewModel into smaller, independently testable ViewModels, each tied to a smaller component of the screen. - Enable the smaller, screen-scoped ViewModels to reactively communicate with each other through a shared Mediator. - Use Hilt or Koin to scope the Mediator to the screen’s lifecycle, automatically disposing it when the user exits that screen. Whether you’re working with Jetpack Compose or traditional Views, this talk will give you the missing piece your architecture needs — so you can grow your apps without growing complexity.

Sharing code across platforms is a wonderful superpower. But sometimes, sharing 100% of your codebase isn’t the goal. Maybe you’re migrating existing apps to multiplatform, maybe you have platform-specific libraries or APIs you want to interact with, or maybe your platforms need to do slightly different things. The strength of Kotlin on every platform is not just sharing code, but also interop with the platform’s unique APIs. When building multiplatform apps, it pays to think not only about what code can be shared, but also about what code is better not shared, and how to move between them. Using examples drawn from real-world projects, we’ll look at different strategies for architecting the shared and not-shared parts of your codebase, so you’re better prepared to handle those times when a platform-specific solution is the best one.

In this workshop, we address the common challenges faced by developers migrating AI workloads from the cloud to edge devices. Qualcomm aims to democratize AI at the edge, easing the transition to the edge by supporting familiar frameworks and data types.   We'll talk through why ML is best done on device and how to easily select a model for your use case, train (or fine-tune), and then compile for the device of your choice. You will learn how to get started with the Qualcomm® AI Hub, iterate on your model and meet performance requirements to deploy on device. You’ll learn how to use Qualcomm AI Hub and practice through tangible use cases. The Qualcomm AI Hub team will be there to teach you the ins and outs, enabling you to use the platform and bring your ML use case on device quickly and easily.

Android Automotive is approaching the point where it is no longer merely a niche experience - it's a growing platform redefining the in-car experience. With an expanding number of OEMs adopting AAOS - both with and without Google Automotive Services (GAS); the doors to a rapidly evolving ecosystem and innovation is in your hands! In this session, we'll explore: * The current state of the AAOS ecosystem: which OEMs are shipping it, and what versions are being widely adopted. * How Automotive AOSP implementations differ from GAS - and how developers can support both with minimal overhead. * App distribution pathways - what are the entry-points for the automotive world? Let's talk about Appning's Apps Market. * Real insights from validating and launching apps across multiple automotive platforms. * Monetization opportunities on AAOS. Whether you're building media, navigation, communication, or utility apps, this talk will help you understand how to bring your Android experience to the car, and get rewarded for it. Get your experience out of Android Studio, directly into the steering wheel! - "Building and Shipping Android Automotive Apps: From Code to Car in 90 Minutes"

Accessibility on Android isn’t just good UX—it’s now a legal obligation under the European Accessibility Act (EAA). But real compliance goes well beyond passing an automated scanner. In this roundtable, we’ll roll up our sleeves and dig into what EAA compliance looks like in practice for Android developers. We’ll discuss how TalkBack interacts with real UIs, how to properly support font scaling and alternative navigation methods, and why screen orientation and motion sensitivity matter more than you think. Bring your accessibility questions, code samples, or current blockers—whether you’re just starting out or gearing up for an audit. We’ll share tools, techniques, and lived lessons for making apps more inclusive and compliant across Compose, Views, and hybrid setups. How are you currently testing for accessibility—do you rely on tools, manual testing, or both? What’s been the most confusing or surprising part of implementing EAA-related requirements in your Android app? Have you faced challenges making custom components accessible, especially in Jetpack Compose? How do you handle edge cases like font scaling, display size changes, or alternative input methods (e.g., Switch Access, keyboard, Voice Access)? What workflows or team practices help ensure accessibility isn’t an afterthought—but baked in from the start?

This roundtable explores the unique challenge of joining a new team or company as a Staff or Principal Engineer—where you're expected to lead, but the structure, ownership, and legacy might already be deeply entrenched. Unlike earlier roles, Staff+ success often means defining your own lane, identifying unclaimed problems, and building influence without authority. We’ll share experiences and strategies for navigating ambiguity, earning trust, and making impact when you’re not handed a clear backlog. Whether you’re in a Staff+ role now, managing Staff engineers, or aspiring to grow into one, this conversation will offer real-world insight into leading without a script. What helped you (or someone you mentored) find traction when joining a new org as a Staff+ engineer? How do you balance observing vs. acting when you’re new and expected to lead? What are red flags or common traps for Staff+ engineers onboarding into legacy-heavy systems? How do you identify “high-leverage” problems or unclaimed ownership areas in a complex codebase or org? How can engineering managers or directors better support Staff engineers during their first 90–180 days?

What if you built your Android app… without the Android Gradle Plugin? In this talk, we’ll explore how to demystify the Android build process by replacing AGP with a custom, minimal Gradle plugin. From compiling Java/Kotlin sources to invoking AAPT2, D8, and signing your APK — we’ll peel back the layers and rebuild the pipeline from scratch. You’ll learn how Android’s build tools actually work under the hood, how to wire them together with plain Gradle tasks, and why doing it yourself might just be the best way to understand the system you use every day. If you're just used to copy pasting the android gradle plugin extension into your projects, come see what AGP really does for you. By understanding it more in depth you'll walk away being able to better debug and modify your builds, increase your productivity, and level up as an Android developer.

Have you ever wondered how to create your own embroidered patch using an Android app? Are you curious to Brayden the horizon and learn more about another DIY initiative from our Berlin local Android community? Do you want to take home your own embroidered patch, made from a Composable? Great, then welcome to yet another talk from the makers of ZeBadge, but now with even more shenanigans and less batteries needed In this talk we'll guide you through the making of "ZePatch App" that displays custom Composables, let's you interact with a USB drive, and creates a binary representation of that Composable, so a given embroidery machine can execute it an lastly bring it to live in the flesh, ready to be ironed on your favorite fabric. Expect a healing of Android Composable knowledge, a how to in writing to and reading from anm USB drive on Android and a top ten of how to make your own embroidery patch with a machine. (No threads are harmed during this presentation) Join this ride and be ready for our booth exercise in which you can craft your own patch, using Android.

KotlinX Serialization gives you a lot out of the box, but sometimes you need more. In this talk, I’ll walk through how we built custom Encoder and Decoder implementations to support complex state handling in SavedState KMP. You’ll learn what worked, what didn’t, and how to decide if rolling your own codec is the right move for your project.

Get ready to explore the Harman's Ready Link Marketplace, your fast track to launching automotive apps and content! Whether you're a seasoned developer or just starting out, this session offers an in-depth exploration of Harman’s Ready Link Marketplace a scalable platform designed to simplify and accelerate the deployment of automotive applications and content. We’ll cover below topics: Marketplace Architecture & Integration Model: Discover the foundational architecture of the Ready Link Marketplace. Learn about its expanding app ecosystem and how it enables seamless integration of your applications into in-vehicle systems using intuitive SDKs and APIs. Ready CQuence Loop: Gain insights into Harman’s fully virtualized development and validation environment. Understand how it empowers you, as developer, to increase your velocity and reduce time to market. Developer Onboarding & Certification Pipeline: Walk through the technical onboarding process, compliance validation, and automated certification workflows. We’ll also explore how to join closed beta programs to refine user experience and ensure platform compatibility. Monetization & Payment Infrastructure: Explore Harman’s integrated payment platform and the SDKs to enable you monetize your applications and generate revenue effectively. By the end of this session, you’ll have a clear understanding of how to leverage the Ready Link Marketplace to build, test, certify, and deploy high-quality automotive applications with minimal friction Join the Ready Link Marketplace ecosystem  and shape the future of in-vehicle experiences with us.

Following up on the Gradle Configuration Cache session, you can join Mikhail and Alex for an office hours session dedicated to helping you walk through the most common hurdles, and learn how the Configuration Cache works. We’ll help you understand how to migrate gradually to get performance benefits early and how to maximize them later on. Trying to enable Configuration Cache in your own project before the office hours may be helpful to get examples of concrete issues you'll be particularly interested in. Bring your Configuration Cache report with you!

Building effective development teams hinges on prioritizing the developer experience. Poor tooling and inadequate support lead to cumbersome builds and inefficient workflows, creating friction that slows engineers and hinders their ability to deliver value. Join this peer discussion to share and discover practical strategies for boosting developer velocity and satisfaction. > How can we effectively measure the developer experience to pinpoint specific friction points that negatively impact team velocity and satisfaction? > What tools or strategies effectively boost knowledge transfer, reduce cognitive load, and accelerate onboarding? > What are your team's biggest DX pain points with builds, IDE, or CI, and what proven leadership tactics address them? > Where does your team experience the most friction day-to-day (e.g., with builds, IDEs, CI/CD, inefficient workflows)? What practical leadership tactics or tooling improvements have successfully addressed these pain points? > How can engineering leaders effectively quantify the impact of DX improvements on velocity, satisfaction, or overall value delivery to justify necessary investments to stakeholders?