Sessions List

Let's kick off the day right with a quiz show and prize giveaway! Come prepared to answer droidcon, Android, Kotlin and general trivia questions. Prizes for 1st, 2nd and 3rd place winners!

I left Google in March, where I had worked exclusively on the Android team for 14 years. This was not only the end of that job, but the end of my very long tech career. I've worked all around Silicon Valley, in startups, big companies, small companies, and as a contractor, since 1993. After all that time doing similar things, it was time for a change (I'm now in grad school for comedy screenwriting). My journey may not apply to you, since everyone is unique and navigates their own career path. But I'll talk about the things that seemed to work for me, plus other random opinions I have on tech, working, careers, companies, and making time for side passions. Bring your questions. I'll try to shut up and leave time for Q&A.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

THERE HAS BEEN A MURDER! ... (Or whatever the code version of a murder is... like breaking unit tests, a bug maybe?... I dunno!) Together, we will learn how to become a professional and revered investiGITor, who will be able to sniff out and solve any version control offence with the ease and panache of a seasoned detective! Version control software is often a mysterious black-box that we HAVE TO interact with in order to successfully collaborate with others. But what if it doesn't need to be a confusing & complicated enigma? You will learn to probe into the dark recesses of Git and understand its inner workings by learning how to carry out many tasks that you will undoubtedly need to perform at some point in your career. For example: * Ever needed to safely remove a secret that you accidentally stored in the repository? * Ever had your app break, not know why, and then needed to quickly hunt down the exact commit where a bug was introduced? * Ever needed to travel back in time, through history, to stop a crime before it even happens...(sort of)? ...All these things and a bunch more useful & interesting, lesser-known ways to become a masterful git detective and truly understand the most important tool in a developer's arsenal. So come have a little fun with me in this talk, bring the bugs to justice, solve the case of the naughty commit & become a hero by defending the integrity of your codebase!

Let's have fun with animations, gestures and sensors! Using Compose Multiplatform, we'll go over how to create animations using gestures and sensor events for Android & iOS. We'll cover some basics like how to get the device motion and position information, how to track gestures in the screen, and how you can combine them with animations to have fun! After this talk, you'll have a better understanding on how to use the sensor frameworks, how to make your own gesture effects, and how to create interesting animations in an easy way. Keep it fun, keep it animated!

Maintaining a Kotlin library API is different from a regular Kotlin project. We have to care about compatibility when changing the API surface, so that users have seamless experience when updating to the new version. There are many challenges on this journey, some of them are Kotlin specific. In this talk we will walk through some real-life examples and explore various approaches and tools when evolving the API.

On-device machine learning has been steadily becoming more powerful and easy to use, allowing developers to add increasingly incredible features to their mobile apps, such as image generation, object detection, and LLM-based assistants. To help our developers build better apps in less time, Google has released a suite of products under the Google AI Edge umbrella specifically for adding custom and advanced ML features to your apps, regardless of your experience level with machine learning. Come learn how you can add ML to your developer toolkit and prepare for the future of app development.

In the realm of Android development, the main thread is our stage, but too often, it becomes a battleground where performance issues arise, leading to ANRs, frozen frames, and sluggish Uls. As we strive for excellence in user experience, understanding and optimizing the main thread becomes essential to prevent these common performance bottlenecks. We have strategies and best practices for keeping the main thread uncluttered. We'll examine the root causes of performance issues and techniques for monitoring and improving main thread health as well as app performance. In this talk, participants will walk away with practical knowledge on enhancing app performance by mastering the main thread. We'll share proven approaches to eliminate real-life ANRs and frozen frames to build apps that deliver butter smooth experience.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

This talk will use the various Kotlin Multiplatform (KMP) samples I've been working on over the last 5+ years to provide a guided tour of some of the libraries/patterns used within them. It will include overview and examples of how the following KMP/CMP libraries are used in the samples: - Persistence: SQLDelight, Realm, Apollo Kotlin, Multiplatform Settings, Jetpack DataStore - Remote API requests: Ktor, Apollo Kotlin - Dependency Injection: Koin - ViewModel/Component sharing: KMP-ObservableViewModel Jetpack ViewModel, Decompose, Molecule - Navigation: Voyager, Jetpack Navigation - Swift/Kotlin interop: KMP-NativeCoroutines, SKIE - AI: Generative AI SDK - Packaging: Multiplatform Swift Package - Compose Multiplatform: Window Size Class, Coil, KoalaPlot, Compose on iOS It will also cover examples from the various clients which were developed using: - SwiftUI (on iOS, watchOS, and macOS) - Jetpack Compose (on Android and Wear OS) - Compose Multiplatform on Desktop, Web (using Wasm) and iOS (also includes examples of sharing Compose UI across multiple platforms).

Compose is the recommended modern UI toolkit for Android that makes it easy to create beautiful and delightful user interfaces. A new powerful feature of Compose is the Lookahead layout system. Using this new layouting mechanism, we can create powerful layouts that animate fluidly. In this talk, we will dive into the depths of using the new shared element transitions in Compose with feature rich examples. We will also explore how Lookahead works and what changes it brings to the current layout system, and how to take advantage of it for your own animations.

