Working with RxJava's Observables can be challenging: they have to abide by the Android lifecycle, be aware of garbage collection, and keep threading in mind. In this talk, Paco will take a deep dive on the memory management pitfalls when working with reactive apps.

You will learn what leaks are, how they are created when working with observable streams, and provide advice on how to avoid them. Building your own UI binding abstraction can help you understand how you app's state changes, and greatly simplify your tests. Lastly, how to architect your app to optimize for fast development loops.

Imagine the following. You're happily coding along when you suddenly realize that there is a serious security flaw with your app. At first you may be in disbelief. You might turn to your co-worker and ask, "Does this sound right to you?" Then the realization of the magnitude of the problem slowly dawns on you. You might swear, walk outside for fresh air, or even laugh out loud, not knowing how else to respond.

Maybe you haven't experienced anything like that. In Clive's talk, you will explore some commonly overlooked areas of Android programming that may pose serious security concerns, so that this doesn't happen to you in the future.

Why overlooked? Because most of the issues Clive brings up may seem like it has nothing to do with security, even to an experienced Android developer. Addressing these issues may seem like busy work that someone on the team should do, but no one ends up doing because no time is allotted for it. These issues include, for example, logging, obfuscation, NDK, library dependencies, recent app menu, etc. Clive's hope for this talk is that we recognize the security implications of these overlooked areas and thus prioritize addressing these issues.

OpenGL is often regarded as too complex, obscure or even too low level to be considered when developing an application. Most people will even try to go around it and develop what they want using Views and Canvas to avoid developing with it. Nevertheless, it's not always possible nor the best solution.

As someone who have been going through all the learning of OpenGL recently, Benjamin has encountered a lot of frustration but also a lot of “aha!“ moment. In this talk, Benjamin will try to demystified OpenGL and share the basics of what it is and how to use it in Android to make applications perform better. Also, you will learn all the pitfalls and key concepts that you should know when starting with OpenGL.

Ever wondered what your Android sees? How does it perceive (or not) the outside world? it would be really nice for our phones to see as we see and if they're not yet capable, why not teach them? the way to do it is using Machine Learning, a (kind of) new trend that's here to stay, and with so many different areas to explore is up to us to pick one we find interesting.

Well, Adrian's take is on computer vision, so buckle up and join him in this journey, you can review options for computer vision on mobile, explore different examples and walk through the basics of several vision APIs.

Android Studio has a whole new suite of tools for analysing your apps and for debugging runtime errors and performance problems. Developers are also becoming more aware about the need to make their apps leaner and faster, but often don't know what tools are at their disposal. Wojtek will share with you several classes of common debugging problems and the appropriate tools to tackle them.

What actually happens when your code calls Android APIs? You all know about onCreate, but who actually calls this method? What does the operating system look like under the hood? In this talk, Effie is going to go behind the curtain and look at AOSP itself. She's going to dig into the internals of how Android OS manages the apps that we write and see:

• How Intents work and how they get resolved
• How an app works together with other Intents, Activities, Services, and Content Providers in features such as sharing
• How the app lifecycle is being managed by the system
• How these features are built on top of the built-in Linux primitives such as processes and Linux user accounts.

Mobile apps increasingly leverage rich and complex REST API backends to enable server-side interaction. However access credentials, such as API keys, have to be embedded in your app code where they can be extracted and subsequently abused. Learn practical approaches to prevent this without having to change your whole development flow. Richard will share with you examples in native Android apps, using Kotlin as the example language.

Firstly you will survey the state of the art in terms of how authorization to these APIs is typically implemented, including API keys and user authorization via OAuth2. Richard will then discuss the types of attacks that are possible if unauthorized software clients are able to access the API and impersonate the intended client mobile app. You will also learn how TLS alone is not an effective countermeasure to credentials being reversed unless certificate pinning is also used to prevent Man-in-the-Middle attacks against the app. There will be some practical advice on how to implement TLS pinning with code examples. During this talk you will then learn how credentials can be easily extracted from mobile app code unless some effort is made to conceal these credentials. Further Richard will share some tips on improving credential obfuscation in code, across multiple frameworks. You will look at proxy based approaches to move secrets out of mobile apps and into more easily secured servers.

