Learn what it takes to help your organization launch and run a successful vulnerability disclosure program (VDP), including what can go horribly wrong (and awesomely right) when working with hackers.

Async and Threading are words that very often scare the developers. Traditionally we have managed some of those tasks with the now deprecated AsyncTask, but that callback oriented way has some limitations. Let's learn how we can refactor our legacy background operations using callbacks for a graceful and very optimized way using Kotlin Coroutines. You will get started with Kotlin coroutines, learn how to perform multiple operations in parallel or performing sequential operations.

This talk will provide developers with insights about building a keyboard, which is a non-traditional Android app. We'll start with how Android keyboards work and then dive into the UX challenges that come with the limited space for displaying views on a keyboard. We'll also explore what happens at each keypress and the performance considerations that need to be factored into building pipelines that can handle them. Finally, we'll look at the strategies Grammarly uses for testing our keyboard by leveraging existing frameworks.

Messaging apps continue to evolve rapidly and push the boundaries of user experiences. When it comes to in-app chat, your users will settle at nothing less than the experiences they are already familiar with in modern messengers. In this session we'll show you how easy it is to build modern messaging features in your app with Sendbird Chat's UIKit SDK.

One of many Android challenges is the good management of the lifecycle of SDK components. Jetpack provides a set of tools to abstract a big part of this for you. However, there’s still a problem: how to recover the state after the system kills the process of your app. Sometimes, people just don’t want to think about it and ignore it. In this talk, you will see different approaches to achieve a proper state restoration post-process kill and why we should care about it. By giving some insights on how lifecycles work, step by step we will compare some solutions, show you how it can be tested, visit the saved state module for ViewModel, and how to integrate all of this using Dagger.

When writing unit tests, we often need to set up representative test data. Sometimes we rely on mocks as it is “easier” or we spend time inputting data manually and suffer the cost of future maintenance. Either way, we usually only cover one path through our app based on assumptions of how our code currently works. What if it were possible to generate your test data using real objects without hard coding fixed values? Today we will look at using random values through “constrained non-determinism” - what it is, why use it, and the new KotlinFixture library.

A lot of Android libraries are being built/shipped by indie devs and companies alike. Everyone wants to start working inside the host application as quickly as possible. This competition has led to many of these Android libraries to implement various possible hack/tricks in order to get up and running inside host Android application as quickly as possible. Eventually leading to bad side effects introduced on the host application side. In this session, you will get to learn about the various ways Android Library developers use to init their code inside the host application. You will also get to understand how these mechanisms work, what pitfalls they bring and where are these employed within an existing Android application. Towards the end of this session, the new and shiny Jetpack Startup AndroidX library will be introduced along with information on how to use it and what it brings to the table to solve the startup mess the Android Library ecosystem is in currently. By the end of this session, you will be all set to build Android libraries that scale and have API which doesn't mess up with the startup of your Android application.

The recent Facebook SDK outages caused thousands of applications that were integrated with it to crash on every boot, launching companies into a frenzy to mitigate the issue and respond to customers. A few weeks prior to the first outage, a similar issue with the Google Maps SDK affected applications which rely on maps such as delivery apps and ridesharing services. Although such outages are never good news, the silver lining is that it draws attention to good software design and process. Join the session to learn preemptive strategies for protecting your application from badly behaving SDKs, including running A/B tests, monitoring for issues in production, measuring the performance impact of SDKs, and more. We’ll also discuss how Bugsnag’s stability management platform can help with some of these strategies and provide complete visibility into every crash caused by an erratic SDK.

With various Android architectural patterns in the mix & the prospect of declarative UI courtesy of Jetpack Compose, we look towards architectures that can better organize and compartmentalize the key segments of an app or feature. In this talk, we will take apart concepts from the MVI architecture used on Android, and the VIPER architecture used on iOS to conceive of a hybrid, one that is conducive to both imperative and declarative UI.

Integrating Amazon State Language into your app will allow you to: * Create apps that maintain parity between Android and iOS without sacrificing native advantages in either. * Facilitates feature team independence. * Maintains data contracts between disparate chunks of code, allowing for dynamic arrangement. * Enforcement of a single architectural ideal reduces "rogue" intra team code approaches.