How do you feel about communicating with attendees without actually having to talk? Do like to wear a fancy digital badge that can be programmed? Do you feel both cannot be combined with an Android app? Well then you came to the right talk! We are exploring how we build the software for our digital badge ("ZeBadge") that can not only display your favorite name, but also wirelessly communicate with other badges🆕, to share said name, but also any other information the user chooses. Additionally we'll also talk about the Android app controlling the badge, reading out your wireless encounters and displaying random graphics and names on it: What protocol does the badge use to communicate with the app? How does the same code executed on the Web (KMP + ktor) and a quick reminder of how fancy black and white pixels can be. Come join our wild ride and explore ZeBadge with ZePass! (Only one badge got harmed in the process of creating this talk)

Knowing where to start with app performance is half the battle. Other than that getting your product owners and feature stakeholders to buy in to your performance improvement plans is a widely observed challenge. In this session we'll discuss actionable areas to focus on, why and how to convince your team to invest in performance. There will also be an introduction to the app performance score. With it we made it easier than ever to feed two birds with one scone when it comes to app performance. You get to evaluate relevant areas, we provide a score, an estimate on the room for improvement and actionable implementation guidance to improve your app's marks. Sounds sweet? Join in!

In this talk, we discuss Developer Productivity Engineering (DPE), and why and how large organizations (incl. Google, Meta etc.) are investing heavily into it. We will begin our discussion with a systematic review of DPE approaches in the industry. Then we'll provide insights into the evidence-based approach to DPE Strategy that we've adopted at Europe's largest online fashion store - Zalando. Finally, we will outline how we executed our app DPE strategy, resulting in significant app health and productivity wins, as well as how we translated these wins into tangible business ROI metrics.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Kotlin Multiplatform's new landscape brings new opportunities and new challenges. With Hilt and Dagger out of the dependency injection game on KMP, new contenders rise to take their place as the king. Which new frameworks have the best tech, which one is more mature or have a softer learning curve? You want the ultimate answer to the ultimate question: which one should I use? Come to this talk to find answers to all of these questions and war stories from our experiences using both of these frameworks in multiple projects.

Abstract Almost two years after the first mockups for the new predictive back gestures on Android were released, we finally got all the APIs we need in Android 14 to create our own beautiful transitions in our Apps. I want to give an overview of the new APIs and how they integrate with your Compose UI and Compose libraries like Jetpack Navigation. Lastly, we will explore the possibilities that go beyond the default UI libraries and create our own animations, driven by the Back Gesture. Key takeaways - How does the new Predictive Back Gesture work - Integration of Back Gesture in the common navigation frameworks - Custom transitions and animations, driven by the Back Gesture

In recent years, screenshot testing has become an increasingly popular way to automate UI testing in Android applications, with new libraries and tools emerging regularly. This makes it hard to determine which ones are the best fit for your project. In this lightning talk, we'll explore the most popular screenshot testing libraries and tools, including Google's brand new Compose Preview Screenshot Testing tool. We will highlight their unique features and analyse their pros and cons. By the end of this session, you'll have the knowledge to confidently choose the optimal screenshot testing tools for your projects. Don't miss out on this opportunity to become a screenshot testing Ninja!

Today there are various exciting options for building mobile apps. With options like KMP, Flutter, React Native and many more, developers have plenty of options to explore. However, setting up E2E testing for all of these can be quite tricky, often requiring testers to learn new skills and working across different test suites. This talk will dive into how you can quickly get up and running reliably testing all your platforms (Android/iOS/Web) with a single test suite using Playwright with Appetize's AppRecorder.

Is your app too big? Does it take ages to build and run? Have you done everything to optimize and still you have a frustrating wait? This is where feature runners come in. Don’t build the whole app, just build your feature and run it stand-alone. This talk will explain how we reduced the time for our daily code-build-run-repeat cycles by making miniature apps for the feature gradle modules and eliminating the wait. Tags: Productivity, Build, Test

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

This talk will provide an overview of the enhancements and additions in Kotlin 2.0, including the new control flow engine and frontend intermediate representation and how it helps with language consistency. We will also discuss the long-term vision for Kotlin, focusing on how the upcoming language features, such as context parameters, signature management, and immutability, will support modern software development trends and challenges that we face today in our ecosystem

Join us as we take you behind the scenes of TIDAL's transformation, where we've reimagined our Android app's homepage with the modern beats of Jetpack Compose. This talk will reveal the motivations, challenges, and triumphs of aligning our Android experience with our iOS app, all while enhancing user interaction and architectural design. We'll kick off by exploring why we decided to revamp our UI approach, striving for a cohesive functionality across platforms. We'll give you an inside look at the hurdles we faced and the victories we celebrated during our migration journey, offering an authentic glimpse into the evolution of our codebase. Throughout the session, we'll demonstrate how Jetpack Compose has allowed us to streamline and maintain our code more effectively, boosting developer productivity in the process. You'll learn about the tools and methodologies that propelled our team's performance and the favorable outcomes for our users. Additionally, we'll address the UI performance issues we encountered and the strategies we employed to resolve them, ensuring a smooth and responsive user experience. As we conclude, we'll share practical takeaways and advice for teams contemplating a switch to Jetpack Compose. By the end of this talk, you'll understand the steps to successfully transition to this UI toolkit and how it can elevate your app development. So, get ready to remix your UI development approach with us as we delve into TIDAL's journey with Compose. It's time to press play on a session that will tune you into the positive impact of UI development with Compose.