Finally you will discover more advanced techniques such as app hardening, white box cryptography and software attestation for applications where security is crucial. You should gain a good understanding of the problem, some short term practical tips to improve their API security posture with minimal effort and an appreciation of emerging tools and technologies that enable a significant step change in security.

Designing an elegant interface for developers to communicate with your Android app is crucial for building a mobile platform. Ty has been building mobile-focused developer platforms at Evernote, Twitter, and now Uber. In this talk, he'll walk you through many of the best practices that he has accumulated and you’ll find out how to allow third party developers to seamlessly interact with your users’ local data to shortcut more expensive server operations.

Ty will share topics such as how to include building single sign-on, surfacing your local databases, constructing well-defined Intent interfaces, using deep links, and binding services for programmatic communication. Ty will share with you how to create a well-defined interface in your app – if that’s something you want to know, don’t miss it!

Android O brings a plethora of security enhancements to the platform and the SDK. Scott will share with you a concise update on these new security features as well as practical tips and examples of how to implement them and improve your app’s security.

You will learn about features such as Auto fill, restrictions on device hardware identification with the focus on user privacy, new permissions in telephony and updates to how apps can access user accounts.

Scott will discuss the major enhancements to Webview in Android O including isolating it’s process and ability to integrate with Google Safe Browsing API. Also the dropping of support for SSLv3 and enhancements to Network security config that was introduced in Android Nougat.

Scott will also share with you some security features you can implement when your apps is not running on Android O. This is where Google Play services can help. Several new SafteyNet APIs allow developers make smarter decisions about the trustworthiness of the devices their app is running on. You will also learn how easy it is to transition to Google Play App Signing which offers a new way to manage your app’s signing keys.

We write code, we run it on the device, we can see it and touch it and play around with it.. But how do those line of code actually become something we can see? Isn’t it magic? - not really :)

This talk will take a peek under the hood and explain how does the system work, how does it draw the views on screen? Ever asked yourselves why is the view class you wrote not showing on the screen? Or why does it take so long until the layout is drawn? Why isn’t your popup displaying at the correct position? Why is your animation junky?

Britt will answer these questions and understand how to profile and improve your app’s drawing performance- for the smoothest user experience possible.

Testing is a fundamental component for the success of our apps. Professionals in charge for developing Android apps are well aware of that and we are doing our best to add unit tests to our apps. But having a good test coverage is not an easy task. More so, when activities (or fragments) get in the middle.

In this talk, Jorge will share a brief introduction about how architecture helps us to increase code coverage and will provide some practical hints.

Finally, Jorge will do live coding to show how to use espresso and JUnit to write unit tests of an activity. The code will be written in Kotlin, but Jorge will explain how to do the same in Java.

This is a "Code or it didn't happen" (TM) talk.

With Android Marshmallow Google introduced two new power-saving modes: Doze and App Standby. True to their intent, both provide longer battery life and better performance. Their effectiveness further improved in Android Nougat. However, these modes carry some limitations developers should be aware of. To further improve power-saving Android O will be even more restrictive and disable common implicit broadcasts. Many apps rely on implicit broadcasts so if you're using those, supporting older and newer devices at the same time is going to be more challenging.

In this talk Ralf will share with you why these new APIs are better. You will learn the given tools and dive into the new APIs. Finally, you will explore effective solutions to avoid duplicating code over and over again for different SDK versions.

A lot of developers will agree to the claim that they turned their hobby into their profession. However, when looking at the daily business they often face a world different from what they expect. A variety of reasons lead to a developer becoming frustrated thinking "What the hell am I doing here?". Sometimes it's because of expectations that simply cannot be met in reality but there are also external factors that contribute to the "developer unhappiness".

