Are you excited about Jetpack Compose? Do you love playing & making games? Have you got that designer itch which makes you want to develop creative apps? Or you love the motion design and micro-interactions? Although Jetpack Compose is a toolkit to create Android UI in a declarative form with the power of Kotlin language. But it can be used as a canvas for generative art, animations, or even games. In this session, we'll take a look at the capabilities of Canvas API for Jetpack Compose and how can we implement different kinds of animations with it. We'll also dig into game development and discuss some common challenges like game loop, state management etc. We will also explore other UI animations and transitions with Jetpack Compose. By the end of this talk, we'll be more familiar with the concepts of Canvas in Jetpack Compose and how we can use it during development to write animations or games.

MobX is a state-management library that makes it simple to connect the reactive data of your application with the UI. In this talk I will be sharing my experience of architecting Flutter application efficiently using MobX.

This talk would be focused on helping developers understand how to use the new Jetpack Compose UI toolkit in your application. This session would be divided into the following sections, 1. How to start composing your UI? 2. Understanding what Compose does under the hood. 3. Making a Custom View that can be integrated into your existing application. 4. Testing in Jetpack Compose 5. Future of Compose with Multiplatform 6. Fun experiments with Compose We are going to develop some amazing UI set using compose and in the process, will build some custom UI widgets. We will integrate it with existing Android Architecture components like ViewModel, LiveData, Pagination, etc.

Navigation is a fundamental aspect of any Android application. The AndroidX Navigation library sets out to provide an easy way to handle navigation in an application. Unfortunately, AndroidX Navigation doesn't work very well in multi-module projects. So what can you do about this? This session will cover: - Why I think navigation is interesting - The challenges I have faced with AndroidX Navigation - Approaches for navigation in multi-module projects - An alternative way of thinking about the screens in your application

Productivity Engineering is fast becoming an integral part of the development & release process in the Software Engineering world today. The benefits of implementing Productivity Engineering significantly outweigh the cost and frustration of inactivity in this space. In this session, we will discuss the importance of productivity engineering and why Android developers & teams should embrace productivity engineering as part of their development lifecycle. We will cover topics on how to make a compelling case for productivity engineering to your team and manager using data, we will also cover tips to improve your build, work with build scans to quickly find build problems & collaborate with team members to resolve them, and build caching to significantly speed-up builds. I will take you through a real-life example of using Gradle Enterprise to diagnose builds, improve build experience, and make a business case for a focus on Productivity Engineering. You will leave this talk with a better understanding and appreciation for Productivity Engineering. You will also learn the current tips & tools on how to improve your android builds and the value proposition of Gradle Enterprise to make data-driven decisions to continuously improve your build process and developer productivity.

Come and ask the Jetpack engineering and Developer Relations teams your Android Jetpack related questions in this roundtable discussion.

One of the top requests from Android developers has landed via PlayCore API, enabling Developers to request their users to review the app or game without switching to Play Store, with a straightforward flow, designed to simplify user feedback. In this session we will cover the implementation details, the best practices, policies and at the same time demystifying some of the most common confusions.

Is our unit testing practice stuck in the past? How about a modern testing practice for a modern language like Kotlin? Property-based testing is a step up from traditional unit tests. Learn how to start using it today in your Android app for testing your ViewModels, even without adding new libraries!

Today's business user expects their enterprise applications to be as appealing and intuitive as the apps they use daily in their personal lives. The challenge is to capture the complexity of business transactions while maintaining the look and feel of a modern Android app. In this session, see how SAP has extended Material Design with Fiori Design to build a modern and sleek UI for the business user.

Design Thinking isn't just for UX Designers. It's for everyone. It's a human-centric, empathy-driven approach to solve problems with out-of-the-box thinking. In this talk, we'll go over what Design Thinking is, what it looks like for Developers, and how to put it into practice with the help of Design Thinking workshops.

As software matures, more functionality is added, code gets moved, re-written or removed. In the same rhythm, team members change and with them historical knowledge might get lost. For that reason, it is important to have a well-organized project, that is inviting for new contributors while still digestible for one-off readers. Understanding how data is structured can be very helpful as an initial step for diving into the abstract modeling of the business domain. Database schemas, then, provide that entry window, but building the mental model out of a machine-readable format can be a daunting task even for seasoned engineers, especially when the project grows large and changes rapidly. In this talk, we will learn how this challenge drove the creation of FloorPlan, an open source Kotlin library to translate database schemas into ER diagrams, discuss its development and application for the team of 20+ Android engineers at SoundCloud.

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