Join us to know a cross-section of what's new and what's likely to come in Android, including a survey of changes in Android 15 that will make your life easier as well as challenging. This session also includes the top changes you need to do now to prepare your app for what's next.

Testing isn't always everybody's favourite task, but that doesn't need to be the case! Writing tests can be an enjoyable way to practice your coding techniques! But with conflicting opinions on writing test code that is declarative, explicit, terse, concise, and isolated, it can be tough to know how to satisfy all of these whilst still retaining your will to live. I'll be covering a few techniques, and mechanisms, for writing idiomatic Kotlin code that leaves you with a beautiful test case that not only fulfils all this but gives you accurate code documentation for your project.

Recently at mkodo we started building a new framework to help speed up our work and delivery to our clients. Building a framework can not only bring some interesting challenges on the table, like custom global UI variables, but it can also magnify some of the existing pain points (I’m looking at you, navigation). In this talk we will explore some of the challenges we came across during our journey from the architecture to the implementation details, our solutions and learnings. We believe that anyone can benefit from these lessons learnt, from the very juniors to the seniors.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

What if you could just… do iOS development? Kotlin and Compose Multiplatform make it possible! Live coding our way through the evergrowing ecosystem built by JetBrains, Google, and the wonderful Kotlin community, we’ll show you how you can pick and choose well-established tools and libraries that you already know from Android and use them to build cross-platform apps. This includes the addition of new Jetpack libraries such as Navigation, ViewModel, DataStore, and more – and you don’t have to make any compromises when it comes to using platform capabilities, either! Using JetBrains Fleet throughout the demos, you’ll also see the tooling support you get when developing multiplatform applications. You may not realize it yet, but you probably already know how to build apps with Compose Multiplatform – for Android, iOS, and beyond.

This is a talk on recomposition in Jetpack Compose and the myths of too many calls it is followed by. I'll briefly explain the reasons behind recompositions and why they are not as problematic as they may seem. I have prepared numerous examples that illustrate how to minimize its occurrence. I'll share real-life situations we encountered during the redesign of our main screen. I'll delve step-by-step into how I optimized a particle animation without additional memory allocation and how we successfully reduced the number of recompositions on the screen. My practical guide on parameter tuning will be a great takeaway.

Debugging is an underrated skill for every Android engineer. It not only helps us in identifying and fixing issues but also improves the overall learning experience as an individual. In this talk, we will learn from the classic art of debugging to the modern era ways to debug and explore different strategies and techniques for debugging Android code we write. We will cover various topics to help you master the art of debugging, including: - Understanding the importance of debugging in Android development - Exploring different debugging techniques - Debugging Jetpack Compose code - Tips for optimizing app performance through effective debugging By the end of this talk, we will have a solid understanding of how to approach debugging as a skill and be ready for whatever comes our way!

Only ~17% of apps reach $1k in monthly revenue. Learn best practices on crossing $1k MRR and beyond from personal experience building two profitable apps and advice from other successful app founders.

Explore the realm of behavioral analysis tools, their design intentions, practical applications, and standout features (e.g., session recordings, heatmaps, dashboards, ...etc). Gain insights into Clarity’s inner workings and its unique approach to capturing user behavior.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Join us for an exploration into the process of creating a error monitoring API using Kotlin Multiplatform (KMP). We'll showcase how we use the expect/actual API to seamlessly integrate our native Java/Android and Cocoa SDKs into our SDK. Throughout this session, attendees will be guided through practical design methodologies, emphasizing the aspects that enabled a seamless integration across diverse platforms. We'll provide insights drawn from hands-on experiences, detailing the challenges encountered and the solutions that made our shared error monitoring API a reality. Get ready for code snippets and practical use cases.

During this session we'll focus on the initial steps of configuring a remote build cache. We'll integrate Bitrise Build Cache to the CI/CD flows, generate some initial benchmarks and will look at optimising the execution. The session will give you an idea on where you are currently with your CI/CD setup and what could potentially be the next step on your journey to faster builds.

## Abstract Gradle is the de facto standard build management tool for Android apps. Over the time, though, the build logic in the project’s Gradle scripts may become quite messy and often violate the DRY principle of software development. Based on _Herding Elephants_ by Square and the build logic used in the _nowinandroid_ app by Google, we’ll see how so called _convention plugins_ help us develop clean and reusable build logic. You may even publish them to your company’s artifact repository like we did at _adesso mobile solutions_, so that many or even all of your Android apps may profit from centralized build logic. Tidy up your build logic today! ## Key takeaways and learning points * disadvantages of the `buildSrc` folder * advantages of using Gradle _convention plugins_ for your build * best practices when using _convention plugins_ ## Speaker’s experience level with this topic I’m a Senior Software Engineer with a great passion for building Android apps. I gained hands-on experience during consulting and implementing all kind of build pipelines for many Android app projects in the last 10 years. Furthermore, I enjoy sharing my knowledge on this topic with others and thus gave some talks about it. ## Keywords * gradle * convention plugins * CI/CD

The Mobile Threat Landscape is increasing rapidly and Software Engineering and Product Owners are scrambling to close security gaps. This lightning talk will introduce you to the Top Mobile Attacks, OWASP Top Ten Mobile Vulnerabilities as well as Tools and Techniques to make your applications compliant with Cybersecurity Standards like GDPR.