So, what can be done to improve the current situation? How can you make ourselves feel better? Based upon a lot of discussions, observations and real life experiences the presentation will show a number of "real life patterns" that can be applied immediately to manage the everyday stress and hurdles to make ourselves feel more relaxed and happier in our job.

With the release of Gradle 4.0, major new features never seen before have become available that allow for efficient development workflows and provide increased build performance by an order of magnitude, in particular for Android builds.

Etienne will explore the new Gradle features like Daemon-by-default, Composite Builds, Build Cache, and others. You will also learn how Gradle build scans help with gaining insights into your builds. All information and live demonstrations will be put into context on how they relate to Android development.

Any sufficiently advanced technology is indistinguishable from magic. The reality of the 10x developer myth is just that - it’s just developers who master their environment. The truth is we can become massively more productive by using what’s readily available and merely a few google searches away.

In this talk you will learn how to become a better developer by mastering our development environment and the universe of tools at our disposal. From the hidden depths of Android Studio and Gradle to the wide open fields of awesome open source utilities and services that border on magical.

How well do You know your tools?

Don't you love making your app robust against network failures? Now imagine your app talking to a Wi-Fi connected product... Locally when your home or via a server when you’re not. You'll certainly love handling those network switches! And what if your app doesn't just control one product, but multiple ones? Some locally, some remotely connected? Or how about having multiple users controlling the same product at the same time? It goes without question that building apps for connected products is incredibly challenging.

From device discovery, over minimizing network requests to out of the box setup, Jeroen's talk will cover it all. Packed with code examples, architecture suggestions and tons of best practices, you'll learn six years’ worth of hard earned experience. This won't just kick start your IoT app development skills, but you will also learn how to keep your app scalable and maintainable towards the future.

Starting as early as 2011, Jeroen has built an impressive range of connected products: BT LE coffee machines, Wi-Fi speakers, connected air purifiers and even full blown connectivity libraries. Currently he is Lead Android developer of the official Philips Hue apps, the biggest IoT system in the world.

Android Lint was introduced in ADT 16 as a tool to scan for potential bugs. However, Lint itself has been around since the Unix V7 in 1979 as a static analysis tool and adopted by every major programming language over the past 40 years.

Well utilized Lint not only prevents common errors such as use of deprecated elements or API calls, but also improves code quality and enforce tailored rules. At the end of this session, you will walk out with knowledge that reveals the full potential behind Android Lint from the built-in checks and configuration, most updated APIs, USAT Library, as well as the difference between Android Lint and other static code analysis tools such as PMD and Findbugs to help you make better decisions on which fits a certain purpose best. Snow will also share step by step examples on how to implement your own rules. You will.

Now are you ready to join us and become a Lint Expert?

Application architecture defines the way we develop, test, scale and maintain our application. Good architecture allows you to easily adopt to constantly changing requirements and protects you from breaking existing functionalities. In this talk Igor will introduce the concept of Clean Architecture, discuss its benefits and help you understand how Clean Architecture fits into Android application development.

Developing a high quality application for TV is not an easy task: developers need to design a compelling, easy to use User Interface, make it navigable via remote controller, connect it to a streaming service and manage all the plumbing, from populating the interface to buffering and showing the content on screen.

What if you could build this type of apps not in months, weeks or days but in just A FEW MINUTES? Join Amazon Technology Evangelist Mario Viviani to discover how you can leverage the Android tools and templates provided by the Amazon Fire TV Developer Frameworks to design and develop high quality Android apps for TV that run cross-platform.

In this talk you will learn:

• How to build a full-fledged, cross-platform Android app for TV in a few minutes using Amazon Fire TV Developer Frameworks

• How to customize the template

• Add modules for In-App Purchase, Subscriptions, Live Streaming, Ads and much more!

There was a time when people could count on one hand the number of employers they had in their professional life. Nowadays you need, and sometimes you also want, to change more often.

