YouTube Playlist: https://www.youtube.com/watch?v=a5VhfEbfGuI&list=PLjQD4n5Df70GCaX0Uv-8hbWTfjZF47BxP 

YouTube Live: https://www.youtube.com/@AndroidWorldwide 

RSVP: https://android-worldwide.com/register/ 

Android Worldwide is back 🌍

It's time for another Android event 🙏

This is a perfect time for you to meet other engineers from around the world and learn from some incredible speakers.

Join Our next meetup on July 25th to catch the latest and greatest in the world of Android.

Event Agenda and sessions (EST) 📅

Tuesday, July 25th 🎙

Kotlin Multiplatform is very trendy technology to create cross-platform application. You could create android and iOS app with common code base. It is possible to achieve a lot of result with less efforts. Also there a bunch of solution from Google with their special Jetpack libraries. In my talk I would like to show you, how to make your android app multi-platform and use the most actual and modern stack of libraries.

10:20 AM - Building Managers Over 3rd Party SDKs for Easy Access

Anshul Khattar - Android Developer at Juno

A lot of times while integrating 3rd party SDKs, we copy paste boilerplate code again and again. Instead of this, building an SDK manager reduces boilerplate, promotes easy migration and much more.

11:25 AM - Battle of the Titans: RxJava vs Kotlin Coroutines

Ivan Dimitrov - Android Developer at Devexperts

Join us for an in-depth exploration of the world of Android app development as we compare and contrast RxJava and Kotlin Coroutines. We will delve into the similarities and differences between these two popular asynchronous programming frameworks, discuss their respective advantages and disadvantages, and evaluate their performance in real-world scenarios. Drawing from our own experience of rewriting a significant portion of our Android app from RxJava to Kotlin Coroutines, we will share practical insights, best practices, and lessons learned. By the end of this session, you will gain a better understanding of the strengths and limitations of each approach and be equipped to make informed decisions on which method may be best suited for your next Android project.

12:30 PM - Impact of Framework Choice on your Application: A Reverse Engineering Perspective

Ruben Pieters - Compiler Engineer

When developing an app you are faced with a difficult choice: which framework will you use to develop it? You can find evaluations of these frameworks containing their various pros and cons online. In this talk we want to dive a bit deeper into this topic by taking a reverse engineer's perspective: inspect and analyze the actual bundled application when using different frameworks. From this perspective, we will ask ourselves several questions related to the framework choice. What impact does the shared framework code have, does it meaningfully impact the overall app size or performance? If the framework allows you to write code in non-JVM based code, where does that end up and how is this code executed in the app? Are there any obvious differences in security caused by a choice of framework?

1:35 PM - Building Accessible Apps with Jetpack Compose

Karol Wrótniak - Mobile Developer, Droids On Roids

Even more than 15% of the world's population lives with some form of disability. Nowadays the accessibility starts to become required by law. In this session, I will describe: - the best practices for building accessible apps with Jetpack Compose - how to use Semantics modifier to make your Composables accessible - the common accessibility guidelines - how to test your app accessibility

2:40 PM - Six Things ViewBinding Teaches Us

Yauheni Slizh - Android Developer, Daresay by Knightec

View binding came some years ago and made our life easier. View binding is part of Android Jetpack and has a simple API to help us reduce boring work with findViewById or other libraries. How does it work internally, what principles use behind the scene, what problems await us when we're using? I will try to answer all these questions in my presentation. I want to share with you 6 lessons that I learned when working on View binding on different projects. I believe, It helps you avoid common mistakes and create a whole picture about 'How it works'.

3:45 PM - JetPack Compose Performance Tips & Tricks

Eury Pérez - Principal Android Developer, Google Developer Expert in Android

Compose is a great, intuitive and straightforward way to build our UI with the behavior in the same place. Nevertheless there are a few decisions we need to make when using compose to avoid affecting the performance like the composables stability, knowing in which phase to execute certain code, optimizations with tools like R8, and so on.

4:50 PM - Unveiling the Unseen Threat: Demystifying Memory Leaks in Android

Yves Kalume - Android Developer, Android GDE

Memory leaks can silently sabotage the performance and stability of Android applications, posing a significant challenge for developers. Memory leaks can be a silent and persistent performance killer. In this talk we will explore the causes, symptoms, and consequences of memory leaks, shedding light on how they can gradually degrade the user experience and impact device performance.

5:55 PM - Blast Off: Managing Hundreds of UI Updates for Emoji Cannons

Piotr Prus - Android Developer

Managing a state might be a challenge. Managing the state with hundreds of updates and constant recomposition of floating emojis is a challenge indeed. In this talk, I will share how to build emoji cannon that floods your screen with UI elements, update the state, and does not freeze your UI. All of that with Jetpack Compose. In addition to covering the technical aspects of building and managing a state, I will also share how to build a responsive UI that takes the user input and animates.

7:00 PM - Designing Jetpack Compose architecture for Gradual Migration from Fragments at Turo

Pavlo Stavytskyi - Sr. Staff Software Engineer at Turo

Many Android engineers are excited about adopting Jetpack Compose in their projects. However, in the majority of cases, the reality is that we have an existing codebase that relies on a legacy UI stack. In this talk, I will share how we designed a Jetpack Compose architecture at Turo that provides seamless integration in the existing fragment-based codebase. I will cover how we leveraged the power of Kotlin Symbol Processing (KSP) API in order to give a proper Jetpack Compose experience for our engineers while automatically preserving the compatibility with the rest of the codebase. This includes the abstraction over the navigation that hides implementation details of navigating between fragments and compose screens, and vice versa.