A lot of our applications depends on the technical bricks provided by the Play Services such as Google Maps, the push notifications by Firebase or even the Play Store for deploying our apps all around the world. What if you are building apps for a device that does not implement the Play Services. With this talk you will have a glimpse of the tools you can use to build your Android applications without the Play Services such as OpenStreetMap, OpenPush or alternative ways to deploy an APK.

Android development can often feel overwhelming - there's so, so many things to take care of around a single app. Here's a brief look at all the things* that an Android developer would have to consider, do, and test for in order to create the theoretically perfect application, to serve as a practical checklist for starting your next Android project.

Over the last two years, Google has released multiple new versions of Google Play Billing Library, also known as BillingClient. We're now in the 3.x line of library releases and quite a lot of things have changed again - both on the side of your Android application as well as on a backend flow implementation. There is now a need to acknowledge payments and a flurry of new subscription features like restore and hold. But how many of all these new features are really required and have to be supported by your app? Before you spend weeks on potentially unnecessary work, this session will provide you with a quick and easy way to catch up. If you have been working with GPBL 1.x or 2.x for a while and want to upgrade, this is the place to be.

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

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

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

Android reverse engineering & malware injection. As Android engineers, we often like tinkering with the platform and for us, it is much easier to recognise some patterns while analyzing malicious code which gives us a huge advantage. This talk aims to explore the basics of reverse engineering, trending tools. How to decompile, disassemble the application, how to find malicious code snippets and what are the possible pitfalls. Difference between static and dynamic analysis. A little bit about Smali and DEX compilers. We will have 2 live demos. First: show how to reverse engineer an application and second: at the end of the session, we will decompile APK, plant malicious code, repackage again and install on the device to test it for educational purposes. Also will provide some introductory info on what is the Catch The Flag challenges and how we can practise.

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

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

Year 2020 has not only been the year of the pandemic, but also the year which set the division between “The Past” and “The Future” in apps development. With JetpackCompose and Kotlin MultiPlatform reaching “Alpha” stage in August 2020, The Future will already start in 2021, the year where both technologies will reach “Stable” stage. The Future is a clean cut from The Past, as “MultiPlatform” will become the preferred choice. We will see many platform-specific technologies (LiveData, RxJava, Dagger, Retrofit, Room, etc.) losing their centrality, replaced by KMP technologies such as StateFlow, Coroutines, Ktor, Serialization, SqlDelight, etc. In this talk I will present the D-KMP architecture which is based on the 3 pillars: - DeclarativeUIs (JetpackCompose on Android, SwiftUI on iOS, Kotlin/React on Web) - KMP (Kotlin MultiPlatform) - MVI pattern (Model-View-Intent)

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

The talk aims to explain the steps to integrate Google Assistant using DialogFlow for Jenkins CI environment. It includes to steps to build an interaction model to know the status of the running jobs, run jobs (if not running) and automate the overall process.

Model-View-Update (MVU) What? Elm? What is this new shiny MV* pattern that everyone is talking about on flutter chatter? While MVU finds itself increasingly adopted across different technology stacks, it has its origins in the community of the functional programming language Elm. In this session, you will learn → About the Elm Architecture → What's MVU → The Dartea library to implement the Elm Architecture in Flutter → Functional Reactive Programming → Why Functional Reactive Programming is powerful and efficient → Similarities between the Elm Architecture and ****

How many times have you measured your app start-up times to reduce the bounce rates? Do you check out the size and contents of third party libraries before including them in your project? Have your users complained that your app is eating away their RAM or draining their battery or is very slow? Does your build take a lot of time or does your layout take a considerable time to render, and you do not know why is that happening? This is everything that this session is all about. With my co-speaker's experience of building a SDK powering more than 8000 applications and reaching out to millions of devices worldwide and my experience of building world’s first regional and India’s second-largest Mobile OS and developed for the Government of India reaching out 100 million users, we will be talking about profiling your app, using Benchmark by Jetpack, measuring your UI & App bootup intervals, memory monitoring, handling memory leaks, battery optimizations and other improvement techniques which will help you understand the nuances of Android App Performance. We will also be breaking the myths related to Android App performance. This session is catered to each and everyone out there, from beginners to experts who want to understand how to measure the performance and improve their app using the best practices and Android developer toolkits.

