So instead of superficially explaining why an architecture is better than another, Mounir will explore with you some issues you might face in our daily Android development job and how you can solve those easily through 3 examples.

1. You have crashes you can't reproduce. Those crashes can be seen on different devices. You will learn about all the steps that led to these issues to understand and fix those easily.

2. Integration tests are great and necessary to ensure a complete flow is working as expected, but they are complex to set up, and it takes time to run the whole test suite when using an instrumentation tool such as Espresso.

3. Your legacy app has some "startActivity" calls in activites, fragments, custom views, and even in RecyclerView adapters (who did that !?!). You have no visibility regarding the overall navigation of your app and the code is sometimes hard to follow.

Mounir will share with you the concepts underneath and how such an architecture can be implemented using functional programming patterns through writing a Kotlin DSL. This talk is targeting developers who have already written some Kotlin code.

During this talk you will learn how to build VR applications for Android starting with a basic Open GL ES prototype and moving towards a more complex one using Unity.

Julien will start by explaining how to build simple prototypes with Java, OpenGL ES and the Google VR library. Then, you will learn about Unity, which will allow you to build complex VR applications. Julien will also explore how to build Android native plugins (Java, JNI) in order to explain you how Unity can interact with the Android components (we will take our player & WebView plugins as examples). You'll get some tips on the UI/UX best practices for your Cardboard or Daydream apps, and some hints on 3D optimization for mobile platforms (in order for you to always keep your app at 60fps) which will give your users a smoother experience.

All Julien's examples will be based on CINEVR, The VR application he's been working on at Cinemur.

Maybe you copy&paste some classes and layouts when you create a new Activity using MVP or MVVM. Maybe you “reuse” the same files when you create a new App. What if you could generate that code automatically? Well, you can, and I’m going to show you how by writing your own Android Studio Plugin.

In this talk, you will learn how to create a new Android Studio Plugin, create templates to generate code automatically, write live templates to insert frequently-used constructors in your code and how you can create a brand new full app in minutes putting together feature modules and templates.

You'll learn how to:

• Setup an app with navigation

• Use the navigation graph to make destinations and actions

• Add navigation transitions

• Implement type-safe argument passing

• Set up a standard UI pattern such as a navigation drawer

• Work with deep links

Currently, multiple techniques exist to identify malware such as code signatures, hashes, permission analysis and manual static analysis. These techniques rely on the premise that who or what is performing the analysis, is required to have access to the Android application (APK). However, performing these analysis techniques on devices is resource intensive, time consuming and also dependent on access to the APK.

What if no access to the APK is required to identify if an application is malicious? Currently, no capability exists to scan for malicious applications at runtime on Android devices, at best there is static analysis on the application and its permissions. Additionally, there is the Android Attestation framework, which attempts to provide information on the state of the device but does not provide information on the state of running applications

In this talk, Chris will explore a novel technique to identify malicious Android applications through the use of analyzing the HEAP of Android applications at runtime. The identification and analysis of instantiated objects for Android applications from the HEAP can be used to effectively identify applications that are making use of, and implementing dangerous functionality such as Class loaders and other well known objects that exhibit malicious behaviour.

Chris will also share how this technique was built and implemented on Android using Android awesomeness and how it can be implemented by the operating system or 3rd party applications to effectively scan application memory for malicious behaviour.

In this talk, Ana will take a deep dive into the Android keystore system, certificates and signatures, and go over key points necessary for any application's long and productive life. Also, she will explore some security tips and tricks that will help ensure your app is safe to use, even if the users are faced with its evil twin.

In this session, Laurence Moroney, from the TensorFlow team at Google will show you how to train a model to recognize images that will then be used to feed commands to a mobile app!

Scott will explore the major changes to the way background apps are restricted from accessing the microphone, camera, and sensors and how to stay on the right side of these privacy restrictions. Google have continued to enhance Network Security Config which now defaults to blocking non-https traffic. As well discussing the restrictions to device serial access, world-accessible files and cryptographic changes. The Keystore also gets enhancements with the ability to import keys and support for a new Hardware security module.