Back in 2015, Jose dreamed of becoming an Android Developer. During his career change, he hit the wall countless times, and he learnt a few lessons the hard way.

Sooner or later you will have to go through the process of moving on to the next stage. Whether it is a significant career change, switch to a different tech stack or evolving to a managing role, you will need the right mindset and tools.

Jose will clear and demystify the path, so you are well equipped when the moment comes.

Prior to Android 6.0, apps frequently requested sensitive permissions (such as accounts, contacts and text messages) at install time in order to provide a smooth sign-in and sign-up experience. Whilst this approach has usability benefits, it has privacy implications (the reason many apps avoided it in the first place), and in addition, developers are finding it much less effective on newer versions on Android in which permissions must be individually requested at run-time.

Fortunately, there’s a way around these problems that both maintains ease-of-use and respects privacy: by using the authentication-related APIs of Google Play Services, most authentication flows can be implemented without requesting any permissions at all.

In this talk Michael will share with you the UX and technical aspects of these changes, and how you can best take advantage of the features provided by Android and Google Play Services to improve the sign-in and sign-up flows for your users.

Application architecture defines the way we develop, test, scale and maintain our application. Good architecture allows you to easily adopt to constantly changing requirements and protects you from breaking existing functionalities. In this talk Igor will introduce the concept of Clean Architecture, discuss its benefits and help you understand how Clean Architecture fits into Android application development.

Developing a high quality application for TV is not an easy task: developers need to design a compelling, easy to use User Interface, make it navigable via remote controller, connect it to a streaming service and manage all the plumbing, from populating the interface to buffering and showing the content on screen.

What if you could build this type of apps not in months, weeks or days but in just A FEW MINUTES? Join Amazon Technology Evangelist Mario Viviani to discover how you can leverage the Android tools and templates provided by the Amazon Fire TV Developer Frameworks to design and develop high quality Android apps for TV that run cross-platform.

In this talk you will learn:

• How to build a full-fledged, cross-platform Android app for TV in a few minutes using Amazon Fire TV Developer Frameworks

• How to customize the template

• Add modules for In-App Purchase, Subscriptions, Live Streaming, Ads and much more!

ObjectBox is a new database designed to simplify and speed up object persistence. Learn how you can achieve up to 10x performance on CRUD operations by dropping SQLite with its rows and columns approach. Vivien and Markus will look into basic APIs, queries, interop with RxJava, and Kotlin support.

Another focus of the talk will be object references, where relational databases and object-oriented languages collide. SQLite-based ORMs struggle with object relations or don’t even support them. For ObjectBox, object relations are an essential part of the database and are mostly transparent in Java code: developers get to decide to load relations lazily or eagerly.

Also, ObjectBox handles evolving data schemas differently than other databases. You will learn that ObjectBox only relies on the class model and thus does many updates automatically. Accordingly, trivial data model changes require no (e.g. add/remove properties/entities) or little (e.g. renames) developer intervention.

Markus and Vivien are the founders of ObjectBox. They are also the team behind the widely known open source libraries EventBus and greenDAO, which are currently used by 25% of the top-500 apps on the app store.

You are currently witnessing the greatest shift in consumer behaviour since the move from web experience to the ‘mobile moment’, and it’s all around you. Reminders, music, shopping, information, smart home control and more can now be summoned with just a simple utterance, enabled by devices which don’t resemble the grey-box computer or the smart phones we’ve grown used to. In this talk Max will share with you:

• How the Alexa community creates more and more delightful experiences for customers every day

• How Alexa helps people with their daily lives in so many ways

• What we mean by Alexa being truly everywhere

You are currently witnessing the greatest shift in consumer behaviour since the move from web experience to the ‘mobile moment’, and it’s all around you. Reminders, music, shopping, information, smart home control and more can now be summoned with just a simple utterance, enabled by devices which don’t resemble the grey-box computer or the smart phones we’ve grown used to. In this talk Max will share with you:

• How the Alexa community creates more and more delightful experiences for customers every day