Discover how to enhance your app’s performance with Perfetto! This talk will guide you through the essentials of performance analysis, focusing on tracing techniques. Learn how to record, analyze, and interpret traces to identify performance bottlenecks. The session will cover practical steps for using Perfetto, including code instrumentation and navigating the Perfetto interface. Join me as I explore harnessing Perfetto's capabilities for comprehensive performance insights.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Writing and publishing a library is an easy task. Writing maintainable and compatible library — much harder. In this talk, we focus on writing code in a way that prevents some typical errors connected to library authoring. We learn about binary and source compatibility, how to maintain it from the start, and how to communicate with your users about changes. Also, we take a look at the tools that Kotlin gives library authors.

Level up your testing skills! A strong type safety is a great first defence against bugs. Beyond that, unit tests allow us to catch bugs early in development, and ensure our project will be maintainable in the long run. Also, tests are fun! In this live-coding session, we'll have a look at lots of tricks across the board: How to use Kotlin for our testing advantage, how to keep tests blazingly fast, which great reasons are there to avoid use of mocks, how to find very tricky issues like memory leaks and multiple TestScopes when testing Coroutines, how to test Android APIs, screenshot testing, and much more!

Tired of waiting for vital updates to reach your users? In-App Updates are your secret weapon for delivering lightning-fast fixes, smooth API transitions, and enhanced security – all directly within your app. This talk equips you to master In-App Updates for a thriving app: - Become an update champion: Deliver instant fixes and keep users protected and satisfied. - Navigate API migrations with ease: Ensure flawless user experience with seamless versioning and rollouts. - Unlock developer efficiency: Streamline workflows, reduce friction, and empower users with immediate updates. - UX in focus: We'll explore the impact of In-App Updates on user experience, including best practices for user buy-in. - Strategic updates: Discover optimal update frequency to balance user engagement and retention while minimizing drop-off. Gain real-world insights: - Battle-tested strategies to supercharge both developer and user experience with In-App Updates. - Hands-on implementation: Learn how to effortlessly set up In-App Updates on Android. Who should attend? - Android developers seeking faster, more efficient updates. - Anyone passionate about boosting app security, stability, and user experience. - Developers eager to learn practical implementation tactics for In-App Updates. Join me and unlock the power of In-App Updates! Take your app development to the next level and become an update champion.

Android-based products are booming in all market segments, thanks to their intuitive UI, a large number of existing software components and broad hardware compatibility, making them a great fit for all types of products. However, Google's fast-paced platform development and challenging security requirements often lead to outdated Android BSPs and make OS-level system updates difficult. This is why OS updates are often neglected, with severe security gaps being seen as a future issue or a problem of other parties'. This talk illustrates why planning for OS updates from the start is critical for product builders and stresses the importance of secure update distribution. Attendees will learn about key system-level elements like Android's A/B partitions, Recovery, and UpdateEngine. The talk also covers Over-The-Air (OTA) update types and installation methods, focusing on incremental and seamless updates, and provides insights on how to design a custom OTA update infrastructure. Join Igor to gain practical advice on on the complete journey from building an update package to intalling it on the target device, ensuring security and durability in all your new Android products. Tags: AOSP, OTA, Security, CI/CD

How can one effectively engage with a designer in a collaborative effort? What strategies and methods should be employed when communicating with a designer, and how can one articulate requests and inquiries? In what ways can a designer deliver results that align with your requirements for practical use? Is there room for refining communication skills or expressing thoughts in alternative ways? Are there approaches to integrate a designer into your workflows, fostering an environment where they naturally align their processes with yours for future collaborations?

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Dive deeper into how Gradle plugins and Version Catalogs can resolve dependency and version management challenges in the Poly-Repo universe. This session will demonstrate practical techniques for using these tools to streamline your Android development workflow. From a real-world case study learn: - Benefits and challenges of the Poly-Repo pattern. - Implementing and using Version Catalogs. - Creating, publishing and applying custom Gradle plugins.

Artificial Intelligence is revolutionizing the world, more and more apps are integrating AI, but are we doing it the right way? In this talk, I will explore practical strategies for using AI responsibly in your Android apps. We will start with the “Ugly”, by showcasing a basic implementation and exploring the consequences. We will move forwards by improving our strategy but exposing the “Bad” pitfalls and leaks we could face. To finish, I will walk you through the “Good” strategy to craft secure prompts, leakproof API keys, and build robust architectures for cost-optimized AI integration in your Android apps.

This talk is about how can we ensure that our app binaries are safe and the data transmission and storage is secure. In this brief talk i'm going to cover about below topics and my experience of a PEN and VAPT test feedback of our app: 1. SSL Pinning and the support that networking libraries offer. 2. Shared Preferences, storage , ways to exploit them ( including EncryptedSharedPreferences) and how to secure them 3. Various test strategies ( SAST and DAST) and recommendations. 4. Weakest areas and entry points into android apps (Broadcast receivers, webviews etc.) and how to secure those spots with realtime examples. 5. How to periodically check your app security status and the open source libraries that help us achieve this.