Introductory for jetpack benchmark, I'll explain: - Why we need benchmark, - How to setup the project for Jetpack Benchmark - Run the benchmark - and how to integrate it with CI/CD

Building an app truly modular is hard. Lending ideas from actors and event sourcing is one approach I've found successful. I've used it for several applications over the last couple of years, started with Java & Rx. With Kotlin coroutines, channels, and flows we can now even omit Rx or other external libraries to make it happen. From this session, you'll get inspiration and some practical examples of the following: - Encapsulated mutable state - Modularization - Event sourcing and what benefits it gives an app. - Exchanging Rx for coroutines, channels, and flows. I will show one concrete implementation and discuss variations that might suit your app better.

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

Reactive Extensions are widely used on large scale successful Android applications, and for this, the most popular library is an adaptation of these Reactive Extensions, the very well known RxJava. What if we could use the existing Kotlin suspending functions asynchronously to return more than a single value? How could we return multiple asynchronously backed results in Kotlin? Kotlin Flows to the rescue! Would Kotlin Flows replace RxJava in the long term on the Android platform? How could we start migrating smoothly to Flow on hybrid (Java & Kotlin) languages apps? Can we fully avoid using callbacks now? StateFlow to the rescue!

Writing a compiler plugin is an uncharted area for many. With the introduction of Arrow Meta, writing compiler plugins just got easier. It's a library that provides a functional API for creating plugins. In this talk, we’ll learn about how to write and test compiler plugins with Arrow Meta. This library provides an API for source transformations, automatic code refactoring, and much more. We’ll look at use cases from source transformations, IDE plugins and custom type checking that are made possible with Arrow Meta. We’ll also look at how to test each use case. Under the hood, Arrow Meta supplements the compiler by hooking into the various compilation phases. We'll look at Arrow Meta works. By the end of this talk, you will have a tool that you could use to create plugins.

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

Enterprise Mobile Applications are rapidly growing and providing a large set of features to the users. As mobile application codebase grows bigger, it becomes hard to maintain and scale the application in a conventional single module, generally called the ‘app’. It starts challenging the growth due to various problems such as tight feature coupling, lack of defect isolation, longer feedback loop, slower time to market, scaling the team, etc. Modularizing the application is at rescue to overcome these problems. It is not a naive concept to break the big system into subsystems, it’s been there for backend services since quite some time now in the form of microservices. On top of that, it also helps to leverage dynamic feature delivery. We have faced the same challenge as highlighted above for a couple of our clients who have rapid growth of application. At a certain point, we were a 75 people distributed team working on 5 features at the same time and wanted to grow more but it was already hard not to step into each other's toes with the existing structure. We started outlining our modularization approach and after finishing it, we have seen tremendous success like a feedback loop time reduced by ~25%, time to develop new features reduced by ~20% and scaling the team size by ~30% etc. Modular mobile application architecture is nothing new, It was also highlighted in Google IO 2019. However, As a part of this session, we will mainly focus on the transition to modularization and also the internals of it. At a very high level the outline of the session will be: - Pain points of monolith application - Objective of modularization - Modularized architecture - Different approaches of how features interact with each other with code examples - How to approach the modularization in a large codebase and where to start? - Success story of a real world example

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

The whole session will revolve around the Jetpack Navigation Components in Android. From setting up the Navigation Component to real-life use cases, everything will be covered.

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

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

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

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

Mockito has been used in testing kotlin/android apps since long, however there is setup required and a lot of boilerplate code required to test certain kotlin components as well as a need to use other libraries like PowerMock for the features that Mockito doesn’t support. Mockk, a mocking framework with first-class support for kotlin features, comes to the rescue and helps developers write unit tests easily as well as improve code coverage without having to do extra setup/ write boilerplate code or use other mocking frameworks. In this session, we will look at codebase of an android app and learn the following, 1- how mockk can help us test the various application components(objects, classes, enums, constructors, chaining calls, hierarchial mocking, verification order, extension functions, coroutines, deferred and suspending functions, private and static functions, methods where callback is an argument, exceptions, capturing and replaying arguments, relaxed mocking) 2- how mockk is better than mockito in testing 1 3- which is better for code coverage - mockk vs mockito By the end of this session, the attendees will have good knowledge about mockk and will be prepared to use mockk in their projects.

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