APK signing is getting a boost with the new APK Signature Scheme v3 that enables your app to be signed with a new signing certificate! Phew no more worrying about what would happen after 22 October 2033.

Of course, Android P won’t be mainstream for 12 months so Scott will also include new security features available via Google Play services and other security libraries.

Find out more about Flipper here.

Artur ran into the exact same situation and dug into the tools that may be used to make your Android app work on 60 frames per second. This presentation is intended for the people who haven't dived into the UI performance yet. You will see some examples of easy and fast ways to check if your app works well and if it is not, how to find the potential problem.

In the presentation, Artur will tell you about:

-How android renders views and why does it matter to you (DisplayLists, Choreographer, VSync, Render Thread - things that will be covered) -How to understand that you have a problem (GPU profiling, SysTrace) -How to get metrics about the current rendering speed (fps) of your app (dumpsys gfxinfo, Systrace, HierarchyViewer) -Some of their mistakes they made, how he found them and how he fixed them (overlaying Controllers (analog of Fragments), incorrect usage of RecyclerView with NestedScrollViewHow to easily find GPU overdraw and fix it (using GPU overdraw in dev settings and export view layers in HierarchyViewer or Scalpel to show you the ways to improve) -How to be sure that the problem doesn’t regress (Android Vitals, dumpsys gfxinfo)

Gradle Kotlin DSL is this new thing that aims to fix some annoyances you might have with your build scripts. And if you're thinking "Wait, what's Kotlin got to do with my build scripts? Ain't that just a JSON-ish Gradle specific text file?", then don't worry. Marcin will explain that in fact no, the build script is just code (spoiler: not Java™️ Programming Language code, but close) and how Gradle Kotlin DSL makes it better.

He'll also take a pretty detailed look at how Gradle Kotlin DSL works for Android projects. Can you use it for your app's build script right now? Does it support the extra features (and complexity) that the Android Gradle plugin adds into the mix?

If you're more (or also) interested in plugin development, writing them in Kotlin is not so new, but he'll quickly show how to do it anyway because it's great and you should try it!

Although the Autofill Framework was designed to work without any effort from app developers, apps that explicitly integrate with the framework improves its workflow, resulting in a better user experience and retention.

This session will be presented by the Android Engineer leading the Autofill Framework project and will cover 10 simple tricks that help app developers integrate with the framework, such as:

• Layout XML annotations
• Android Studio integration
• Testing with standard services
• Android P improvements

Tomek will tell his story about how he convinced his team at Groupon to try out Flutter. How highlighting the benefits, whilst being fully transparent about the risks will strengthen your argument. Next, they will help you address your team’s concerns; starting with fellow developers through to management.

He will share how to get the whole team onboard, by showing your:

• Designers; how to make a beautiful application
• QA; how to make your application more robust
• Developers; how easy and captivating is to use Flutter
• Product owners; that Flutter is feasible for product goals

Finally, Tomek will share some of the challenges while integrating Google’s cross-platform framework into an already existing application and how they tackled them in the last couple of months.

A common usage of paths is SVG, which supports operations like clipping and compositing. Path manipulation APIs are available on every platform like the Web, iOS and of course, Android. Many developers don’t realize that they can take advantage of these APIs to create great visual effects.

In the talk, Rakshak will explore some effects created using Paths, deconstruct their behaviour and reproduce them using the Path Operations API. He’ll also look at backporting some Path operations to as low as API 1.

• What is Bazel and the features it brings to your development

• How it is used by Google

• Bazel features for Android build

• How to turbocharge your development

Andrew and Catalina will talk about Clean Architecture, why it might make your life easier, and its relevance to the direction that Android’s heading in. They will discuss how it can fit with your current codebase and existing endpoints. And they will share with you some practical tips on how to bring your team with you on the journey. But no giant space goats. Sorry.

The discussion will include:

• How Layout XML file become view hierarchies

• How LayoutInflaters are used in AppCompat

• new AsyncLayoutInflater in v24 of support-v4

Unfortunately, it is not a straightforward task since Mockito 2 is not fully compatible with the old behaviour of Mockito 1.x. Adding to this complexity, If you are having PowerMock in your old tests, then you will have to face another dimension of complexity since most of PowerMock’s versions are having integration issues with Mockito 2.x.

This session goes through the tips and tricks that you need to consider in order to migrate to and utilize Mockito 2.x. It has demos to show migrating Android app Mockito 1.x tests to Mockito 2.x.

Drawn from experiences with working on a global network of backend systems, websites and mobile apps in more than 30 locales for the last 10 years, this talk will start with an introduction to the concepts behind time zones and locales.

You’re going to learn about the history of time measurement and time synchronisation and how the world eventually ended up with the global system of time zones of today. Today’s model is full of interesting and sometimes outright bizarre quirks and you’ll look at some of best and worst of them. From there you’ll learn about the ideas behind locales and why cultural context is at least as important as a locale’s common collection of purely technical data such a number formats or text direction. After this, the talk will cover how common runtime environments like Android and Java represent these ideas.

Technical topics covered are:

• How does the JVM deal with timezones and locales and in which way is this is handled differently on Android devices?
• What level of support and libraries does the Android SDK offer for Java and Kotlin?
• Ways to make your developer life supporting multi-lingual/-locale apps easier.
• How can you survive a "WHAT? We have to support daylight-savings-time?" request?
• Managing user expectations and dealing with changing timezones/locales at runtime .
• How can you support 30+ languages in the Play Store — and would you even have to?

Eventually, it will be revealed why a whole country skipped a day and what they gained from going through this effort. Stay tuned!

At Spotify, it has meant clearing out years and years of tech debt, re-writing APIs, rethinking the architecture and structure of the application and features that goes into it, wrestling with build tools, and then some.

This talk will walk you through the Spotify modularization journey: why they got started, how they went about it, what they have learned through the process, and also why you should be thinking about modularizing your code, if you haven't already started.

Android Jetpack: Test is the official testing library for Android. In this session, Jonathan and Stefan will share a new set of testing APIs that allow developers to write tests of all sizes across different execution environments. These new APIs will make testing easy, reducing the cognitive load for developers and keeping them in the zone while rapidly iterating.

What empowers us to classify over a billion users, from varying backgrounds and cultures and upbringings; of different ideologies and visions and ages, as one single user and then go on to design for that user?

While doing so produces a user experience better than most, it is still far from the ideal curve, which can also be achieved by morphosis in design - adapting the user interface and experience in accordance with usage patterns.

This session aims to cover the various techniques and outputs involved in it, allowing apps to provide an experience tailored for its current user, eliminating possible bottlenecks and hurdles along the way.

To talk review people. The status of Kotlin and multiplatform will change dramatically between now and October, so while the talk will be on this topic, it’s hard to predict exactly where you’ll be by then. Kevin has spent 2 years working on a J2objc solution to sharing architecture and has switched to Kotlin. He's recently released a functional demo of SQLite and SQLDelight running on iOS and is currently working on a formal SQLite shared library, which should be published later this month.

The great news is that Android Plugin 3.1.0 and higher include major changes that bring significant performance improvements to large multi-module projects—in some cases, we've experienced builds that are 3-5X faster! Some of the improvements include:

• Better parallelism for multi-module projects through a fine-grained task graph
• Variant-aware dependency management. (When building a certain variant of a module, the plugin now automatically matches variants of local library module dependencies to the variant of the module you are building)
• Compilation avoidance via new dependency configurations
• Faster incremental build speed due to per-class dexing. Each class is now compiled into separate DEX files, and only the classes that are modified are re-compiled
• Faster resource packaging with AAPT2 enabled by default. In order to bring about these improvements, there are some breaking changes in the plugin behaviour, Domain Specific Language (DSL), and APIs. In this talk, a member of the Android Studio team shows you how to easily migrate your project to the new plugin, resolve build errors, optimize your build configuration, and prepare your project to take advantage of future improvements to the plugin

But how can you as an application developer for a large application or one with plenty of untested legacy code? Preparing an application that might be tightly coupled into a single module requires us to carefully de-tangle and move concerns to independent modules.

This talk covers how they managed to prepare our application for instant apps by breaking off base elements and isolating essential key features into self contained, independent modules, with all the difficulties that this entails and how you can avoid the common pain points and pitfalls

In this talk, you'll learn about:

• Evolution of different kinds of notifications: Basic notification, Expandables, Heads up Notification, notifications with actions, badges

• Notification channel: What, how and management

• Notification Importance and their outcome

• Quick Demo of how to create notifications from your app

• What improvements are further expected with Android P and beyond!

At the end, you will walk away with a deep insight into the world of these everyday knock knocks in your phone's status bar, that notify you of different happenings.

From the native side you will cover topics like using the new MotionLayout, animation XML definitions, Material Design AppCompat included tools, moving through ObjectAnimators, Animation Properties, Listeners, View Animators, AnimationSets, even AnimatedVectorDrawables, Morphs, and libraries like Lottie. Finally finishing with going "manual" in Canvas to get that precise experience. You will learn what to use where and how for Best Performance and Best Practices.

Stacy has lived this truth and responsible for the Material transformation and Animation throughout applications for household names for tens of millions of users.

This session will take on where I/O has left off, giving more detailed insights into usage, best practices and development workflows.

This talk will explore how, and why, they have three different apps, how they get the three to work together to deliver your order, and how they manage these three apps to keep all food moving.

Some of the parts of the system that Al will cover include how their engineering Teams work separately on each app, but stay in sync with each other to maintain best practices across the company. He'll also cover the technical aspects of how the data flows from the consumer app into our service orientated back-end, between the services, and out to the restaurant and rider apps in a way which keeps customers orders flowing through the appropriate workflow.

He'll share some of the challenges they've faced deploying private apps to limited audiences outside of the play store, managing the diversity of hardware which has been deployed, and how their approaches have changed over time to take advantage of Mobile Device Management solutions, user education, and the changing needs of the business.

On the other hand, interviewing candidates for a position can be stressful too. You want to find the perfect person to join your team, but there are many factors that feel out of our hands (e.g. rain can affect the mood of the candidate and the person interviewing and impact the result). You need to effectively control the factors that we can.

In this talk, Anastasia and Vivien want to focus on the whole process of finding the right people to work with, from the job advert to the offer. And They want to do it from both points of view, as the company and as the candidate.

They want to show candidates behind the scenes of the interviewing process, to make it feel less intimidating. They also want to teach them how to choose a job and a company that fits with them. They want to give some tips on how to prepare for interviews, and the sort of exercises they might encounter.

Anastasia and Vivien also want to help companies improve their hiring process. There is no solution that works for everyone, but there are patterns everyone can follow to do better. They want to show them how to reach candidates, make sure qualified candidates apply, show them how to deal with the unavoidable biases they will face, help them understand the pros and cons of different types of exercises, and finally, help them find the perfect new hire for their team.

Hiring and interviewing is not easy, and there is no easy solution to it. But we hope that with this talk we would make it a little bit better for everyone involved.

Lyla and Dan will explore the basics and then dive into a series of more complex use cases. Learn about advanced topics such deep linking, leveraging Navigation to simplify modularization for instant apps and Dynamic App Delivery, using sub-graphs, manipulating the back-stack, sharing a ViewModel between navigation destinations and more. See what Navigation components can do for you!

In this talk, you'll learn about AGP internals and answer questions like:

• What's D8 and R8?

• What is mergeResources and why does it take so long?

• Why are there so many tasks?

• How can I measure and speed my builds?

You'll come away with a better understanding of the toolchain which will make you a better equipped Android developer!

No? Then why don't you convince management to start over? Things will be different, you'll do things right.

Truth be told, app rewrites seldom work out: estimates turn out to be overly optimistic, functionality a lot more complex and crucial details have been deeply buried in the legacy code.

Result: pressure to ship increases and technical debt again piles up.

Join this talk to get a better understanding of the unique challenge of today's ever growing, more and more complex apps. Learn how you can efficiently tackle legacy code bases and how to get back your developer happiness.