Together we will investigate a case study on BLE Issues in healthcare Android app which I encountered during my work. During the presentation, I'll show the background of the problem, share how I looked for solutions, explain the reasons behind the issues, and talk about what I've learned along the way. Plus, I'll answer the question from the title. Join me to discover what can go wrong when trying to mix BLE with Android.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Let's kick off the day right with a quiz show and prize giveaway! Come prepared to answer droidcon, Android, Kotlin and general trivia questions. Prizes for 1st, 2nd and 3rd place winners!

With the rise of Kotlin Multiplatform, the possibility of expanding to multiple platforms has increased, especially for Android Developers. It's easier than before to build for other platforms. But how to release your app to multiple platforms? In this talk, I will share all the things I've learned around distributing FeedFlow, an Android, iOS, and macOS app built with Kotlin Multiplatform, coming from an Android development background. We will cover the deployment of the binary, automating everything with CI, crash reporting, logging, internationalization, and all you need to know to successfully distribute your KMP app.

Abstract: The more apps scale, the more costly and tedious manual regression testing becomes. In this talk, I will share how we transitioned to automated regression testing in our 100% Compose app, focusing on reliability, developer experience, and cost-effectiveness. Our journey begins by understanding our goals, constraints, and test strategy - what to test and how to do it. Then we’ll take a look at a sample compose UI test and define all of the things missing to achieve our goals. We’ll start by setting app dependencies and opening a screen. Of course, when dealing with an actual screen the basic setup would quickly become too verbose. So we’ll go through defining a reusable way to find and interact with UI components and structure them into hierarchies. Then we’d address mocking backend services, including complex with lots of calls and even websocket connections. We’d see why and how to build a nice DSL on top of MockWebServer to enable any scenario in a readable and maintainable way. Then we’ll follow up with quickly revisiting our tests to make sure they’re stable and discuss common pitfalls that could affect your tests or production code. In the end, we’ll briefly cover our infrastructure and how we run and collect reports to ensure the setup is cost-effective while keeping the best developer experience.

Unlock the full potential of Kotlin Coroutines with a focused exploration of their practical applications in real-world scenarios. This talk will guide you through essential best practices, demonstrate robust patterns for common asynchronous tasks, and show how to synchronize and test coroutines in both the backend and Android worlds.

Remember when Google hit the Reset button to clean up the mess of its Android support libraries? Since then, a ton of new Jetpack libraries have been created. Some are obvious choices, like compose. Others you may not have heard of at all, for example palette and window. Depending on how we count, there are way more than 100 artefacts waiting to be added to our apps. If you are feeling lost you are not alone. In this talk, we'll look at what's there, what's useful, and what's obsolete. And you'll learn about a few true gems.

Android Automotive platform is still in its infancy but gathering progressively more interest both from Automotive OEMs and from App Developers. With more cars hitting the roads with Automotive AOSP, App Developers, OEMs and App Store providers are looking now into monetization opportunities. In this talk, Faurecia Aptoide we’ll explain how to integrate its * Payments SDK to monetize apps: * How to integrate the Payments SDK * How to launch the billing client * How to trigger a purchase flow * How process the payments workflow * How to test payments integration

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Nowadays, Mobile software development focuses on efficient architecture, scalability and delightful UX. Those are quite important topics but sometimes we forget Mobile Development has its roots in Embedded Software Development, which was that branch of software development focused on running code on limited resource devices. Both have diverged, one specialised in mobile apps for smartphones, while the other has transformed more into IoT, industrial and other types of solutions. There was an attempt to bring both together with Android Things. It made Android app development skills transferable for hardware development, letting developers create apps with their existing knowledge and interact with the hardware through “high-level” driver APIs. Unfortunately, it was decommissioned by Google. With the flourishing of technologies like KMP and Compose Desktop, the regular Android developer again has some transferable skills that can be used to develop apps for non-smartphone hardware. In this session I will talk about how to develop a simple app for devices like the Raspberry Pi, covering details like interacting with GPIO, WIFI and Bluetooth communication as well as current issues and workarounds.

In this session we will talk about, - Lessons from the first implementation of Compose based design system at N26 - What are Slot APIs - Migrating N26's existing entity based design system to Slot APIs and why - Some plus and minuses of this approach - Should you migrate to Slots?

Nowadays it’s not anymore a question whether we want to write tests or not. Writing unit tests is not “nice-to-have” it’s an essential part of our everyday job. While that’s already a great step forward, how can we be sure our tests are actually testing something. To check this we all use code coverage tools. In this presentation you will learn how code coverage for Kotlin works, which tools we can use and what are the challenges and limitations of various approaches. You will learn the difference between line, instruction and condition coverage and how to read and interpret coverage results in Kotlin. In the last part of this presentation we will cover the future for Kotlin Code Coverage, what is missing and what can be improved in the future.

