Many programmers get paid amounts similar to professional athletes, yet pro athletes have entire suites of team doctors fine tuning how they eat, drink, and exert themselves to maximize performance. In contrast, programmers rarely seem to account for how their physical surroundings effect their programmatic output. This keynote will coalesce the most recent medical studies about human concentration and performance and talk about how we can apply them to developer workflows to become more productive and happy at work.

Koin is a pragmatic dependency injection framework for Kotlin/Android developers. In this talk, you will discover how Koin will make your life easier thanks to the power of Kotlin language: from basics to the setup of Android architecture's components, without forgetting the testing part... And of course, how to migrate your "old" Dagger project. You will also learn about the new 2.0 release and some advanced APIs!

Reactive programming has firmly become one of the modern Android developer's tools. More and more teams apply fully reactive architectures for their apps utilizing MVI approach. This plays well for separating OS-independent business logic from presentation layer. And while it can be implemented really nice using Kotlin, what if you want to expand this solid base further and don't repeat yourselves on every platform? What if you want to enter Multiplatformland? Obviously, RxJava is not ready for that journey. But is their really no alternatives?

In this session, you will discover how you can adapt Unidirectional Data Flow for a Kotlin multiplatform project. You will explore mutliplatform alternatives to RxJava, such as Flow from Kotlin team and Reaktive from Badoo, and speak about refactoring a MVI project to untie it from JVM and make it reusable on different platforms.

This is a hands on workshop to learn how to fully test your app, focusing on the view part of the architecture without using instrumentation. In this session, Jorge will share a simple but well-architected application using Android Architecture Components. Then, he will use Robolectric, ActivityScenario and FragmentScenario for writing the tests with you. You will discover how good architecture helps to test, but not from a theoretical perspective, but by actually writing unit tests for the different pieces of the application. This is an important first step towards achieving real continuous integration and improving the quality of your apps.

WORKSHOP PREREQUISITES

• Please bring your laptop with the latest Android Studio installed.

Bringing Junior developers into your team can be a challenge, but it can also be rewarding. Mentoring can benefit both sides: It can help juniors with the most difficult moment in their career, and it can help seniors become better professionals. Come and learn how juniors and seniors can support each other and grow together.

You can benefit from this talk no matter what’s your level of expertise. As a junior, you will learn that you are not alone, that you can stop the impostors syndrome, and to be a better apprentice. As a senior, you will learn the benefits of being a good mentor, and how to become one. Lara will share her experience as a developer who is working on growing up in the career ladder.

Benchmark is one of the new interesting libraries recently released by the Jetpack team at Google. This library allows you to measure the speed of certain parts of your application. This is helpful to validate certain parts of your app that are repeatedly accessed such as going into details of items, or scrolling through an infinite list.

The measurements help you monitor if your app performance is slowing down. Because of this, you can integrate it to your CI. In this session, JB will share with you a real life scenario of benchmarks on the OLX app and show you how you can integrate it in your CI tool.

You don’t need to have any experience with development to get upset when the application you use crashes, or when there is an error on a website that does not let you check out after you spent an hour collecting products into a basket. Having fewer crashes makes the lives of both users and developers better, and it provides significant business value. In this presentation, you will discover the best practices to make Kotlin applications safer. You will explore how to deal with mutability, platform types, why inheritance can be dangerous, when explicit types are important, and much more.

Your relationship with RxJava doesn't have to be complicated. You may have found many ways to use it wrong but it is powerful when used properly.In fact, RxJava can guide you in shaping a sound architecture for your app. To do this, you only have to follow a few but decisive principles.

In this talk, you'll:

• Explore how side-effect isolation can help avoiding bugs.
• Learn how to model your data and share it as one unique stream between your view and your presenter.
• Discover the ways a unidirectional data flow makes adding new functionality easy and safe.
• Look at how you can easily deal with collateral side effects, such as navigation.

After this talk, you’ll be able to write a robust and reactive architecture for your app, taking full advantage of RxJava.

This is a hands on workshop to learn how to fully test your app, focusing on the view part of the architecture without using instrumentation. In this session, Jorge will share a simple but well-architected application using Android Architecture Components. Then, he will use Robolectric, ActivityScenario and FragmentScenario for writing the tests with you. You will discover how good architecture helps to test, but not from a theoretical perspective, but by actually writing unit tests for the different pieces of the application. This is an important first step towards achieving real continuous integration and improving the quality of your apps.