Kotlin Multiplatform becomes more and more usable by the day. We might not need it every day, but there might also be the moment when it makes sense for everyone to just share that little bit of logic. In this talk, we will be talking about how we can convert a module to be Kotlin Multiplatform-ready in an existing codebase and how we can interact with it on an Android app.

Google’s Play Billing library has come a long way in the past few years. In this session we’ll start by talking about the improvements that have been made in the latest releases of the library. We’ll then focus on common challenges developers face when integrating the library and how to avoid common pitfalls. Lastly, developers using the Unity game engine can now take advantage of the Play Billing library and we'll talk about the process of adding the library to your Unity game.

This is an interactive event, feature engineers from the Android team who will answer audience questions about modern Android development.

In this session I'll demonstrate the power of both Kotlin Multiplatform and emerging Declarative UI frameworks like Jetpack Compose and SwiftUI by live coding the development of an Android and iOS app. I've been exploring these technologies over the last 2 years or so (some related articles at https://johnoreilly.dev/) and hope to show that when combined they provide a productivity sweet spot for the development of mobile multiplatform applications. The shared Kotlin code will also make use of the following multiplatform libraries: - Ktor - Kotlinx Serialization - SQLDelight

What do I need to do to set up a Multiplatform Kotlin app? The answer looks different today than it did two years ago. Many tutorials and samples you find online are out of date, and there’s lots of conflicting advice about how to configure things. With Kotlin 1.4 recently released, it’s a great time to take stock of where things are, and what things you might want to change compared to a year or two ago. Drawing on questions I’ve seen from the community and in consulting work, as well as my experience building one of the early Kotlin Multiplatform libraries, I’ll catalogue some useful tips and tricks for Multiplatform projects. We’ll talk about common pitfalls and useful tools and examples. Whether you’re maintaining a project that’s starting to show its age, or you’re just getting started, we’ll get you up-to-speed on the latest advice.

The unemployment rate is increasing and there is more competition day-by-day in the job market. Many candidates face difficulty standing out or even making it past the resumé review. We can help! In this talk, we’ll walk through a typical hiring funnel from Resumé Review to the dreaded Onsite. And we’ll share what you can do to stand out each step of the way. We’ll answer the following questions for each phase of the funnel: What is the goal of this phase? Who is the audience? What are the do’s and don’ts? Annyce is a software industry veteran with years of hiring experience under her belt. And Wesnie is an Android Developer with expertise in the ins-and-outs of the technical interview process. By the end of this talk, you’ll be ready to land your next gig in tech!

As per Bain and Euromonitor (https://media.bain.com/next-billion-internet-users/index.html), nearly one billion new Internet users came online in between 2013 and 2017 and almost half of them were from 11 developing countries in Asia, Africa and Latin America. For a lot of these users, mobile phones are their first computing device and they are not familiar with most design patterns we take for granted. Over the past year, I have helped IDEO (a global leader in the design space) create the digital confidence (https://digitalconfidence.design/) framework aimed at helping designers and developers build solutions that new internet users love using. I will be going into the details of the framework and how you can leverage it to create an app that these "new internet users" can use confidently. Topics covered: - Who is a "new internet user" - Obstacles new internet users face: Onboarding Navigation Accounts DiscoveryAssistance Voice Visuals Language Transactions Data - How to solve these problems, Inspiration and Provocation (how other apps are solving this effectively) - Introduction to the digital confidence toolkit by IDEO, Google and The Bill and Melinda Gates Foundation

Let's face it: Android builds are slow. What can we do about it? What are the most common build misconfigurations that cause slow builds? How can I improve my sync times? What are some upcoming performance features that will make my builds faster? All these questions and more will be answered in this talk.

Is your app using SharedPreferneces heavily to store persistent data? What is the modern way to store data into shared persistence? What the heck is DataStore? Etc. Etc. Well, the talk will cover all the nitty gritty of modern android development with datastore and migration from the Android legacy SharedPreference API.

This talk will introduce learnings from Facebook’s first explorations using Kotlin Compiler Plugins. Kotlin Compiler Plugins are a powerful tool that can transform your source code inline, and we will provide step-by-step code instruction on how. Kotlin Compiler Plugins, though powerful, aren’t broadly used yet due to lack of documentation and the difficulty of manipulating bytecode. Our talk will explain not only how to write a Compiler Plugin, but also how to easily parse and transform source code as text and avoid the difficulties of working with bytecode. We hope by showing these techniques more engineers will be able to unlock the power of Kotlin Compiler Plugins.

This session includes: - Introduction to StateFlow. - How to adopt StateFlow to app architecture. - How to provide app orchestration using StateFlow + LiveData. - How to test StateFlow implementations. Background: In today's app development, it is common to see Coroutines implementations in our architecture. It is not difficult to learn how to work with suspend functions. And some people have constantly switching from Rx Observables to Flow. But has anyone ever heard of StateFlow? Is it important to know about it? Today there are some companies in Asia with Conservative Engineering Practices. They hesitate to adopt LiveData in Data Layer just because it is coming from Android Framework. But now Kotlin has a solution similar to LiveData which conservatives can adopt: The StateFlow. And it has a great potential to turn your app into a deadly state engine, just like LiveData did!

Android developers spend countless hours dealing with lists of data, and with the vast amount of collection operations available to us (think ‘map’, ‘filter’ or ‘sort’) it’s become easier than ever to manipulate that data into the format we want. But all that processing can come at a cost, as sometimes we sacrifice efficiency in the name of readable and concise code. It would be great if there was a way we could do both - be a good citizen when dealing with data, while also still using all the handy operations that we’ve grown to love... Enter Kotlin Sequences! They offer a different take on iterating through data than a Collection, and in many cases allow you to work with your data more efficiently. Join us as we go through the ins and outs of Kotlin Sequences - what they are, when to use them, and what advantages they offer over traditional collections.

Current trends show that all mobile platforms switch to a declarative approach. Flutter, Jetpack Compose, and even SwiftUi from iOS require us a different way of thinking during architecting and developing processes for our mobile app. In this presentation, we will go through these changes and discuss the pros and cons of this “new” way of creating UI.

There are some topics there is not much if any literature about yet, but topics I consider key. On this talk, we'll cover the compiler and runtime sides of Compose, the nature of Composable functions, effect handlers, composable lifecycles, scoping tasks to those, surviving config changes, navigation with backstack support, integration with already exiting observable state data types, how Compose will influence architecture, and much more.

The Paging library helps to load and display chunks(pages) of data of a larger dataset from local storage or over network, thereby using both network bandwidth and system resources more efficiently. Paging 3 library introduced by Google recently offers significant improvements over Paging 2 library. This talk will cover the following, 1- What’s new in Paging 3(including built-in error handling, refresh and retry mechanism, first-class support for Kotlin, Coroutines, Flow, LiveData and Rx, enabling multiple requests aren’t triggered at the same time, built-in separator, header, and footer support, requests the next page when the user has scrolled to the end of the list) 2- App Architecture with Paging 3. 3- Getting started with Paging 3(Introduction to Paging 3 Components and code walkthrough of an app that uses Paging 3 with Network and Database) 4- Benefits of Paging 3. By the end of this talk, the attendees will be equipped will all information required to get started and use Paging 3 library in their apps.

Come learn about androidx.test! We will talk about Android Test Orchestrator, Truth, AndroidJunitRunner and other parts of `androidx.test`.

Modularizing an app is all the rage, but what about taking it to the next level? SDKs. Have you ever wanted to take a central feature in your app, rebuild it, and publish it as an SDK? Well if so, Melissa, from the Snap Kit team at Snap Inc. is here to talk about doing just that with Snapchat’s Story Player - an SDK that plays Snapchat Stories. This session will cover how the Snap Player SDK (aka Story Kit) was built from scratch to replicate the Snap Player features in a reasonably sized SDK. She will walk through the design of the Snap Player SDK covering some interesting details on features including the preloading, decryption, caching, scaling, rendering of Snaps and transitions between Snaps in a Story. Along the way she will touch on some lessons learned in this process including: - Differences in goals between SDK development and app development - Weighing tradeoffs between desired feature complexity and SDK size - Tips for designing SDKs that are usable for a wide variety of app structures

Privacy continues to be a priority in Android 11. This presentation will help you understand privacy related changes and how to make your app compatible. This includes changes to permissions including one-time permission, storage, package visibility, tooling to help identify private data access, and other new platform APIs.

Android has come a long way since 1.0. In recent years, the team has added new tools, new APIs, new practices... even a new language. What should developers be learning? What should they be using? How does it all fit together, and how does it take us into the bright Android future?

Through 2020 and into 2021, Kotlin Multiplatform for mobile development code sharing will see increasing adoption and maturity. As real teams approach putting code into production, there are real questions that go beyond the simple proof-of-concept level. We have been working with several orgs on bringing KMM to production, and have researched many of these issues. In this talk, I'll discuss the status of bringing KMM to production and touch on some of our findings. Topics include: - Binary size impact - Build and deployment options - Tooling options - Performance - Concurrency - What JetBrains has planned for the future, and how that will impact you... KMM is still very much in the early adopter phase, but many teams are using it in production. Hopefully this talk will help you determine if KMM is right for you now, and how the situation is changing over time.

Lint is a powerful static analysis tool that can be used to enforce coding styles and also find common bugs across a codebase. Google provides a bunch of lint checks by default for Android. In this talk, I discuss some examples of custom lint checks we use on the Tickertape app to enforce out design guidelines. I go through the source code of some Android lint checks and then show how to write a custom lint check. By the end of the talk, the audience will be able to understand how lint works and how they can add custom lint rules to their project.

When developing a library, designing an easy to use API while hiding unnecessary implementation details from clients is fundamental. Let’s look at some API design choices we’ve made for our library Krate, an Android SharedPreferences wrapper.

At what point in the development process do you normally think about your app's security? Despite the best intentions, it can often be a bit of an afterthought. Security by design thinking is about a shift in mindset. It means you develop your application with security as a key consideration at every stage of the process. And the responsibility for its security is shared across the company. The end result? You avoid the vulnerabilities that can creep in when security is only considered at the very end of the process. And you end up with a safer app for your end users. In this session, we'll share our key security by design principles with you that you can use in your own development process.

Join us for a panel discussion from some of the most knowledgeable and experienced Android experts and their experience with scaling up Android builds to many many modules. Bring all the questions you have always wanted to ask build performance, static analysis, prioritizing performance vs. features and more!

Continuous integration and continuous development (CI/CD) are core principles of the DevOps topic - allowing individual developers and development teams to build and release outstanding, bug-free software, even while they sleep. For developers at any stage in their career, DevOps is a topic that cannot be ignored, and the sooner the principles of CI/CD are adopted, the sooner the developer can focus on building amazing software rather than getting bogged down in tracking hard to find bugs or fixing errors in production environments. In this beginner session, we’ll show you how to integrate Travis CI’s test and build automation into an existing Android project, allowing you to take advantage of reduced time from code to deployment. We’ll show you best practices you can implement yourself, common gotchas to look out for and how to fix them, and how build automation eliminates releasing buggy code.

Most content discovery apps have a remotely configurable home page with dynamic rows of content. A fully server-driven page allows product teams to test out different content placements, titles, graphics, and much more. Making this screen performant, configurable, and testable is extremely important as this is the first impression the user has of our app. This talk will explore the implementation details of a screen like this, what lessons were learned from it, and what you need to know before embarking on such a project. We’ll explore techniques to improve the performance of nested RecyclerViews, maintaining scroll state, lazy loading, accurate analytics, and much more. We’ll also dive into how we made the implementation testable, secure, and less prone to abuse.

Getting the “happy path” right with Kotlin Coroutines is pretty straightforward. On the other hand, handling exceptions appropriately when something goes wrong is not that trivial. In this talk, you will learn about the reasons for the complexity of exception handling with Kotlin Coroutines and about all things you need to consider to appropriately deal with occurring exceptions. You will learn when you should use a conventional try-catch clause, and when you should install a CoroutineExceptionHandler instead. You will also learn about the special properties of top-level Coroutines when it comes to exception handling and how they differ when they are starting with launch and async. Furthermore, you will learn all about the exception handling peculiarities of the scoping functions coroutineScope{} and supervisorScope{} and why you should re-throw CancellationExceptions to avoid subtle errors. This talk is for developers that are already familiar with the basics of Kotlin Coroutines but still struggle to understand how exception handling works in detail. By the end of this talk, you will have a better understanding of how exceptions are treated by the Coroutines machinery and how you can handle them appropriately.

"You can’t anticipate everything that’s going to change in the software but you can try to build in enough flexibility that it’s likely to adapt to most changes" Application architecture defines the way we develop, modularise, test, scale, and maintain our application. A good architecture allows us to deal with never-ending stream requirements by providing enough flexibility and solid protection against regression. Igor will introduce the concept of Clean Architecture in the context of Android Development, discuss it's benefits, helps you understand how Clean Architecture fits into modern Android application development.

No it is not a feature, it is a bug! And Android Studio is here to rescue. Android Studio 4.2 includes Layout Inspector and Database inspector which lets you debug and pinpoint issues from database to user interface. Come to this talk to see how to use learn more about new tools and features of Android Studio.

In this talk, you'll be introduced to the most common Android advertising violations. We'll look at how these abuses are implemented and how nefarious publishers are avoiding detection of these behaviors at scale.

Threat modeling allows us to think like an attacker and find security design flaws before the first line of code is ever written. This session will teach the fundamentals of threat modeling and provide you with an oppurtunity to threat model your own application and begin finding potential security threats.

Learn the basics of Android app reverse engineering from Google's Android Security team. We will cover the tools, processes and pitfalls that you need to be aware of to get started, illustrated with examples from the front-lines in the fight against malware.

The Xfinity Android app has an enormous range of features from controlling your wifi network to opening your garage door and viewing security videos. This talk will cover how Xfinity combines the work of hundreds of engineers into a stable app that ships to production every other week. We'll talk about how we work quickly and effectively despite the size of our app, the tools we use, and lessons we've learned on this journey

Unit testing Channels and Flows can be a challenge as they are fairly new. In this talk, I will share with you how to implement and test practical examples from my experience. These examples are testing delays, retries, and errors. I'll also share testing more complex examples such as polling. For each use case, we'll look at how to use features in the coroutines library such as runBlockingTest and TestCoroutineDispatcher. From my journey of using and testing Flows in production, I'll share the challenges I experienced.

Ever wondered why you should try public speaking OR how you can get the confidence to present on a stage  or how you can  speak at a conference?  Conference speaking  usually starts with writing an abstract about a topic that you are passionate  about  or want to tell a story about  which gets reviewed by a conference’s program committee upon submission. If you get accepted, the next steps are  preparing your content & slides ,  practicing, presenting  virtually y uor on stage  and convincing the audience to see your point of view on a subject  matter.  Come to this talk to  learn how you can write abstracts, where  you can  submit them & how you can  practice  being  a public speaker, presenter and  story teller  all in  under  40minutes  from someone who’s spoken at over a dozen conferences.  With this knowledge , you can  apply to  speak at any meetup or  conference, maybe even at  a  DroidCon  near you!

You've implemented swipe-to-dismiss, and your drag-and-drop and pinch-to-zoom features are working beautifully. But how do you make any of this accessible? For example, what about users who cannot see the screen or touch it, or those who cannot perform the pinch, drag, or swipe gestures? How do *they* get to use your app's cool functionality? Enter custom accessibility actions. In this talk, you'll earn about AndoridX APIs that allow you to easily extend your app's functionality to users of accessibility services who might otherwise not be able to properly interact with your app. This talk is intended for engineers and designers and assumes no prior knowledge of Android accessibility.

Controlled rollouts, or canary releases, allow you to release your features to a small subset of your user base at a time to ensure functionality before releasing it to your entire user base. Its a fundamental piece of having an effective CI/CD pipeline, and essential to chaos engineering because you can roll out features to production, test them in production, and ensure functionality and reliability. However, this process on mobile comes with some challenges. How do you propagate feature flagging configuration to mobile devices that don't always have a strong network? As a mobile developer, you want to be able to use the latest flag configuration, but you also don't want to stop someone using the app just because you can't load the feature flag config. In this talk, we'll start with why controlled rollout is important and how feature flags enable you to do it successfully, then we will talk about mobile specifics, and then a demo with React Native.

Nowadays, App modularization is a technique largely adopted that gives lots of advantages. But how to approach it? This talk will not focus on the pro and cons of modularization but instead on the approach and the process to achieve it. In particular, I want to share the approach that I followed to modularize an existing application and a new one. I want also to share the failures and all the struggles that came in my head while approaching the process.

Many Android developers are working in Kotlin nowadays. On Android, your Kotlin source code gets compiled to Java byte code, and eventually to Dalvik bytecode. How is the result different compared to starting from Java source code then? Is it compatible? Can it be as compact? Is it as secure? We'll look at the differences. We've extended our open source code optimizer ProGuard and our protection software DexGuard to fully support Kotlin. We'll now share our experiences and point out what can be important in your apps and in your libraries. We'll demonstrate a new open source tool to view the Kotlin metadata hiding inside your apps. We'll show how to optimize and obfuscate Kotlin libraries in such a way that they remain compatible in other Kotlin projects. Armed with this knowledge, you'll better understand your own Kotlin projects and you can tune them to create more compact and more secure software.

In this talk we will go through the four stages of Android Machine Learning: Design, Find the ML model, Build a ML model, and Implementing ML functionality in your Android app. We will talk about the latest development in ML tooling from ML Kit, Android platform and TensorFlow, and tips on getting the most out of these tools.

Test doubles are powerful tool in developer trying to write unit tests. Mocks allow us to keep system under test isolated so we can check given scenarios and perform assertions on singular piece of logic with ease. In this talk I will dive into fakes, mocks and other test doubles and I will present use cases for each and every one of them. Also, I will share my thoughts about mocking frameworks and give some tips & tricks of how to use them with ease.

Contrary to our hopes, ViewModel lifecycles are not infallible. The Android OS can kill running processes, which means killing your ViewModel and all the state that you’ve saved in it, spelling impending disaster for your Activity or Fragment. Luckily, we have a new tool to maintain a seamless user experience even through process death – SavedStateHandle. This talk will use code examples to demonstrate: • How to use SavedStateHandle to gracefully save and resurrect your ViewModel state through process death • How to leverage Jetpack to automate state restoration with SavingStateLiveData

What developer doesn't occasionally daydream about scrapping their legacy codebase and rebuilding a project from scratch on a completely blank canvas? My team had the opportunity to do just that, with only a couple caveats (6-7 month roadmap, no in-house QA team, and a global pandemic..just to name a few). In this talk I'd like to share the good, bad and ugly of our process - everything from picking an architecture pattern to devising a safe rollout plan for our users - as well as some key learnings we were able to take away from the experience.

One of the first and easiest things we do as Android Developers is rendering a list of items. Commonly, one of the hardest things we do next is trying to animate items in that list in a variety of ways. Ever since Hoford & Roard showcased the possibility of animating a RecyclerView with MotionLayout a lot of people have wondered how to actually implement it. I'll be showcasing how my work has evolved in the past year in this specific vein, the issues I encountered, and new routes forward.

In 2020 COVID sent us home. This event produced a completely different scenario in companies where employees enjoyed fast corporate networks. The optimization in the Build System of teams working remotely has an impact on the speed and productivity of the engineers. Learn how at Tinder we worked in caching strategies to optimize the build speed.

This talk showcases how to use TensorFlow Lite models on Android to create artistic designs. It starts with a brief overview of how AI can be used to assist and inspire the artists and designers in their creative space. You will also learn about open-source computer vision and deep learning tools. Then we dive into details of TensorFlow lite and the end-to-end scenarios of how to make Android apps with ML models for art and design.

UI development on mobile and the web has relied on imperative programming for decades. In this traditional way of programming, both simple and complex user interfaces can become tedious to work with - not only are we more prone to errors and performance issues, but this can also result in a lot of boilerplate. Modern declarative UI frameworks like Jetpack Compose, SwiftUI & React, abstract away the exact implementation and let you describe the UI, it’s behaviour and how it is transformed. This not only reduces boilerplate, but also makes state related changes easier and safer by using state for UI composition. In this talk we will walk you through the differences between declarative and imperative UI development, the benefits they offer and how these modern frameworks have lowered the learning curve by being behaviourally & structurally similar to each other. We will also cover the shift in mental model that is required when adopting these frameworks.

If you're developing mobile apps, you probably know what's one of your most important KPI: Store Rating. In such an environment, speed is key. You want to be able to iterate fast and ship beautiful apps to your users frequently. But with growing mobile teams, this is becoming more and more challenging. The Mobile DevOps imposes a prospective shift to the "classical" DevOps perspective. Tools and processes should be adapted to the mobile release flow. You need to have tools to monitor your application, rollout a feature safely, and react to incident and 1-star reviews. Mobile DevOps engineers to the rescue. They play a fundamental role in adapting your development flow to deliver mobile apps to your end-users. In this talk, I will share my experience as a Mobile DevOps engineer, some of my preferred tools, and some of the lessons learned while building mobile infrastructures.

Jetpack Compose is a new UI toolkit for Android that lets you write less code to build powerful Material applications. It’s currently being developed in the open. In this talk you will learn what Jetpack Compose is and how it can simplify your code, increase reusability, and help avoid bugs.

In this talk, we will share the story of how the developer community is influencing Compose. We will share a brief introduction to what elegant developer experience entails, such as API usability, tooling, and documentation and why they matter. You will hear about how our team conducted developer research to make design improvements to the different APIs and tooling offered in Compose.

Jetpack Compose is our new modern UI toolkit designed to help you quickly and easily build beautiful UIs. It combines the expressiveness of Kotlin with a declarative programming model, can be adopted incrementally and has powerful Android Studio tooling. Compose is now in Alpha, shipping 1.0 next year. Come ask the Compose engineering and Developer Relations teams your Jetpack Compose related questions in this panel.

Come join the Firebase team as they discuss all things Android, Kotlin, and everything in between related to Firebase. This casual session will let you bring your questions and comments about what has or hasn't worked in your apps, and learn straight from the experts at Google about the Firebase platform.

Did you know that 65% of users are visual learners? Visual learning is a powerful tool for communicating complex concepts in constrained spaces, while also improving later recall of that information. More importantly, visual vocabularies can be more inclusive to diverse audiences by using imagery, iconography, typography, color and other navigational cues that transcend languages. And, they improve your own understanding and recall of ideas in ways that can help with public speaking, technical documentation and more. In this talk, I'll review my roadmap for visual storytelling - from sketchnoting to visual metaphors - and walk through the basic techniques you'll need to get started on your own visual storytelling journey. Come learn how you can "sketch the docs" and build skills to make you a better communicator and listener.

Learn the fundamentals of Kotlin Coroutines from the ground up and why they are better than current Java/Android solutions. Will explore Kotlin Flows and how they can be used for reactive programming to simplify handling complex data streams. Key Takeaways: - Fundamentals of Coroutines - Structured Concurrency - Coroutine Channels - Kotlin Flows - Converting callbacks to Coroutines

Vectors. Bitmaps. 3D. 2D. UI. There are soooo many types of graphics available to you when writing a mobile app. This session will provide an overview of different graphics technologies and how to implement them on Android.

In this workshop we will create an application that will take advantage of what dual screen devices provide. We will go through the whole development process of building an app at first designed for single screen mode and we will later enhance it to use two screens on dual screen devices. Together we will learn how you can address those changes in your own apps in order to provide new and amazing dual screen experiences for your users.

This talk will introduce you to dual screen foldable devices like the upcoming Surface Duo mobile device and the possibilities that this form factor opens up for application developers and users. We will share various dual screen UX design patterns relevant to all foldable devices and walk through the various levels of support a developer can make use of to take advantage of large screen mobile devices, both for single- and dual-screen foldables. The talk will go deep into the code that apps can use to enhance their user experiences for dual screen devices, walking through code samples for Drag & Drop, launching activities to the adjacent screen, spanning apps so they use both screens at the same time, and using design patterns such as List/Detail, Companion Pane, Two Page and Dual View, showing how quick it can be to enhance apps with extra user value on foldable devices. The session will end with a guest speaker from the Jira Mobile team (from Atlassian) who will share how they approached dual screen app design and what they have done in code to enhance the Jira app’s user experiences on dual screen foldables.

One of the major refactors in Flutter SDK in 2020 was introduction of Navigator 2.0. New API brings declarative navigation and opens a lot of possibilities for customization. Even though it's not widely available, we can already use some parts of it in the stable channel of Flutter SDK. Learn why and how to use new Pages API and how to transition from current imperative navigation system to brand new declarative realm. You'll learn about the brand new Router widget and how to handle hardware interaction in your Flutter app.