Kotlin Multiplatform is here to stay! We start to see several products in production that are already migrating part of their code/ implementing new features with KMP. The goal here is simple, develop your application logic once and use it on every platform. So join me on the next two hours on this multiplatform adventure and let’s create an app for android and iOS.

In this session, we will be going through how far we have come with existing UI tools and what challenges it presented, and why something like Jetpack Compose is needed. We will learn how Jetpack Compose accelerates Android App development by creating a complex app UI in a few lines of code. While making the app we will go through core concepts of Jetpack Compose and how it handles state management, rendering, performance, and how Kotlin compliments compose. At last, we will see how Jetpack compose can be adapted to our current projects and how soon we can be ready for production apps with compose. Key Learnings: Get to know the basics of Jetpack Compose Translate basics to a working App Best practices for complex UIs and performance.

Design Systems help us streamline the way we create experiences. They introduce a common way of working, common language, predictability and speed. Over the past 12 months at Trade Me we’ve extended our in-house Design System, Tangram, to include Android and iOS. Join me in this session as I take you on the journey of creating Tangram with Material Design Components. You’ll learn what Design Systems are, and why they’re so useful in larger organizations. We’ll dive in to creating a mobile Design System by balancing brand with native look and feel. We’ll see how MDC made implementing Tangram across three large apps easy. Finally we’ll look at future proofing, and how MDC and Tangram is ready for Compose. Keywords: Material Design Components, Jetpack, Dark Mode, Design Systems, Compose