This session is dedicated to exploring a lesser-known aspect of Hilt: Extensions (https://dagger.dev/hilt/creating-extensions.html) Extensions offer a mechanism for generating dagger modules using custom annotation processors, allowing us to automate repetitive patterns in Hilt-based projects and make dependency injection even easier. This talk will be exploring 2 such annotations: @AutoBind and @AutoMultiBind, processed with KSP, which can be used to bind implementation classes to interfaces automatically. These annotations can be used to eliminate the boilerplate of writing Dagger modules by hand for every module in a multi-modular codebase, and as a helpful side-effect, help replace mocks with fakes in integration tests.

Embark on a hands-on journey to develop and launch an Android Automotive OS application from scratch in this comprehensive workshop. This session is designed for developers interested in the automotive app market and will cover the entire lifecycle of AAOS app development, from initial design to final upload. Participants will learn to craft applications specifically for automotive use, focusing on interface design, functionality, debugging, and optimization. The workshop will culminate with a live demonstration of uploading the finished app, showcasing the process on an Audi-specific environment. This real-world example provides a vivid insight into how apps integrate with advanced vehicle systems within the Volkswagen Group. Feel free to bring your laptop with Android Studio and follow along!

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

How does the Android Development Experience look like from an outsider's perspective? Developers who have worked with Android for years may have forgotten the ups and downs of Android Development compared to iOS. But as someone who recently worked on an Android project inside the company while being a full time iOS Dev I wanna shed some light on these aspects. With SwiftUI and Compose, the 2 worlds are said to be quite similar. But is this really the case? In this talk I'll talk about my experience switching to Android on short notice and highlight what was great, what wasn't and if I left behind my iOS journey to become a full time Android Developer.

In this session, I will explore the intricacies of real-time communication in Android applications, comparing the traditional HTTP request-response model with more dynamic alternatives like WebSockets and Server-Sent Events (SSE). I will discuss the advantages and use cases for each method, and demonstrate how to implement them in an Android app with a Ktor backend. The session will also showcase an open-source project I've developed as a practical example of these concepts in action. Attendees will learn how to choose the right communication protocol for their app's needs and how to integrate it effectively for a seamless user experience.

If you, like many Android developers, come from a Java background, Kotlin has improved the reliability of your code and your life writing it a lot. Just with the introduction of nullable types much has changed for the better in the Android world. But type safety is not only nullability many of you may have seen a method like this: fun updateTimer(id: Int, minutes: Int, seconds: Int): Timer? It looks perfectly fine on the first glance. I have written methods like this many times. With three parameters all being of the same type however there is no way for the compiler to help in making sure that everybody calls this method in the right way. The compiler will only check if the values are technically correct but it can not prevent users of the method to submit conceptually wrong values, for example milliseconds instead of seconds. My talk will give an overview on how to make code more type safe through the use of existing classes and through adding more and more domain specific types. One example of these types are id classes that make sure you supply a valid timer id to the method above. I will also give an overview of the ways you can handle unsafe data both on a code and on an architecture level. This will help to protect your app from crashes, the next time the backend team promises that: “this field will always contain a valid value”. The last part of the talk will introduce you to the idea of railway oriented programming and show a way to make error cases more explicit and understandable.

Join us for a talk focused on securing Android apps. Explore the security challenges of a classic Android app compared to other frameworks like Flutter, and discover strategies for fortifying your app against cyber threats. Don't miss out on this opportunity to gain insights into protecting your Android app and ensuring its resilience in today's digital landscape.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

According to documentation, blog posts and YouTube videos it is rather easy to go full Compose Multiplatform. The reality is, that it's trickier than it seems and with some downsides that no-one tells you when you start or try to push for it at your company. The takeaway to this talk is how to develop a project with (almost) everything done in Kotlin/Compose, but also pinpointing to things that are either trickier or currently straight up impossible to do with Compose Multiplatform in its current state. I will provide a GitHub project that can be used as source of reference, including a working sample with some of the more tricky parts to implement and this presentation. Also it will be a good starting point if you want to pitch Compose Multiplatform to your company and want to get going for the next project or maybe even mix things up with your current development state. https://github.com/rschattauer/compose_multiplatform This talk will cover: Wizard, Navigation, Resources, Lifecycle, ImageLoading, NativeUI, RealNativeUI, A11Y (VoiceOver/TalkBack), Keyboard, Previews, BackHandler, Modifiers, WindowSizeClasses, Testing, IDE, Migration and how to keep up to date.

What are we allowed to draw on a Google Map using Jetpack Compose? How easy is it to draw Markers? And what about customising them? ✅ Clustering? ✅ Lines? ✅ Paths? ✅ Anything else? ✅ In this talk, I show how to, and how easy it is, from easy to quite hard, to draw above a Google Map instance using Jetpack Compose.

We'll discuss some obvious, yet tricky parts of working with coroutines, explore some real world examples and dive a bit into best practices and anti-patterns, helping you to write testable and easy to maintain code ## Key Takeaways and learning points - Scope and Dispatchers: Learn to wield scopes and dispatchers effectively. Avoid common pitfalls like rogue CoroutineScope() creations, and understand the nuanced differences between scopes and contexts. Discover how to inject scope or dispatcher wisely throughout your codebase to enhance performance and maintainability. - Context and Customization: Delve into the versatility of coroutine contexts beyond dispatchers. Explore custom context creation and utilization beyond just managing threads. Uncover the power of withContext(..) function for dynamic coroutine configuration, including dispatcher switching and context enrichment. - Room and Flow: Navigate the complexities of integrating Room with coroutines and flows. Identify common pitfalls, such as returning flows instead of objects or lists, and learn strategies to optimize performance and avoid potential bugs. - StateFlow Insights: Explore the safe usage of StateFlow.value and distinguish between flowing and static data. Gain insights into when to utilize StateFlow effectively in your codebase for improved code quality and stability. - Avoiding runBlocking: Understand the perils of using runBlocking {} and its implications on application performance and reliability. Witness firsthand the consequences of improper usage, such as crashes and timeouts, through practical demonstrations.

This talk explores the intricate and ever-evolving world of Android security, dissecting both systemic OS-baseband vulnerabilities and high-level application threats. We kick off by investigating critical vulnerabilities in the OS and baseband layers, highlighted by a slew of CVEs that underscore recent security challenges: CVE-2023-41111, CVE-2023-41112, CVE-2022-21744, CVE-2022-21765, CVE-2023-21517, CVE-2023-42529, CVE-2023-42528, CVE-2023-42527, and CVE-2023-30739. This segment underscores the rigorous efforts required from vendors in identifying vulnerabilities, engineering solutions, and deploying patches effectively. We then delve into the attacker's playbook, exploring how vulnerabilities are uncovered and exploited, revealing the sophisticated methodologies and tools utilized by attackers. This transition shines a light on the stark realities and necessities of robust security measures. Shifting focus, the talk examines high-impact vulnerabilities within applications through the lens of the WebP CVE-2023-4863 vulnerability in Flutter's ecosystem. Despite strong security measures by leading tech entities, a broader analysis of numerous Android applications reveals a normal distribution of exposure, indicating widespread risk across the platform. In response, we discuss practical methodologies and "plug and play" security solutions that empower developers to stay updated, adhere to best practices, and effectively shield apps against threats. This comprehensive approach provides a vital framework for understanding and tackling Android security, highlighting the continuous race from dusk to dawn and back in the effort to secure Android systems.

We have been working on an Android Automotive OS project for two years - this is our experience report on technical and organizational difficulties. Description: Since 2021, several of our developers started Android Automotive app development in the context of a big international enterprise company project. We benefited from the AOSP knowledge we have gained in our company throughout a number of AOSP customizing projects we worked on in the past. It helped to identify, foresee and handle some of the possible pitfalls that can occur while working on an adapted AOSP OS. With our contribution to the Droidcon Berlin we want to share our experience we gathered in that journey with the community. The talk emphasis the problems and challenges we encountered especially regarding the following topics: - technical aspects like -- the multi user system and its challenges when e.g. switching users or sharing essential data between users -- new system states like different vehicle states (e.g. driving, parking) or Suspend To Ram enter and exit, welcome and goodbye screens -- since AOSP/AAOS is lacking support of some vehicle specific behavior (like the one mentioned above), one needs to add system components like system services with higher privileges that e.g. broadcasts signals throughout the system. So the Android permission and privilege model needs to be well understood. One also needs to know or look up in AOSP how to circumvent different startup restrictions for apps like e.g. starting services from background or extending the limited amount of manifest declarable Broadcasts. -- limited resources, e.g. during device start up (everyone wants to start their service at the same time) leading to the possibility of missing signals -- limited 3rd party libraries e.g. you might not have the Google ecosystem at hand cause the customer decided against it -- bridging/IPC with low level processing units and bus systems - legal aspects you might not consider in regular Android app development - imprecise or lack of Android platform documentation, e.g. how do App processes behave on user switches? Do they run in parallel like on the phones? No they don’t, but they overlap, which is not quite well documented in AAOS documentation and you will find out the hard way Based on that knowledge we were and are successfully developing apps for our customer. These are currently rolling out world wide in mid to premium class vehicles. Join us for a fun and sometimes bumpy ride into the world of app development for Android Automotive! ---------- Learning points / takeaways: - Pain points most besides common app development challenges -- the multi user system and its challenges -- limited system resources, e.g. during device start up -- new vehicle specific "Lifecycle" states - What one should plan/prepare for when targeting Android Automotive -- a more "customized" platform where coordination and role assignments become more important, meaning: --- AOSP mechanics should be well understood --- coordination of teams from an architecture perspective is beneficial because it avoids re-inventing the wheel throughout the sub teams. -- truth lies in the Source Code - be prepared to dive into AOSP/AAOS sources from time to time

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Any developer writing code with Compose APIs designs Composable functions and components all the time. In this talk, we'll take a look at some highlights from the official guidelines around designing Compose APIs, and learn how we can do a better job of building with Compose.

Level Up Your Android App: Mastering AGSL Pixel Shaders for Incredible Visual Effects! In this talk, we will demystify the art of writing pixel shaders, speaking to beginners and experienced developers. Learn the ins and outs of AGSL syntax, important features, and advanced techniques that will help you create fascinating graphical effects and animations. Discover how seamlessly you can integrate these shaders into your Jetpack Compose UI, enriching your app with stunning background visuals, captivating loading animations, and much more. Practical insights and real-world examples will empower you to effectively use pixel shaders and unleash your creativity. Don't miss this opportunity to master the art of pixel shaders and make your app a visual masterpiece!

In this session we’ll dive into the world of Kotlin Symbol Processing (KSP). This session aims to provide an introduction to KSP and its benefits compared to the Kotlin Annotation Processing Tool (KAPT). The practical portion of this talk will guide you through the process of creating annotation definitions and implementing a symbol processor. We will demonstrate the usage of KSP API and KotlinPoet for generating Kotlin files, providing you with a hands-on experience of working with KSP. Furthermore, we will demonstrate how to use KSP in multiplatform projects. By the end of this talk, you will walk away with a solid understanding of Kotlin Symbol Processing, and practical knowledge on how to leverage KSP in your development workflow.

We all have our secrets, especially when it comes to publishing apps or SDKs online. Sometimes, though, those secrets are unavoidably exposed in your source code. And while you might think they're safe once compiled, the truth is, it only takes a few minutes to decompile your code, revealing everything. Ensuring the safety and stability of your system hinges on concealing your code effectively. This talk explores the significance of obfuscation, covering vital concepts. We'll demystify deobfuscation, clearly differentiating it from decompilation, and dive into practical techniques for unraveling obfuscated Android code. Next up, we'll explore diverse obfuscation approaches, ranging from crafting custom obfuscators to leveraging obfuscation software and integrating native code. Throughout, we'll weigh their respective pros and cons. Once your obfuscation is implemented, we'll provide you with tools to evaluate its effectiveness, offering practical recommendations to guide your choice of approach. Rest assured, you can achieve security without compromising usability or performance.

Discover how Covesa standardizes Android Automotive to make it easy to create applications and new experiences for the automotive; Covesa gathers app developers, car manufacturers, suppliers, and provides specifications and open source code. Join us on this exciting journey!

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

We’ve recently converted the AndroidX Lifecycle libraries (ViewModel, Lifecycle Runtime, and Compose support) to Kotlin multi-platform (KMP). Join this session to learn more about how this process went, what the real-world challenges of maintaining API backward compatibility are, what lessons we learned from working around KMP limitations, and insights to guide you in migrating your own libraries to KMP.

Join me for an insightful session where we'll unravel the art of passing data implicitly between Composable screens in Jetpack Compose. Implicit data passing offers a streamlined approach to sharing data between Composables, eliminating the need for cumbersome callbacks or state management libraries. In this talk, we'll explore practical examples and real-world applications to demonstrate how implicit data passing can simplify your UI code and enhance the maintainability of your Compose-based projects. We'll begin by delving into the fundamentals of implicit data passing in Jetpack Compose, understanding how it enables seamless communication between composables within your application. From there, we'll dive into hands-on examples, showcasing technique for leveraging implicit data passing in a practical application scenario. Throughout the session, you'll gain a deeper understanding of how to use CompositionLocal for your Compose-based applications for flexibility and reusability, harnessing the power of implicit data passing to create modular and maintainable UI components. Whether you're a seasoned Compose developer or just starting your journey, this talk promises actionable insights and practical tips for using implicit data passing in your projects. Key Takeaways: - Understand the concept of implicit data passing in Jetpack Compose - Learn various practical techniques for passing data implicitly between Composable screens and components. - Explore real-world examples of implicit data passing in action, demonstrating how it can simplify your UI code and enhance code readability. - Discover advantages of implicit data passing, promoting modularity and reusability in your UI architecture. - Walk away with knowledge of leveraging implicit data passing effectively in your Compose projects, empowering you to build more maintainable and scalable applications.

What we know about Reflection is shaped by our experiences in the world of Java. In that world, Reflection is a very advanced feature and is even considered harmful by many. But do you know that you use Reflection all the time in Kotlin? It “is essential when using a functional or reactive style” as the Kotlin documentation states. Functions and properties are first-class citizens in Kotlin and so is the ability of their introspection. This talk dives into this world. We’ll go not only through the simple but powerful API but also dig into functionalities like property delegation that uses Reflection. Let’s understand its power. Have you ever wondered how Kotlin’s features are hidden in normal JVM byte code? Let’s walk behind the mirror and use and understand the Reflection package of Kotlin.

If you have ever come across the topic of accessibility, you might have heard that testing your app for accessibility is crucial. However, you might be unsure of how to go about it. What are the tools you can use? Where should you start? In this talk, I will demonstrate how to manually test Android apps for accessibility. I will test an Android app live on the stage and show you what tools to use and how to start. After listening to this talk, you'll know how to perform manual accessibility tests. You'll also learn about some possible causes of common accessibility issues.

The development of innovation in mobility cannot be left only to carmakers. It must also be open to third-party developers who wish to improve vehicle owners’ driving experience.During this talk, we will share our view on in-cabin trends and how the creation of a dynamic, adaptable and connected in-car environment alongside car brands and app developers will help content developers reach millions of connected cars.

Come by the Google Office Hours stand and schedule your 1:1 meeting with members of the DevRel team.

Discover the art and science of developing Android Automotive OS applications across the prestigious Volkswagen Group lineup, including Audi, Porsche, VW, Bentley, and others. This in-depth session will guide you through the multifaceted world of automotive app development, tailored to the unique characteristics of each brand. Learn how to effectively leverage Media Audio systems and Car Templates, navigating the intricacies of development with key industry partners like Cariad and Harman. We will explore essential tools, share expert guidelines for app publication, and provide insights into creating applications that enhance the driving experience across various vehicle platforms within the VW Group.

Jetpack Compose Preview is a powerful tool that provides real-time feedback on how our composables are rendered and even on how they behave and animate in certain conditions. While writing useful previews seems like a straightforward task, there are some things that we need to keep in mind. Preview code won't reach users of your app (hopefully!); however, it's more likely that the author of the preview and future peers as well might have to work with them eventually. This talk will touch on the following topics: - Recap on the main features and limitations of Compose previews - How we can overcome the limitations of @Preview being an annotation - How we can make our previews developer-friendly - What we can use our previews for besides checking how our composables are rendered and how they behave