WORKSHOP PREREQUISITES

• Please bring your laptop with the latest Android Studio installed.

In the MVI world, there was a missing piece from the coroutines framework and due to this, it always felt strange to completely adopt coroutines. Recently, with the introduction of Co-routines Flow library, things are not so strange anymore. In this talk Garima will explore the Coroutines Flow library, its need and how it compares with the reactive world. You will also learn to migrate an Rx MVI pattern to use coroutines Flow.

Google's APIs and libraries used for in-app-billing users from inside of your app, are confusing at best. The new star on the horizon is Google Play Billing Library, centered around a BillingClient class. GPBL is supposed to make your life much easier - but does it really?

In this session, you will discover the infrastructure around Google Play Billing Library and its usage. You will briefly explore the setup and basic implementation patterns inside of your app and then look behind the scenes and into the internals and implementation of the library itself. This approach will help significantly in gaining a better understanding of the library developer's intent.

A part of the session will be a close look into and a discussion of the provided samples and the issues they pose. Looking at them with a critical eye it'll be possible to understand what the good and what the bad parts of GPBL are and how to structure your implementation the best way.

You’ve heard, seen or witnessed the buzz around MotionLayout. But what does it look like in real life? What are some of its current limitations? How easy is it to use? Are the demos that you’ve seen actually possible? Or is it all a ruse? In this session, you’ll use MotionLayout to develop an animation taken straight from a crazy designer’s mock-up. A mock-up that you see and crumble at just how long it would typically take you to build it on Android. Throughout this talk, you’ll see some animated goodness and you’ll learn some of the fundamentals of how MotionLayout works. You’ll find out what a MotionScene is and how you can use it to separate your states and transitions from your layout, how to use click and swipe handling to trigger transitions, how you can take advantage of KeyAttributes to tweak animations at certain frames, how to use CustomAttributes to animate certain parts of a View and more! You will leave this session armed with the basic knowledge required to start having fun with MotionLayout and creating your own animations and transitions. And you'll realise that the mad animations or transitions that your designers give you are now possible! To never saying “no” to designers again*! *Ok, sometimes you’ll still have to say no.

Google is bringing a system-wide dark mode to Android Q, and Material Design is evolving to adapt to this new change in the system. Dark theme UIs use predominantly dark surfaces, with sparse color accents and maintaining a high standard of usability while retaining the simplicity and beauty of Material Design. Adapting a dark theme isn’t as simple as swapping light colors for dark ones, however, and this is a common pitfall while first going dark. In this talk, you will discover the edification of developers and designers regarding the nuances of dark theming on Android, the areas that need special focus, the common pitfalls which teams should avoid, and a host of tips and best practices on smoothing the transition.

In this workshop you'll learn how you can improve your Android apps using functional programming, with Arrow. You'll be introduced to simple functional patterns that will help you with things like error handling, persistency or data validation. This workshop is for you if you are curious to see how making your code more functional supercharges your Android apps.

WORKSHOP PREREQUISITES

• Please bring your laptop with the latest Android Studio installed.

One of the tools most commonly used for static analysis, that comes at no extra cost is Lint, so why not take full advantage of it. You can now apply Android Lint to Kotlin modules as well. The number of supported built-in Lint checks is much lower though since not every Lint check that targets Android is also applicable to non-Android projects. But nonetheless, since you do have the possibility to define your own set of styling rules, this increases the readability and efficiency of your code. Plenty of new rules are available in open-sourced projects ready for you to grab, but sometimes you just can’t find something that would match your company’s code-style ruleset. In this session you will explore all the parts of a Lint check and write your own, then have it be statically checked across the project.

Are you more productive at home? To really get something done, do you do home office? If the answer is yes, something is wrong. Most modern offices and company cultures are primarily built to communicate and interrupt. Think, how often do you respond to a message within seconds? How often do you get interrupted by a colleague asking you a simple question, that probably could wait until the next day? Communicating at wrong times is a killer for productivity.

In this talk, Philipp is going to demonstrate and share how to stop this madness. In order to be really productive as a developer, you need long hours of uninterrupted focused work. You will discover the basic principles around deep work, a state of absolute productivity, that most developers would have never experienced. Finally, you will explore how mySugr is building an office and a company culture to maximize productivity for all employees while still inviting frequent communication.