• How Alexa helps people with their daily lives in so many ways

• What we mean by Alexa being truly everywhere

During this talk Dr Lukasz K Bonenberg will share with you what is the difference between android.gms.location and android.location libraries, the advantages and disadvantages of using android.location, why GNSS community is so excited about android.location and what additional GNSS knowledge you need to have to enable the functionality. You will also learn about what information is already available from Google and European GNSS Agency (GSA).

For years, you’ve been looking at one type of consumer of your work: the end user - the one for whom you are developing our apps. The Android community has been growing and, most of all, it’s been collaborating! Code, blog posts and talks - for all these types of content that you are producing, the consumer is you. All of you! From code reviewers, team-mates, other developers that use our work, to the future “you” that needs to maintain the code.

For the first type of consumers you have specialized roles that advocate for them – like product owners and UI/UX designers – but for the second type, you don’t. As developers, it ends up being your responsibility to look at the content you are producing from the perspective of the target audience.

Florina will share with you a look at the “content - consumer” relationship in the same way you look at the “app - end-user” relationship. You will explore what kind of questions you need to answer to improve the quality of your work, satisfy your content consumers and, in turn, improve the end-user experience.

Writing reliable tests is not easy for many reasons, especially when asynchronous code is involved. Some libraries can be used to create a testable architecture (for example Dagger and RxJava) and to simplify testing (Mockito, AssertJ and DaggerMock). In this talk you'll learn how to write JVM and Espresso tests with particular attention on how to replace real objects with mocks and how to test asynchronous RxJava code. In this talk, you will also explore:

• how to take advantage of Mockito and other libraries to write good JVM and Espresso tests in both Java and Kotlin
• how to use DaggerMock (an open source library available on github to avoid boilerplate code in tests
• how to test asynchronous RxJava code using a JVM test

Every engineer has great intentions when diving into a codebase. You want to make the code beautiful, easy to read, and modular. However as time passes and quick-fix bugs are put in, somehow your android codebase turned into a mess of multiple levels of inheritance of views and fragments and it takes forever to figure out exactly where a certain component exists.

Alice will share with you common poor patterns within android that many developers make and how to avoid or refactor them. All these mistakes previously existed within the Pinterest codebase! During Alice's talk you will learn: static class patterns and why they're a pain, separating away network calls from the main views, writing testable code, and misuse of a static eventbus. Alice's android team at Pinterest has learnt a lot through the process of refactoring their entire codebase to MVP paradigm and would like to share it with everyone else!

Authentication is one of the most frustrating parts of using apps and websites, and a serious bottleneck for growth. What if authentication could be reduced to a single tap, without compromising on security?

OpenYOLO is a protocol for credential exchange between apps and the user's credential manager, and it achieves exactly this goal. It is a new OpenID Foundation standard which allows for programmatic access and update of user credentials. It is being fully supported by 1Password, Dashlane, Google, Keeper and LastPass.

In this talk Iain will describe how OpenYOLO works, and share with you examples of how it can be easily integrated into an existing application.

Window insets have long been a source of confusion to developers, and that’s because they are indeed very confusing! The system dispatches Insets for many reasons, such as drawing behind navigation bars, full-screen immersive modes or handling round displays.

In this session Chris will deep-dive on the situations where you need to consider Window Insets, and how you can handle them without resorting to copying random code from StackOverflow.

You will learn the answers to questions such as: ‘How do I handle these in my custom view?’, ‘How do I draw behind the status bar?’ and ‘What was the developer of AppBarLayout thinking?!’

It's not an easy task to build libraries when your users are actually developers. In this talk Emma will share with you the value a library can bring, with real life examples.

Emma will start out with some points to consider during designing phase, where to do the failure handling, and how much responsibility can actually a library take. Next you will learn all the steps involved in publishing to a central repo, keeping versioning and changelogs in mind.

But how to depend on those libraries? Developers should be trusted to update their dependencies without using dynamic dependencies that add nondeterminism to the build. Moreover, there are tricks for preventing libraries to add permissions silently to your app.

In this talk Josh will share how Kotlin isn’t just syntactic sugar, it’s a better way to build Android apps. We will start with a modern java-based Android project and walk through a complete migration to Kotlin.

In the process, you will see objective examples of how the Android concepts you're already familiar with are expressed in Kotlin more accurately, with less code, and with far fewer chances for bugs!

"Shame is the most powerful, master emotion. It’s the fear that we’re not good enough. Vulnerability is about showing up and being seen. It’s tough to do that when we’re terrified about what people might see or think." - - Brené Brown

We live in a society that's motivated by comparison, in a culture in which everything you do is never enough, one in which you are constantly engaging with people using shame, either to shame or to be shamed, and in which making yourself vulnerable – exposing your fears and uncertainties, taking emotional risks - is considered a form of weakness, and something most of us want to run away from.

But as an Android developer you cannot run away from being vulnerable. No matter your level, you will be constantly exposed, you are constantly vulnerable. With pull requests, stack overflow (questions or answers), blog posts, talks... You are being vulnerable. Unfortunately that means you are also more exposed to being shamed, to being told off on how wrong you are, or how little knowledge you have. This kind of behavior can be toxic and can lead to people feeling insecure about themselves (hello impostor syndrome).

It's not only you. This is something that affects all of us the moment we decide to be developers. And it has an impact in our growth, our jobs and the way we interact back with the community.

Anastasia will explore what shame and vulnerability really are, how we perceive it and how it affect us in the core of our interactions and our job. What makes Android developers vulnerable. You will learn the tools you are already using to fight against shaming behaviour, and what we can do in our day to day job to make it even better.

With this talk Anastasia want everyone to leave the talk knowing they are good enough, they are brave enough, and they can put a stop to toxic behavior we don't realize we do.

Android apps are fun to dogfood but sometimes complex to configure for testers. To be developed fast, apps need internal builds that don't rely on server teams. To test effectively, internal testers need options to force edge cases and navigate quickly.

To receive feedback, developers need to provide discoverable options to send reports. Tools like Dagger and Gradle build variants have made these wishes a reality for many, and Eric will also dig into how everyone can retrofit existing projects to be quickly configurable.

Eric will cover creative ways to get runtime bindings and debug options up and running in Android apps, old and new.

Android Things is the new kid on the IoT block, it brings all the power of Android development to hardware platforms & IoT devices. Any Android developer can start using the Android SDK and many of the APIs that we are familiar with, to blink a LED, build a cloud doorbell, the next IoT product or our own (non-evil) robot army.

In this talk, you will learn the new set of APIs that Android Things bring to devs, what supports, how to start and how to approach the platform as hobbyist, without necessary having an electronics background and how to build some Android powered robots.

Developers and designers want the same thing: the best possible product out there. However, cooperation between the two vastly different disciplines is rarely seamless. What can be done to make the dev-design interaction work better? How can we improve the communication and cooperation?

In this joint talk, with a developer and a designer, Juhani and Pierluigi will share with you usual pain points from both points of view and explain how to best avoid them.

You will also learn how a seamless cooperation can lead into a new wave of very rapid prototyping using Android as the platform. The tools and libraries available for Android designers and developers now allow small teams of two to build complete functional prototypes in just two days.

Juhani and Pierluigi will also explore how to best get detailed designs communicated in a form that developers will understand them and how they best get feedback from designers for adding that extra polish to projects and prototypes.

Bluetooth Low Energy (BLE) powers the Internet of Things (IoT): smart watches, smart bulbs, and smart cars all use it for short-range communication. Now that 90% of Android consumer devices and 100% of Android Things devices run software that supports BLE, there’s never been a better time for Android developers to jump into the rapidly-growing IoT ecosystem and start building their own companion apps or custom smart devices.

Unfortunately, Android’s Bluetooth stack has a well-deserved reputation for being difficult to work with. The documentation is patchy, the API abstractions are leaky, and the stack itself is unreliable. Stuart worked through all these challenges while building a pro audio app at the start of 2017, and now he's sharing his story with you to save you time.

The beginning of this talk will cover BLE basics. The remainder will showcase code samples and strategies for tackling the quirks of the Android Bluetooth stack. No prior experience with BLE is required to enjoy this talk. You’ll leave excited to tinker with BLE on Android and equipped with a roadmap and toolkit to help you navigate the nasty parts.

Since the release of Kotlin 1.1 there is now the new language feature of Kotlin Coroutines available for use in Java and Android projects. Coroutines are a new way to write asynchronous and non-blocking code. They can be thought of as light-weight threads without having to deal with all the problems that threads bring to the table.

A lot of developers think that Kotlin Coroutines are mainly or only useful for Kotlin on the JVM, but that’s not true. There are a variety of use cases in which the application of Coroutines can make a lot of sense on Android.

This talk is introducing the ideas behind Kotlin Coroutines, showing how to use them in Kotlin code for both the JVM and Android via the kotlinx-coroutines APIs and then exploring specific applications in Android. Part of this is a deeper look into the use of Coroutines in higher-level frameworks such as AsyncAwait and Anko.

Those trendy, flashy and allusive Android devices in your pockets have allowed you to solve numerous problems but at the same time, introduced an indefinite amount of security related threats. Currently there is a large number of Android users who find themselves in an exciting yet hostile environment that without mobile devices, life would become tougher in many aspects.

This Android environment that you find yourself in is not new so why are you still worrying about mobile security? Hackers are constantly using multiple tools, techniques and targets to achieve their goals. Perhaps a hacker narrative describing how Android targets are exploited and defended may provide some insight into where you currently are, how you got here and where you are going so that you can worry less and Android more.

Pasquale and Emil are really excited to open source a new piece of the Litho framework: Sections. Sections are built on top of Litho to provide a declarative and composable API for writing highly-optimized lists. While Litho Components are used for displaying pieces of UI, Sections are a way of structuring the data and translating it into Litho Components.

Previously you might have heard about how Litho can help improve the performance of your apps. In this session you will learn how Litho helps you write less and cleaner code and allow you to focus on shipping great features to your users.

Kotlin has established itself in the Android development community since v1.0 last year, and with official support announced at I/O this year, it’s an exciting time to get started with this language in your work.

This talk will take you through Deliveroo’s journey from a full Java codebase to using Kotlin across the project. Learn how to get your colleagues involved and convert them to Kotlin supporters. You will also learn how they got started, the problems they ran into and how Kotlin can improve your codebase, your app and your sanity.

Amazing UX, delighting UI, wonderful performance.. You already know what to do in order to make users love your app when using it. But as app session lasts around 5 minutes, there’s a large portion of the day where your app is not being used. When your app is sound asleep what can you do to remind your users that your app is the best?

Britt will explore how to make your app pop and shine, even when is not on the foreground, and increase retention dramatically! Brand new Android O features, notifications, shortcuts, animated launcher icons.. Your app won’t be sleeping for long ;)

Artificial intelligence, Machine Learning and Deep Learning have become the latest buzzwords in the tech industry. You hear about image or object recognition all the time and they start to appear in our mobile apps more and more often. But there is still very few usage of direct application of deep learning in mobile apps, most of them are cloud based solution. Qian and Yoann decided to build a PoC (Proof of Concept) using deep learning technologies on mobile devices to see how things would work.

The project Magritte was born out of our curiosity for on-device intelligence. It’s an educational application that helps people learn language, by leveraging TensorFlow to recognize daily objects. You will learn how Qian and Yoann trained and optimized the models for mobile application, the possibility of building an architecture to receive image updates from mobile apps in order to retrain the model and distributing the new models to mobiles apps. If you are an Android developer who is curious about deep learning, this is the slot for you.