Item List

Let’s face it, ui testing is probably not on top of every developer's wishlist. Even though it is an important part of the development process, it can be a tedious and monotonous job.

This talk describes CTW’s effort to make writing test cases more efficient, safe, and expressive by leveraging Kotlin-specific features such as function types with receivers, extension and infix functions.

We’ll present a lightweight and type safe Kotlin DSL for ui testing that is being used as an alternative to frameworks such as Cucumber, while still achieving highly readable test cases directly in Kotlin code. We’ll also show how this approach can reduce code duplication, speedup writing test cases and improve productivity by building a repository of reusable actions and assertions that can take advantage of syntax autocompletion provided by the IDE. We’ll even get our feet wet with popular testing frameworks Espresso and UiAutomator and see how we're able to completely abstract away these implementations details.

By the end of this talk:
- you'll be able to write Kotlin test cases in a more natural language. If you don't believe it, test it out;
- you'll know how to extend and customise the DSL with your own keywords;
- you'll see how it is possible to cleanly use different testing frameworks such as Espresso and UiAutomator simultaneously.

Compose took on the table a new approach to developing in Android. Besides this great new framework, large portions of our apps won’t change at all, and Unidirectional Data Flow best practices should be used.

What will change in our project? Which patterns should we adapt in our app to work with these new techs? Is my app ready to be migrated with Compose? Let's see how use this new declarative UI framework in an already structured and organised project maintaining its own design pattern architecture.
What will be the advantages and disadvantages?

Unified Test Platform (UTP), best known as project code Nitrogen, it's another fantastic tech presented this year at Google IO. Let's see together what it is, why is so useful and why we should adopt it in our app.
We will use this extensible test executor to 'nitrogenize' our UI test suite covering some UI cases in our project. Let's scale together our test suite with Gradle managed devices in parallel using new test metrics, and finally, inspecting test results and possible failures by emulator snapshots.

After this talk, you will know if your app architecture is ready for Compose, you will be ready to transform your test suite into a more reliable scalable and productive env and you will speed up the delivery and the code quality of your project.

During my journey, I realized that the more I advanced in my career, the more time matters. In order to optimize my life, it was important to know the right tool for the right job and use it in the most effective way.

In this talk we will deep dive into 3 killer apps which I cannot live without: HTTP proxy, system keyboard utility and a secret tool. You will learn how to use them through real examples.

After this talk, your daily work won't be the same. Those tools will boost your efficiency to another level, allowing you to focus on what really matters.

Memory and threading in is some of the most difficult and complicated topics in Android. This talk introduces what memory leaks are, and why they’re so hard to find. Taken from excerpts of the newly published O'Reilly book "Programming Android with Kotlin: Achieving Structure Concurrency with Coroutines", this talk take a light-hearted approach at some of the colorful developments Android has gone through the years.

From “Why did AsyncTask get deprecated?” to resource leaks in background threads, we look at memory leaks in Android as we’ve uncovered them through the years. To understand quirks of memory leaks in Android, join us for some historical context, a little empathy, and a kinder view of open-source development.

Modularisation is a demanding topic. With modularisation, you can have extraordinary achievements or spectacular failures. We split 200k lines of monolith app modules into 160+ modules with 10+ developers. Now we can contribute faster, test features in isolation and use foundation modules for best practices.

With an increasing number of features and code, we needed a scalable codebase. During the process, we find out practical patterns, and we had lots of pitfalls. In the end, improved build speed, uncoupled features, strong foundation for best practices come with modularisation. Separated responsibility layers help team members contribute and contain changes in smaller efforts.

Correct modularisation is the foundation of having scalable codebases. From navigation to reusing views and resources, your mental model needs to change. In this talk, you will learn compelling problems you can encounter and how to overcome issues proficiently.

To download an image on Android, all you need are these lines of code:
val input = URL("https://cutecatsimage").openStream()
val bitmap = BitmapFactory.decodeStream(input)
imageView.setImageBitmap(input)
Why then, are there whole projects and teams dedicated to doing this on Android like Coil, Picasso, Glide, etc. In this talk we'll look under the hood at all the intricacies of downloading images, what we try to optimize for by using one of these frameworks, and the common problems they're trying to solve.

We live in an era where every 12 months a new shiny flagship phone is released with fancy OS features and (slightly?) better hardware. In this day and age the average lifetime of a shiny new phone is 2 years. What happens to your old phone at the end of the 2 years? Does it go to Android heaven or does it end up collecting dust inside a dark drawer? With a little bit of creativity and hard work we found a new purpose in life for our old phones and gave them a reason to continue living - turn them into a surveillance camera! We built an app that streams live video from one phone’s camera to another using WebRTC (Web Real-Time Communication), a free open source technology developed by Google. Unlike many conference talks that solve problems with CRUD systems, here we will talk about an omnipresent technology in the current remote work era and show you how you can use it to build a video streaming system. By the end of the talk you will be familiar with how WebRTC works and be ready to build a new video streaming app.

This talk emphasises how and why building Android apps using a concept called Server Driven Architecture for our UI layer is so important and current hot-topic.
We take a look at multiple offerings such as JetPack Compose or Epoxy (Airbnb's library) and we then take a look at some tips and tricks to navigate the code from start to finish.

How to deliver new apps fast?

This is probably one of the most heard questions in mobile development. There are no magical recipes, but luckily nowadays in the mobile world we have tools that help achieve this goal without compromising a fully native experience.

This talk will be a brief overview of our journey in the KMM world, considering the following topics:
- How the development of shared code approach for mobile apps fits in our business case;
- What we were able to share between the two platforms;
- How a single source of ‘truth’ can give more reliability, allied with a strong test coverage over the domain aspect of the App (avoiding divergences in the platforms);
- Some of the challenges we had during this journey, including the platform specific UI and UX (Compose, SwiftUI) and concurrency model.

Kotlin is wildly popular with Android development for its easy adoption, functional features, and cleaner syntax: but Kotlin offers much more than that.

With its coroutines language feature, Kotlin also offers new ways to solve concurrency problems in Android. From the newly published O'Reilly book "Programming Android with Kotlin: Achieving Structured Concurrency with Coroutines", this talk brings you a crash course on Android thread safety concepts, problems associated with parallel flow execution, and how structure concurrency offers solutions to these problems.

Dependency Injection is a complicated topic, and when used in a project that compiles to multiple targets through different compilers & runtimes, it can lead to serious headaches. However, the Inversion of Control pattern brings a lot of architecture features and safety.

In this talk, we will see how to use all the power of Kodein-DI, a popular dependency injection library that works everywhere Kotlin can compile to, in a mobile multi-platform project targeting Android, iOS and the mobile Web.

We will start by using the dependency injection pattern to abstract and test the behavior of multi-platform business modules. We will then see how to debug common dependency management errors.

In a second part, we will abstract & test behavior by embedding the DI library into popular behavior architecture patterns, such as MVP, MVVM or MVI, before showing how it can be implemented on each targeted platform.

Finally, we will enhance our common code using advanced features of Kodein-DI such as set bindings, lazy access, context, and scopes.

Koin (https://insert-koin.io) is a pragmatic dependency injection framework for Kotlin/Android developers, well known for its ease of use. In this session, I propose to see together how we can structure our components, for the following topics:
* Classical Components in MVP, MVVM
* Dealing with Scopes
* Jetpack Navigation
* Jetpack Compose
* Integrating with Multi Platform

And bonus, we will talk about incoming new features.