At comparethemarket.com they have explored a number of approaches to animation, including building them using the Android framework, leveraging Airbnb’s animation library Lottie and using video. In this talk, they will show a step by step implementation of each approach and discover their benefits and pitfalls. They will then make recommendations about which approach is best to use in different use cases.

Getting machine learning models ready for use on-device is a major challenge. Drag-and-drop training tools can get you started, but the models they produce aren’t small enough or fast enough to ship. In this talk, you’ll learn optimization, pruning, and compression techniques that keep app sizes small and inference speeds high. You’ll start by discovering flexible model architectures that meet performance and accuracy requirements across devices and platforms. You’ll then learn pruning and distillation techniques to optimize model performance and use quantization tools to compress models to a fraction of their original size. Finally, you’ll explore a practical example of this process as you create an artistic style transfer model that’s just 17kb. All of these techniques will be applied to mobile machine learning frameworks for Android, i.e. TensorFlow Lite.

In this workshop you'll learn how you can improve your Android apps using functional programming, with Arrow. You'll be introduced to simple functional patterns that will help you with things like error handling, persistency or data validation. This workshop is for you if you are curious to see how making your code more functional supercharges your Android apps.

WORKSHOP PREREQUISITES

• Please bring your laptop with the latest Android Studio installed.

Have you ever had an experience where a small voice in your head prevented you from acting on an idea, stopped you from sharing your knowledge or trying something new, or maybe even made you feel like your achievements were nothing special? That voice is more common than you think! In this talk Ana will share with you the basic steps that will help you materialize, deconstruct and take control of that voice, helping you distinguish the useful bits of information that can help you grow from the overwhelming debris and clutter. You will learn how to notice the early signs of its onset and manage the situation to your benefit. Finally, you will learn to use simple tools that will help you recognize and acknowledge your achievements and help yourself and others fight the invisible menace.

Fresco is an open-source library from Facebook that makes it easy for you to display images in your Android apps. In this session, Alexander, a core maintainer of Fresco, will talk about how the library has evolved in-step with its popularity by gaining new features while also losing weight and simplifying Fresco's architecture and APIs. You'll also learn how Facebook have improved image loading performance in small and big apps and how you too can benefit from these developments.

Find out more about Fresco here.

As Android developers, you often work with a backend service. Often in your team, there is an iOS project or a Javascript project, with similar functionality, that is being developed by your teammate developers next door. How fun would it be to write Kotlin code once and share it with all platforms? It would save so much time and effort of implementation and testing! Please meet Kotlin Multiplatform! Although still experimental, it is very powerful and awesome. In this session, you will learn to create a full-stack Kotlin project that fits Android apps and a backend Kotlin component. You’ll discover how to share code between the components to build more efficient and robust applications. And your teammate next door will thank you as well.

Understanding and mastering the tool that you use on a daily basis is the perfect way to boost your productivity. In this talk you will discover tips that will help in boosting your productivity with Android Studio.

The talk will explore what these actions are, how to find them and examples on how to incorporate them into your daily use. In this talk you will not be relying on keyboard shortcuts since not all attendees might be using the same operating system with the same keyboard combinations and shortcuts.

At Badoo they are developing several applications for millions of users across the world and lots of features are run with A/B tests. Due to the specific nature of this case a combination of speed and quality of development is critical for them. However, given such a large code base, the large number of A/B tests and several generations of legacy general UI components, it is becoming more and more difficult to keep up. It was decided to develop a single design system, Cosmos, which would simplify interaction between designers and developers and would significantly speed up and simplify the development process. Artem will share with you how they scaled this approach, how they globally refactored the application and how their in-house decisions, in regards to testing, assisted them in this. He will also show how they parameter UI components synchronically on all platforms with the help of design tokens and how this simplifies the structure of UI modules on a scale of several applications. You will discover the difficulties they encountered during the course of the UI scaling process and how this approach has significantly improved quality of development.