Most developers (who writes test cases, but doesn't yet follow TDD) are interested in or willing to follow TDD, the only factor stopping them from following TDD is confusion. In this session, I'll try to remove that confusion, so that developers can follow TDD without hesitation. I'll be talking about following TDD, what should be the process, and how exactly should you approach TDD. While discussing on TDD, I'll also be discussing on writing test cases with Spek DSL and the different styles of DSL offered by Spek. I'll also be showing how to setup Spek. We'll be writing a feature, following TDD and coding live in the session. Spek being a DSL is descriptive way of writing rest cases, thus making them more readable and better organized, which will help further to understand TDD. Moreover, if you're new in android-dev, but have prior experience in web, you'll find Spek more familiar than traditional JUnit4 unit testing.

Enabling an enhanced audio experience for your users is the topmost priority for developers who build audio processing apps. Android, however, holds dark secrets about low latency audio, thus making it harder for developers to build responsive audio apps and user experiences. This talk uncovers those dark secrets while also giving a quick rundown on working with Native code along with Kotlin and how the platform has evolved over time to fix the issues with Low Latency Audio. Towards the end, Oboe library for building real-time audio apps is introduced showcasing how it simplifies everything.

Lately, more and more android projects are adopting multi-module setup. The number of modules for a project can vary and some projects can even have more than a hundred modules. Managing these modules can then be very cumbersome as it involves a lot of copying and pasting common settings and codes between build.gradle files. Some teams utilize buildscript.ext and apply from: statements to try to remedy this issue. However, these methods are very limited in terms of functionalities. In this talk, I will discuss how the Gradle plugin works, and how we can write a custom plugin in Kotlin to help us manage an Android multi-module project. I will also present techniques to provide custom configurations in our Gradle plugin so that we can modify our build depending on the module, and further, extend the plugin's capabilities by integrating it with other Gradle plugins; e.g., Jacoco plugin. Lastly, I will share our experience of building a Gradle plugin and explore the benefits and limitations that I've encountered.

There are a lot of decisions developers need to make when developing an app, such as: selecting the best color for a button, how often an ad will be shown or how fast the protagonist of our game should run. While these might seem like small changes, they can make a huge influence on your app’s success when put together. In this talk, Rosário will show you how to run A/B tests using Firebase, how to interpret the test results and the recommended actions to take based on those results. Expect to come out of the session with knowledge on how Firebase Remote Config integrates with Google Analytics for Firebase to help you make better decisions for your app’s success.

It was the best of performance, it was the worst of debuggability. Mobile applications inherently require multithreading. This complexity has spawned innumerable libraries and design patterns to guard against losing countless hours solving incomprehensible bugs. During this talk, we will discuss how developers have tried to solve this with mutexes, immutability, and thread-confinement. We believe that two design patterns have emerged: immutable objects and transactional objects. We will compare and contrast these two implementations and show how Realm’s new Kotlin Native SDK with Multiplatform support walks a fine line between the two, helping developers more easily deliver bug-free multithreaded mobile applications.

Traditional asynchronous paradigms such as callbacks and RxJava use ‘continuation passing,’ which litters our code with boilerplate ceremony. If you want Coroutines to turn your asynchronous code into a thing of beauty, come take a clean and simple live-coding journey from ‘Hello World’ to a fully functioning IOT ping-pong air cannon. Even if you’ve already been using Coroutines, this talk is for you. So get ready to duck!

While Espresso is an incredibly powerful UI automation framework, it can be daunting to implement in a way that easily scales. Daniel works at Trade Me - one of New Zealand's biggest Tech employers - and spends a lot of his day worrying about scale. Chief among them: how to make speedy and reliable testing frameworks that are easily adopted, a breeze to maintain, and owned by dozens of engineers across many skill-levels and geographies. No small task! Daniel's keen to share his journey with Espresso with you. He'll demonstrates the way forwards that he and Trade Me have chosen, that results in beautiful test code, able to be written by anyone. Key takeaways: - Page Object Design Pattern optimises for maintainability - Abstracting Espresso itself can make the code more readable - Mocking API calls increases the speed, reliability and repeatability of your tests - Internal libraries make code shareable between application codebases - Taking this approach makes life easier for cross-platform teams

Messaging app users have high feature expectations that have extended to all apps with communication features including supporting video and voice communications. In this session we’ll show you how to add both to an existing app using Sendbird’s Calls SDK.

In this session, my major aim would be to provide an overview of the different tools one could use to power their Android apps with Machine Learning and also discuss the new additions for Machine Learning in Android 11 specifically the Model Binding Plugin and ML Kit. I would first go on to explain the standard procedure of using pre-trained models with MLKit. I would show how we could take the idea of MLKit forward and use pre-trained models from TensorFlow Hub to run right in the app, which would provide support to build high-quality machine learning apps based on models contributed from the community. I would then show how we could use custom TFLite models in Android apps, I would also talk about TensorFlow Model Maker and ML Model binding plugin in Android Studio through which I plan to show how easy it is to now use custom TF Lite models in Android apps. With Android 11 the NN API now supports Asymmetric integer weights making model sizes and inferences even smaller opening up an even larger opportunities for edge ML. If time persists, I would also show demos about the above topics.

Dividing the module of a Monolithic Android app to realise multi-module application is considered as an important concern in recent Android development. This session distils all the pitfalls and best practices in building a complex app and take a look at the usefulness of multi-module application and how we implemented Dependency Injection in our consumer app at Gojek(superapp.is) Some of the highlight points of this session are : 1. Reintroduction to DI 2. Reintroduction to Dagger-Android 3. DI in single module projects 4. DI hotness in multi-module projects 5. Realise DI in multi-module projects using Dagger2

With the ever increasing complexity of mobile applications, you would always want to avoid user reviews like "this app is janky" or "it is too slow on my device". So in this session I will talk about about how complex layouts can cause this janky behaviour, how to diagnose it and then finally some tips on writing efficient layouts.

Do you enjoy company evaluation time? Your code reads like poetry, your unit tests are behavior driven executable specifications, the animations you implemented are the best that has ever happened to you app since sliced bread. However when evaluation time rolls around there's always something to keep you from your goals: joining that cool project, getting that raise, becoming tech lead/product manager/engineering manager etc. How come your manager doesn't understand....? We focus a lot on hard tech we often forget to plan our professional and career development. Getting better at Android is simply not enough to reach your goals. In this session we will dive how you get the recognition you deserve by utilizing your manager. * What do you want? * Reverse engineering your manager ** What does your manager want? ** What does your business want? ** What does your HR want? ** How to make it easy for your manager? * Manage your manager ** Set expectations with your manager ** Tell your manager what to do ** Ask your manager for help ** Set goals for your manager Key takeaways: After this session you will * have an actionable plan for the next 6-12 months on how to utilize your manager to maximize your career progress. * understand how you manager thinks This sessions targets: * anybody from entry level positions up to middle management * working at a medium-large company with middle management structures and dedicated HR (If you work at an early stage startup or are a freelancer this session is not very actionable.) The session is based on my experience in Rakuten, where I moved from entry level android developer, to senor engineer, to tech lead and to application architect over the last 5 years. Another other major influence is books, in particular "Soft Skills: The software developer's life manual" and "Peopleware: Productive Projects and Teams". Keywords: Career & levelling up & skill focussed talks

Remote is finally here, and it's going to stay. In this talk, Marco and Gian will go through what it means to work remotely for a startup — from both a developer and a manager point of view. They'll share some tips and tricks on how to stay organized and focused, how to manage deadlines and the team organization, how to take care of your mental health, and the pros and cons of hiring remotely. They both work for Uniwhere, a venture-backed startup that went remote-first more than two years ago and is now working with 4 different time-zones.

Setting up CI/CD pipeline should be the first thing an Android developer should do when starting a new project. Think automatic versioning, verification of pull requests, completing JIRA tasks, and automated deploys to Firebase App Distribution or Google Play. Yet many projects are still doing all of that manually. Is it hard to setup? Or too expensive? I will show you a free, easy-to-configure and flexible way with GitHub Actions and Kotlin scripts.

Offline and Mobile are two sides of the same coin. Enterprises need their mobile applications to deliver uninterrupted access, whether they are in a board room or at ground zero, especially for mission-critical scenarios. Building an application with some local cache capabilities may seem easy, but building an offline app that works seamlessly could be extremely hard. An ideal offline application should efficiently download the voluminous initial data, maintain the standard for each subsequent delta download, adeptly perform local CRUD operations, and excel at resolving data conflicts between the local store and the cloud server. In this session, we'll see how SAP helps application developers deliver an offline experience that is similar to an online experience.

I will be happy to share our experience and open source library for Kotlin Multiplatform development: this is a way how to do native mobile apps with single shared code with while business logic. We know that going to talk – we have been doing Kotlin Multiplatform already more than 1 year and have been working on 10 mobile projects on this (6 in Stores and 4 in production). Our expertise was approved by community (https://blog.usejournal.com/the-dos-and-donts-of-mobile-development-with-kotlin-multiplatform-db7c098545c0) and JetBrains, the creator on Kotlin. As the result, we done a open source library that helps to do multiplatform projects as easy as native, just a few steps, but for both platforms at the same time. The Key features ok Kotlin MPP and our library are: 1. Significantly reducing development cost and time based on reusable modules and components: from 4-6 months development time become is 1-2 weeks. 2. Platform allows full OSs support (iOS, Android) and native UI user experience based on native programming language (Kotlin) and the newest technology stack (Kotlin Multiplatform). 3. Single Code Instance for iOS and Android platforms increase quality and make architecture is more confidential. 4. Kotlin is a game changer right now in mobile industry (Google preferrers it to Java) and Jave developers move to Kotlin very quickly https://youtu.be/PsaFVLr8t4E?t=435

ConcatAdapter is a new api exposed in recycler view which enables us to sequentially combine multiple adapters. Learn how to better encapsulate your adapters having different data sources. Different use cases where concat adapter can be used in an easy & elegant way.

One of the most powerful software quality tools are code reviews - an activity in which a developer, other than the author, examines a software deliverable for defects, and improvement opportunities. For a new Engineer, a code review can be a valuable learning resource, and for a more experienced Engineer it can be a good teaching mechanism when done properly. Whether you are a fresh college graduate, or a Senior Engineer with multiple years of experience under your belt, this talk will take you on the journey of a team that transformed their code review process from being vague and lacking, to being the biggest investment of their resulting, high quality code output. By the end of this talk your perspective on code reviews should change and you will approach code reviews as what they really are - a Software Engineer's Best Friend (woof! woof!)