In this session you will also learn about: - Design tokens, what they are needed for, how you implement them and how they help support design in respect of synchronisation - About Badoo's Remote Icons Pipeline, how they parse icons from the sketch file in a synchronised manner on all platforms - How tokens and the Remove Icons Pipeline have assisted them all-round as they have made a global a/b test for redesign - How they reuse and customize their UI components between all their applications - And how this is scaled for all the company's applications (the development company grew twofold practically in two months), in order to scale development speed. They have a single MVIcore architecture, and this seamlessly leads to the emergence of a single approach to UI development. Artem will share with you the architecture of UI modules and how they allow you to have one layout for features shared by applications, so that these applications may be reused by applications among themselves. - And, of course, he will tell you about the problems they encountered at each stage

As Android developers, you know that your app is insulated from other apps in the device by the Android Application Sandboxing model. But the reality is that this sandbox only protects your data. Your APK is completely exposed to other apps, including resources, assets, and code. Jeb wanted to know how much reverse-engineering he could do from within an app, so he built an app that can run on your phone and inspect any other app’s resources, looking at image assets and reading string values. It can even load another app’s code, and execute it. All this happens without leaving the device, without classic reverse-engineering tools on a developer machine. In this talk, you will discover the APIs that expose your resources, and learn how to put them into action. Jeb will demonstrate how you can inspect, and even execute, another app's code. You will come away with a better understanding of what is and is not protected by the Android Application Sandbox, and which parts of your app are freely available for reverse-engineering.

Allowing users to login with Biometric Auth (fingerprint) in your app can help with both ease of use and security, but there are many “gotchas” to implementing fingerprint authentication across a wide variety of devices. During this talk Michael will explore how to add fingerprint authentication, learning about the device and OEM specific gotchas that you need to be aware of. You will also discover the new androidx BiometricPrompt library.

If you want to enable Android developers to incorporate your functionality into their app, the process is straightforward, right? Wrap your project a jar file and make it available for download. This works great for libraries targeting a single platform but not all Android developers can easily consume jar files.

In this talk you will discover how Darryn and his team implemented their APIs using Android Intents, making them accessible to most mobile frameworks as well as traditional Java / Kotlin / Xamarin developers WITHOUT having to create a new plugin for every framework. There are many advantages to this approach and they have seen enthusiastic adoption by their customers, but he will also cover the downsides including performance concerns, debugging and device dependencies.

Using GPS to find out exactly where you are is one of the more awesome powers of your mobile devices. It also poses some of the toughest challenges to developers, who must prevent excessive battery drain and deal with insufficient accuracy. In this talk you will learn how to face these challenges by answering questions such as: How does GPS even work? Where the heck did my battery go? Why does it take so long to get a good fix? And why does my phone think I’m in the middle of a lake? If you’ve ever wanted to understand how satellite navigation actually works, this is the talk for you. (It also features cold war intrigue, applied relativity theory, and a picture of a dinosaur. So you know it’s going to be good.)

You all know that users buy new devices, but how many developers have considered the user experience of moving users from their old device to their new one?

In this session, you will discover how to make the transition to a new device easier for users, how Android features like Auto Backup can help your user get up and running quickly, and offering some advice on making your users transition between devices as smooth as possible.

Al will also be opening the door to gain ideas from developers; They want to hear feedback about what they have, what developers want, and what they can do to give users the best possible experience.

Mobile/game addiction is a reality. As a mobile developer Hawazine feels concerned by this problem. Addiction to phone can cause different ranges of issues from miscommunications, anxiety.. to mental health issues. In this session, you will explore what could cause these issues and how you could address them.

Personal retrospectives are a great tool to help you stay on track to achieve your goals. Funnily enough Jakob has also noticed a few more positive side effects, especially that they help him enjoy being lazy. Jakob will share with you how that makes sense and how you should try personal retrospectives for yourself.

Maintaining a large project and not going insane – in practice:

• Causes of everyday development pain, frustration, and slowdown less frequently talked about
• Breaking down the complexity of screens instead of a classical layering approach
• Keeping code easy-to-understand, decoupled, and maintainable even in highly complex projects
• A plug-and-play component architecture where individual pieces don’t require a deep understanding or careful wiring, and can be reused in a few minutes

Zsolt and his Team now have over half a billion users across a growing portfolio of apps, including Badoo, Bumble, Chappy and Lumen.

A year ago they set out on a journey to unify and scale up their approaches to reduce component reuse and maintenance times by an order of magnitude. They reached for maximal reusability and minimal coupling between individual components.

Many of the lessons they learned in the process have immense practical benefits for projects of all sizes.

Failing to protect your users data can not only result in fines but of course loss of your users trust. You can protect your apps against man-in-the-middle attacks using techniques such as certificate pinning. However, as you will discover, implementing certificate pinning requires us to answer questions such as which certificate to pin against, and that doesn’t have a straight forward answer. In this session, Matthew will share certificate transparency which has already replaced certificate pinning in Google Chrome. You will also learn how to use it on Android with a new open source certificate transparency library from Babylon Health.

Currently smartphone navigation can only achieve accuracies of 5 m at best – this won’t be the case for much longer. The FLAMINGO initiative, part sponsored by the European GNSS Agency, is introducing technology to Android developers to permit positioning accuracy of 1m or better, the baseline performance for future smartphone navigation. This is made possible because of the use of multi-constellation GNSS (GPS, Galileo, GLONASS, Beidou), and in some cases multi-frequency, chipsets within the latest smartphones. Joshua will share with you how to engage, develop and use FLAMINGO in smartphone apps to begin harnessing the future of navigation. The interface similarities and differences between the FLAMINGO API and Google’s existing location API, will be discussed and demonstrated. Joshua will finish by explaining how high accuracy positioning will dynamically change the smartphone application landscape, including app markets such as AR, street navigation and professional tools and provide a mock-up demonstration.

In today’s world, calculating your heart rate is very easy due to wearable’s and applications available in the market. But the question is. Is it accurate? It is interesting however that the answer is no. We can argue about accuracy of a heart rate but it is definitely not interesting. The only way to make calculating your heart rate interesting is by adding augmented reality to it. There are many heart rate monitor applications available. But no application is using augmented reality to make it more fun and interesting. The cardiac application will make the study of the heart more interesting and will also give accurate heart rate output. There is not a single application which has integrated AR within it, and their results are not accurate. As such it will have benefits in medical study.

Little Secret, the superstars of the Developer World didn't get there on pure talent alone or "accidentally" (for the most part)! There are concrete steps that you can do to be recognized for the work you are ALREADY doing at every level and stage in your career. Personal branding and fulfilling that promise is worth real money, real happiness, real success in your work, and keeps building on itself.

Joe has always loved playing guitar - but he feel it's something that's always been taken for granted. Whilst he was able to pick up a guitar and start teaching himself how to play, that experience might not be the same for everyone. That's why Joe decided to build a smart, accessible guitar that would allow others to experience the joy of music with less of a hurdle to do so. Powered by Actions on Google, Firebase, Dialogflow and Google Cloud - the Chord Assist smart guitar allows people who are blind, deaf or mute to be able to learn, play and tune their guitar. In this session, Joe will share the journey of this project - from the importance of inclusive craft to how all these technologies come together to provide an accessible experience for everyone.

Announced at this year Google I/O, Jetpack Compose is a brand new, exciting toolkit for UI development on Android. It borrows from such frameworks like React or Flutter, and offers concise, composable, reactive way to designing your UI 100% in Kotlin!

In this session, you will discover the core principles or Jetpack Compose, what features it offers and why Kotlin is the language of choice. You will also explore how you can integrate Compose with existing UI frameworks and what you can expect in the future.

Rendering UI takes a significant amount of CPU time, therefore it's important to keep this part of the computation as lean as possible. Whenever UI rendering regresses key metrics such as app startup, time-to-interaction, scroll performance are all affected which eventually affects product engagement. In this talk, you will discover how Facebook uses benchmarks to make sure that regressions on UI rendering do not slip through to production. Also you will explore ways of iterating on UI rendering code to proactively improve UI performance.

Kotlin Coroutines is a powerful tool. Well implemented concept of suspendable computation... It is a dream of many theoretics of concurrent programming for a long time. But how is it possible? How do Kotlin coroutines really work? Why are they important? What do they introduce? And finally, how you can use them in your project?

In this workshop, Marcin will share how to use Kotlin Coroutines and what makes them so special and so efficient. You will also explore if they are an alternative to RxJava.

In the past, engineering teams typically split “frontend” and “backend” responsibilities. As an Android developer, you almost certainly slotted into the “frontend” category, with no responsibility on the backend. And if you do want to work on the backend for an app, it can be taxing to learn new tools and languages, while being responsible for managing and scaling a server farm.

Today, with “serverless” backends becoming popular, server management and scaling is being fully automated, and you can use many of the same tools and languages you use for Android development. Do you want to write Kotlin everywhere? There’s a solution for you! Join this talk to explore some serverless options provided by Google, see some demos, and discover which options are right for you.

With a diverse, global base of users, how do you decide which language to use to present content to your user? Location makes sense, right? Romans speak Italian, Osakans speak Japanese, and Ohians speak English. Simple! Except that you know it’s not like that. Everyone knows there’s Vietnamese people living in Rome, British people living in Osaka, and Argentinians living in Ohio—such is life in 2019. So why do so many companies solely use location to determine things like language, currency formats, and other important internationalisation features? It’s a frustrating experience for users, and the tools exist to do much better. In this session, you will explore some examples where companies are getting it right, some examples where companies are getting it very wrong. You will also discover some suggestions on how you can improve the experience in your own apps.

Many successful Android apps offer multiple features and components that work together to provide a great user experience. Although you want all prospective users to have the ability to install your app, this may not be possible due to limitations in storage and network connection, especially in emerging markets. What if you can deliver new features selectively post-installation, reducing the initial app size, and allowing you to target a wider audience? How did Kotlin enhance your reliability and quick prototyping before shipping a brand new dynamic feature? Now that Kotlin is the first language on the Android platform, you certainly know this was the right choice at the time.

Are you one of the numerous developers who wants to implement Espresso testing but hasn't? Perhaps it's for one of the common reasons - not enough expertise or time, it feels like a daunting task, or it feels downright tedious. Adam has personally felt each of those things. All of that changed once he learnt about the robot pattern. In this session, you will discover how the robot pattern helps you write cleaner and maintainable tests, as well as how it can be leveraged for better test reporting. You'll walk away with an understanding of how to write tests much more thoroughly and efficiently so that it can easily become a natural part of your build process, and not shoved in the backlog and left untouched.

Kotlin Coroutines is a powerful tool. Well implemented concept of suspendable computation... It is a dream of many theoretics of concurrent programming for a long time. But how is it possible? How do Kotlin coroutines really work? Why are they important? What do they introduce? And finally, how you can use them in your project?

In this workshop, Marcin will share how to use Kotlin Coroutines and what makes them so special and so efficient. You will also explore if they are an alternative to RxJava.

What if an app could be performant by being simple? What if an app could work “at scale” for a billion users using only standard Android paradigms? Facebook supports some of the biggest, most complex apps in the world. But supporting *everyone* also means support for developing countries, low-memory phones, and spotty network. So in Messenger Lite, the team tried something different. To make cold start and APK size priorities, they went back to basics. They limited dependencies -- and the feature set. And they embraced what the Android framework provides to make a 100% native app that’s featherweight and really, really fast. In this talk you'll discover how these tools -- such as data binding, RecyclerViews, a database-driven UI, and simply writing *less code* -- are available to every Android developer who wants to build their app the Lite way.

In times where design revolves around interfaces and screens, moving towards UI-less experiences brings new challenges. Most of the interactions between humans are done through conversation and still, most of that communication is wrong. Technology brings new challanges but also makes life easier for people by building bridges between the needs of humans and modern technology. However, how can we teach computers to better interact and communicate with people when most of the time, communication is flawed. In this talk, Alina is going to explore with you not only the technology and the challenges of voice interactions, but also human and psychology aspects that help designers and developers create better products.

Since Google I/O 2019, the Android Devtools team has been heads down to make the Android Gradle plugin faster, smarter, and more stable. In this talk, Izabela and Adarsh from the Android build team deep dive into the magic—such as the revamped resource compilation pipeline, incremental annotation processor support, build attribution, and more—that makes the latest version of the plugin work for you.

"Idiomatic" is a word often used by Kotlin experts to describe elegant patterns or solutions that make excellent use of Kotlin’s features. In this session you will discover how to abuse Kotlin language features to take shortcuts, create tricky solutions, achieve exciting syntax, or confuse others who dare enter your codebase.

Let´s face it, Groovy is ok, but Kotlin is irresistible. During this talk you are going to learn how easy it is to migrate your Android project to Kotlin DSL and find on the way some tips to boost the gradle files reusability.

You may have been reading about AR as the future platform, even though currently you are only able to experience gaming/entertainment use cases about it. However, there are effective non-gaming examples: Many travel and transport companies are using AR to help you to understand if your luggage fit their limits. In this session, you will discover these apps and explore how to develop them as an Android native app using ARCore, Sceneform and a bit of AI with Firebase ML Kit. At the end you will be able to apply these new skills to new exciting use cases.

Futures! Priority Inversion! big.LITTLE! MessageQueues! Choreographer! Obscure OEM Optimizations! All the things you never thought to ask about threading on Android. Pasquale and Andy REVEAL ALL in this exclusive expose.

Android engineering has come a long way. Nowadays most applications are modularized to a certain degree - to combat high compile times, enforce separation of concerns or to group code based on certain scopes. In this talk you will explore navigation in modularized apps. Navigation in Android can be done explicitly by passing the class variable or implicit by sending an Intent with a certain configuration. Since modularization is supposed to simplify our dependency graph, you will take a closer look at deep linking as a navigation pattern and compare different approaches like Intent filter, a custom deeplink processor or the Android Jetpack Navigation component. After this talk, you will be able to modularize your application with a clean, structured and scalable navigation.

No doubt you have heard of Flutter... perhaps you have given it a go, and not found it quite as intuitive as you want. Simon will share his experience of Android and Flutter so that you could reach the next level in mobile development. You'll learn what Flutter is and how it works under the hood from an Android developers perspective. How it connects with Android, and discover why it is not as far-fetched as what you might first expect. He'll take you through examples of how you achieve common app developers patterns with Dart and Flutter.

This is my invariable advice to people: Learn how to cook- try new recipes, learn from your mistakes, be fearless, and above all have fun!” - Julia Child. The first lessons of an apprentice cook typically focus on identifying quality. Reinforced by repetitive acts, which helps understand the product and the method. This training only focuses on the detail rather than the bigger picture. With these new skills a cook learns how to adapt. Once they have a strong grasp of the fundamentals cooks are less fearful of experimentation. After they’ve gained confidence in their ability to adapt, improvisation teaches them how to act based on their intuition. Finally, when they have enough technical skill, a chef’s creativity finally enters the picture. A dish is simply the expression of a personal challenge, filtered through the whole of a cook’s experience and knowledge. Adapt, try new things, overcome and learn from your mistakes, repeat. How well do you think you'd cope if you had to be a professional chef for a day? What if we replace “cooks/chefs” with “Android developers” in the previous text?

The software you create is the expression of our knowledge, of what you’ve learned, and your own experiences. The path of becoming a senior Android developer can be very similar to the one cooks take to become chefs. Anastasia wants to learn from chefs and their journeys and apply it to your own craftsmanship. During her talk you will learn what path you can expect in your career, what skills will be needed in each step, what it takes to become a good Android developer, what it means to be senior developer, and finally how to lead a team successfully.

As the Deezer team expanded over the last years, making changes and maintaining design in the mobile app became a major concern: How do you keep the different screens of the app(s) consistent and let the design evolve? How do you ensure consistency across platforms / applications? How do you fill knowledge gaps between designers and developers? Join this talk to find out how the Deezer team decided to build a strong Design System, based on Brad Frost methodology: Atomic Design. They established with designers a UIKit, a pattern library, implemented as an Android library and inspired from Atomic Design, defining every UI component of the app. In this talk, you will explore the UIKit, see how components are defined, organized and integrated in the app with global architecture, and the implications on the design and development process in our team.

If you want to know more about the Atomic Design and UIKit before hand, you can read this article on medium on Deezer's journey towards atomic design on androi.

Mobile is a leading platform that keeps growing (amounting today to 52% of web traffic and half of online shopping), no wonder voice interfaces are met with success there. And with half of all voice interactions taking place on mobile, you see many original ideas being developed in this field.

Some of these bring users a lot of value, reducing friction to use a service or improving the user’s overall experience. But quite a few design patterns actually interfere with the user’s objectives. What should you take care of when building voice interactions into an app? Would any app benefit added voice commands, or does it only bring value to some use-cases?

From interaction design to the dreaded issue of knowing when to stop speaking, you’ll learn what separates a great voice-enabled app from a not-so-great one. You will take away some lessons the current ecosystem can teach us to build better interfaces... and it might put a smile on your faces along the way!

Join in this technical keynote with Chet Haase and Romain Guy!

Join us for this wrap up of 2 days of droidcon London joy!