There is a common misconception that junior developers are a burden and won’t be delivering value for the first months or even years. Yet after observing not only my own but other's contributions to teams while still being junior developers, I realised that even though our technical skills were still developing, our insights could prove useful to the teams from day one. In this session, I want us to discuss some of these misconceptions and help juniors and teams alike understand the real value they can bring to a project or company. Because a good developer is worth hiring no matter their experience level.

Working with a design system can be hugely rewarding: layouts can be created and modified using shared components. This should result in faster development and consistent designs across the app. But getting there is a slow and painful process. When implementing a design system you have to make many decisions, like: Where do you start? What actually makes a component? And how flexible should components be? This talk will shed some light on these issues by taking you through Deliveroo's process of adopting a design system in its three Android apps.

You want to style the title of dialogs throughout your app and you think it should be simple enough. However, once you dive into it, you might start asking questions - should I use alertDialogTheme or alertDialogStyle? Should I use dialogTitle, windowTitle or textAppearanceLarge? It is no secret that the styling and theming system in Android is complex, but I promise there is some method to the madness! We can avoid writing custom components just to achieve pixel perfection if we know how tame to the beast. In this talk, we will learn about the difference between themes and styles, the hierarchy of different styling techniques and how to use them effectively. We will also learn how they work internally, and the best practices of how to apply them. We will wrap up by discussing the newest app theme in town - the Material Components Theme and the attributes that come with it, like “colorOnSurface”. At the end of this talk, you will know how to style your app like a pro with the correct use of Styles, Themes, TextAppearance and sensible defaults while specifying colour, shape and typography through Material Theming.

You’ve heard, seen or witnessed the buzz around MotionLayout. But what does it really look like in real life? What are some of its current limitations? How easy is it to use? Are the demos that we’ve seen actually possible? Or is it all a ruse and they’ve been created in Adobe After Effects? In this talk, you’ll learn some of the fundamentals of MotionLayout through the development of an animation taken straight from one of those crazy Dribbble shots. A shot that you see and then doubt whether it’s even possible on Android. Throughout this talk, you’ll see some animated goodness and you’ll learn how MotionLayout works, the basics for creating a layout using it, what a MotionScene is, what KeyFrames are and more! You will leave this talk armed with the basic knowledge required to start having fun with MotionLayout and creating your own animations and transitions. And you'll realise that the mad animations or transitions that your designers give you are now possible! To never saying “no” to designers again*! * Ok, sometimes you’ll still have to say no.

If you are into mobile development, you probably heard of Flutter. It's the new kid in the block and offers you a native cross-platform development environment. Even before the stable version, big companies like Alibaba decided to move their applications to Flutter. Sfter it became stable, it got even more attention. One of the biggest advertisements for the Flutter is "You won't say no to your UI/UX designer anymore" and one of the biggest reason for this is: Animations. Flutter comes with a lot of out of the box tools for creating fancy animations. Its Skia Engine is also helping the developers to render the graphics faster so users can have a better experience with the animations. At FlutterLive, a tool called Flare is announced. It helps developers to create 2D animations faster and efficient. In this talk, we will go through, how you can create the widely used animations in Flutter by explaining the key concepts of it by starting from very beginner level and going to the advanced level. And of course, we will see some code :)

Navigating between screens is pretty simple right? No it’s not. Actually not all the time. Last year Google introduced Navigation Component tool helping us standardise the design and the implementation of how screens can pass in front of the Android users. We started to use it with my team last summer and we learned a lot about its benefits, and its pitfalls. In this presentation, I'll try to give a feedback about what we learned, what hope you can put in it and what’s not to expect from it. Here is an outline of the talk: - The Navigation Component tool and API - Testing your navigation - Specific use cases - Handling multi start points - Handling custom transitions and Shared Elements - How to handle other entities than Fragments - Handling the back navigation - Implementing the navigation logic - 3 examples of implementation patterns we found - Alternative example to Navigation Components - The lib is in alpha, what is it implied by this, for real - Single or Multiple activities what to choose? - Integrate nav controller in an existing app - Conclusion - What can it bring to your app? - Should we use it?

Generating Kotlin extension functions lets developers balance at the edge of previously established boundaries of what can and cannot be done in Annotation Processing. As a part of this talk you will learn: 1. What are the current approaches for Annotation Processing and what are their issues? 2. How generating Kotlin extension functions can help with Annotation Processing (with proof-of-concept examples)?

Modularization is the new trend, almost everybody in the Android ecosystem is refactoring their apps to use a modularized approach. We at Sky are no different, we had a big monolithic codebase supporting 4 apps in different countries that we started modularizing in September 2017. But we failed, big time. This talk is an honest retrospective of everything that went wrong, the bad decisions that we made, the approach we initially took and how we, against all odds, eventually started re-building a maintainable, sustainable and extensible modularized codebase. In this talk you will learn from our mistakes and struggles, like defining what is a module and its responsibilities, how to integrate Dagger in a multi-module environment, set some rules and best practices and much more but, more importantly, you will learn what not to do when modularizing your codebase.

If you’ve used Firebase Performance Monitoring, you know that it automatically discovers and reports performance metrics for all the HTTP transactions in your app. But have you ever wondered how it does that? Android doesn’t provide any APIs to listen in on an arbitrary connection (that would be a security problem!), and Firebase supports URLConnection, Apache, and OKHTTP APIs. The secret here is bytecode manipulation at build time using the Transform API provided by the Android build tools. Join this session to find out how the Firebase Performance Monitoring Gradle plugin intercepts and measures HTTP transactions at runtime with some assistance from bytecode manipulation at build time.

Think about almost everything you use an Activity for. Now replace the word Activity with Fragment. That's right, in a single activity app you start using fragments for almost everything. From UI to navigation, this is all better from a Fragment. In this talk Remco will be using real world examples on how single-activity will help you have a more reusable, maintainable and cleaner codebase. At IO 2018, Google published more architecture guidelines as well as a new navigation library. These both push for a Fragment-heavy, single-activity approach. We had the opportunity to apply this pattern in some of our apps. In one we decided to take a leap of faith and completely go single activity. We converted all our activities, at that point, to fragments and have not regretted this decision for a second. This talk will be covering navigation patterns, handling certain UI elements and system features like window insets, supporting Instant apps, analytics, and more.

WorkManager is the recommended solution for scheduling and executing deferrable background work in Android while taking care of compatibility issues and best practices for battery and system health for you. Work Manager can be used to solve many use cases that needs to be executed just once or that requires a periodic execution. This talk is about WorkManager, its API and how to migrate your application from Firebase JobDispatcher to it using some sample based on my experience working with WorkManager and supporting the Android developer community in the adoption of this new library.

Source: droidcon Turin 2019 When it comes to accessibility support, it can be difficult for teams to know what to focus on and how to get started. Sometimes it can be hard to justify the effort when teams think it only benefits a "few" users, which is a debatable assumption. Whether you're new to the subject or you're keen on knowing more about it, this talk is for you. In this talk, you will learn how supporting accessibility helps in a lot of different cases, from temporal illnesses or reversible situations to severe disabilities. Moreover, you will learn how people use different Android accessibility services such as Talkback or SwitchAccess to interact with your application in a different way. We will also explore the current range of developer tools that can be used to spot potential accessibility issues in our apps. And finally, you will learn how developers, designers and product managers can work together to make sure that we create experiences for everyone.

Source: droidcon Turin 2019 Data binding is great for eliminating boilerplate and keeping UIs in sync with your state… but there's a lot more that it can do. This talk will take you through the more advanced features of Data Binding, beyond the basics. It will cover using custom binding adapters, two-way binding, animations and testing considerations. Moreover it examines how using Data Binding influences your app's architecture. You'll learn how to get the most out of Data Binding so that you can write less repetitive, safer, efficient apps.

Source: droidcon Turin 2019 During a vacation, I have wanted to play a blitz chess game with a friend. We only had a chess board with us, but no chess clock. We looked for Android apps online, but none satisfied us. Hence, in February 2017 I have started writing a chess clock app for Android. In the beginning, the app got 0 to 5 installs per day. With time and some tricks, more and more user installed it. Now after almost two years 400 to 650 new users are installing the app every day; without a single dime spent on marketing. Daily active users are around 1500, weekly around 8500, monthly around 27000 users and it keeps on growing. I will walk you through my journey step by step. Everything started with research. Development of the app was next. Followed by user acquisition. Many tricks and tools have helped me to stay sane and focus along the way and will help you in making your application more successful too.

Source: droidcon Turin 2019 What does a developer do when a build takes 2 minutes? He gets bored and his mind starts to wander. Maybe he opens Reddit, Twitter orMedium or checks his emails. Switching context and multitasking kills productivity. Every developer needs fast feedback, so he can jump into the flow state. Therefore, fast builds are essential for productive development. First, we take a look into Gradle Build Scans. There is no sense in accelerating your build without measuring and comparing the different outcomes. Gradle Build Scans help you to understand what happens during your build and which parts consume the most time. Then we continue with basic tips to tweak your build with Gradle. Most of those tips are quick wins, because they only require a simple change in the gradle build settings. Finally, we take a look into how modularisation influences the build speed through an example. By doing it right you can change your business logic and run your tests in 2 seconds instead of 2 minutes.

Source: droidcon Turin 2019 Android allows developers to add download functionality to their apps, but if you want to extend that behaviour, or customise it to your liking — that’s not easy. That’s why at Novoda we created an improved version of the Download Manager. This is the perfect example to see how Android developers can share common code between more projects through an Android Library. In this talk we'll see how to get started creating a library, what are the difficulties we encountered and finally how to publish and share the library between multiple projects.

Source: droidcon Turin 2019 GraphQL is not new, and REST is still around. Is it already time to switch? What tools can we rely on, as of today? Is the framework ready and suitable for everyone around? At The New York Times, we invested heavily on this technology, so much that we actually created a whole new feature around it. Join us to discover the inner depths of GraphQL, how it works and how it can be integrated within a few days. Explore how you can make sure about what you write and test it out. And when it's time to optimize, maybe we can help it!

Source: droidcon Turin 2019 Lately, Android applications are becoming more complex by the hour. In this world, the architecture of your app has to step up to remain easy to maintain and scale. You have probably heard about "Clean Architecture", or you are already into it. The goal is to define different layers which have single responsibilities and good decoupling. In this talk we want to cover a specific layer, the data layer. We will explore how to use the Repository pattern to implement a Single Source of Truth in a clean way, but most importantly, why we failed at our first attempt so you can avoid making the same mistakes we did.

Source: droidcon Turin 2019 Mobile technologies are evolving, client's needs change over time, but what about your application's architecture? How can an architecture crafted 3 to 5 years ago be renewed, improved and changed on the go in order to fully meet the client's demands and to use the latest features that the SDK offer? In this session we will discuss about a case study involving the largest financial mobile application currently being developed here in Turin and how we are going through the migration from an "old" MVP ark to a much more modern MVVM model. We will cover aspects such as Android Ark Components, EventBus, and much more.

Source: droidcon Turin 2019 Today, most artificial intelligence services have to send your data to the Cloud in order to perform the analysis. With specific chipset capabilities, calculations can be done directly on the phone, with less risk of data getting leaked or hacked. Furthermore, AI apps tend to be real-time and mission-critical, any AI-use cases that enhance an experience can’t afford latency. With on-device computation you can improve the performance of your app and resolve privacy and cost related issues. In this session, I will show you how to use HiAI: a mobile computing platforms that make the developers able to run artificial intelligence algorithms on device.

Source: droidcon Turin 2019 A curated collection of authentic “ohhhhh”, “can’t believe it works”, and “WAIT YOU CAN DO THAT” experiences, evoked by some of the most disruptive properties of the Kotlin language, slowly refined through an artisanal all-natural process. [ gluten free / may contain traces of nuts ]

Source: droidcon Turin 2019 When writing networking code, you want to make sure the code between the client and server implementation is consistent. After spending hours defining the APIs with your backend engineers, you’ll probably need to spend even more time implementing those details over to your code (and guess what… your backend engineers will be doing the same!). This process is boring, time consuming, and prone to errors. Wouldn’t it be cool if this process were automated? If you could have classes and interfaces that mirror your API definition? And if they were automatically tested and ready to use out of the box? It can be done! At Yelp, we define our APIs using Swagger Specs and we successfully automated the generation of our networking code for both servers and clients (iOS & Android). On Android, we generate Kotlin Data Classes and Retrofit APIs that mirror our spec files and are ready to use for all engineers. In this talk, we will explore how we set up our code generation pipeline and how you can start doing it, too.

Source: droidcon Turin 2019 The Clean Architecture has been formalized by Robert C. Martin in 2012, it's quite new even if it's based on the SOLID principles (presented for the first time in early 2000). The biggest benefit that we get using this architecture is the code testability, indeed it separates the application code from the code connected to external factors (that usually is more difficult to test). In this talk we'll see a practical example of how to apply the SOLID principle with particular attention to the D of the acronym: the dependency inversion.

Source: droidcon Turin 2019 Even though Android is a mature platform by now, the adoption of Kotlin at Google I/O 2017 brought about a sweeping wave of freshness and enthusiasm amongst developers. Regardless of what the language and design patterns we use when writing an app, there is only one way to ensure correctness and quality: testing, static analysis and continuous integration. Many still think that setting up a CI for your project is hard, onerous, and not that useful, but we’re going to see how this is not true. Focusing on static analysis and unit testing, we’ll walk through setting up a continuous integration pipeline for a modern open source Android project using Gradle, CircleCI and Kotlin. We’ll see what benefits this brings to a codebase and how with a few tricks we can make sure external contributors adhere to the project code style, how we can prevent subtle bugs to sneak into the codebase, all with very little effort and zero budget.

Source: droidcon Turin 2019 Dagger is one of the most powerful libraries for dependency injection in Android, but its boilerplate and complexity can become overwhelming — especially if you’re new to it. It doesn’t have to be like that! Learn how to avoid writing unnecessary code to make Dagger work for you, speed up the development by optimising the build time, and how to take advantage of the new features in Android development, such as modularization and App Bundles.

Source: droidcon Turin 2019 You probably already know what Retrofit is and most likely you've been using it in conjunction with RxJava to handle asynchronous and concurrent network requests, but what if I told you there is an alternative and easier way? In this talk we'll be looking at another combination: Retrofit + Kotlin's coroutines! We'll be exploring why coroutines make a perfect match with Retrofit and how to migrate to them from an existing RxJava implementation with testing.

Source: droidcon Turin 2019 This talk will be a complete waste of everyone's time. But it should be fun.

Source: droidcon Turin 2019 MvRx is an Android development framework designed at Airbnb. It was designed to make Android development faster, easier, and more fun and it has been a wild success. 93% of the engineers in the pilot rated it an 8/10 or higher and once the pilot ended, it almost immediately became the go-to solution for nearly 100% of new screens from the simplest to the most complex. MvRx is Kotlin first, builds on top of Android Jetpack, and takes the pain out of Android development. In just the second half of 2018, literally hundreds of entirely new screens were created with MvRx at Airbnb and 100% of teams that were using React Native have chosen MvRx as their migration path back to native. Why has it been so successful and how can it help you? Come join Gabriel Peal talk about MvRx and what makes it so practical and effective in the real world. https://github.com/airbnb/MvRx

Source: droidcon Turin 2019 Developer tools for pixel pushing are one of the more under-developed areas when it comes to Android. Pixel pushing itself is such a tedious process that eats up a lot of development time. Some teams are lucky enough to utilize tools like Figma and Zeplin, which help reduce time when translating designs into something tangible. Others still use the tried and true method of using redlines, screenshots, and photoshop! In this talk we'll go through the journey of pixel pushing, the pain points, and some tips and tricks to help developers and designers speed things up. We'll then talk about Window, a new tool to help you master the art of pixel pushing. Window is a new free open source tool with the goal of enhancing the process of pixel pushing. First is the Window Android App. It lets developers and designers measure, add rulers / grids, and verify placement of what you're seeing on screen. The second is the Window Android library, to integrate into your projects. This library lets you export your Android UI and view it tools like Figma & Sketch. We'll talk about how you can use these two tools to help you simplify and potentially offload that work onto designers, so we can get you back some time!

Source: droidcon Turin 2019 In 2018 Android App Bundles were introduced as the publishing format for Android. Alongside this dynamic delivery enable shipping features to users on demand. In this session you'll learn about Android App Bundles, Dynamic Delivery and how to structure code and resources based on publicly available code samples. Also you'll learn how to make an instant experience available for your app.

Source: droidcon Berlin 2019 While the native widgets for Android are extremely powerful and cover most of the use cases we can imagine, there are still some areas where web content is our only option. That means we need to embed a WebView in our application and create a bridge between the native code and the JavaScript running on the web page we load. In this session you will learn everything there is about how to deal with the WebView on Android. Learn how to properly load content, inject your own CSS or JavaScript, how to effectively communicate between JavaScript and Android, and how to make loading web content secure in Android applications. We will also look at how to implement some common use cases, like displaying ePub and other HTML-based e-books.

Source: droidcon Turin 2019 The promise of cross-platform frameworks looks great on paper, and some of them do a pretty good job delivering actual results. But with inherent differences between platforms, is "build once, run anywhere" even worth pursuing? Learn how you can share parts of your app between mobile platforms (and even the web!) without compromising quality, and delivering a best in class Android experience. During this talk I'll explain some ideas on how to structure not only your code, but also your teams, I'll show how to implement your own Kotlin MP libraries and showcase a few ones that you can use out-of-the-box.

Source: droidcon Turin 2019 The introduction of Android Architecture Components made things are easier for the less experienced developers. However, In order to build robust, testable and scalable applications we need more. That's where the Unidirectional Data Flow architecture comes in, borrowed from Flex and Redux on the web. The approach is based on the idea of an immutable state that represents the state of our app. All the components are decoupled from each other, and they work together taking advantage of Kotlin's language features. We solve the asynchrony problem using Coroutines, specifically Channels and Actors. Do you want to know more? This talk will guide you through the implementation of this principle, with clear steps and a detailed explanation that will help you understand its value and spark your curiosity!

Source: droidcon Turin 2019 Software development is challenging because as a technical team, we have to figure out what to do, do it, and then make sure we’ve done it right. And each step requires effective communication. In this talk, we’ll look at various tools and techniques that can help propel your career by making you a more effective technical communicator. Learn what forms of communication are the most important to automate and which require a personal touch in your team’s daily activities. We’ll also discuss how you can best structure meetings to achieve your team’s goals. Finally, we’ll review some common challenges to effective communication and how you can navigate them successfully. Our coworkers aren’t all robots yet. Effective communication will continue to play a major role in the success of our teams. So let’s do it right!

Source: droidcon Turin 2019 Many teams are designed so that engineers can take an abstract view of the customer and focus on implementation. But when the customers are other engineers, that entire dynamic is thrown on it's head. In this talk, Ty will walk you through the best practices of building great products for developers, from research and team processes to the technical delivery. Topics covered will include: Building customer personas and product strategies, Developer Experience research and analytics, customer empathy and support structures, API Design and usability, testing, code distribution, and creating great documentation.

Source: droicon Turin 2019 Android apps are not just series of static screens. To create a great app you will have to bring it into life with meaningful, helpful and delightful motion. However, a good design is not worth much unless it gets implemented correctly. In this joint designer-developer talk we discuss the workflow from the idea, to design and development and all the way to user’ hands. We describe when to use motion and when not to as well as selecting the right type and right intensity of motion. We then dive into the best implementation strategies including communicating state, navigation, feedback, tutorial and delightful animations.

Animations bring your app to life but often we write them as pre-canned sequences that once started can’t be interrupted or redirected. Modern Android apps are reactive to state changes… your animations should be as well. This talk looks at techniques for writing animations that work like state machines, that can be interrupted or retargeted while running. We’ll look at ways to architect your animations to achieve this, and libraries and classes that we can utilize.

Source: droidcon Turin 2019 The promise of Kotlin/Native is intriguing: Write pure Kotlin code that, using the LLVM compiler, can be compiled to run natively practically anywhere. As Android developers, it's a particularly attractive proposition since quite a bit of Android development is already done in Kotlin - you wouldn't have to learn a whole new language, but you could work on new platforms. But what happens when you try to take that promise and use it to implement a real-world iOS and Android application? In this session, you'll hear the tale of a developer who's written separate native iOS and Android apps for years, and what happened when she worked to build out an app using Kotlin/Native. What are the things that work well? What are the things which are still a hot mess? What do Android developers need to be aware of when trying to write Kotlin code for iOS? Where do platform differences still matter? And how do you avoid the classic cross-platform pitfall of "Write once, run everywhere poorly?" by making good decisions about where to use shared code and where to avoid it?

Source: droidcon Turin 2019 The paging library offers a complete solution for efficiently displaying large lists of data but adopting such a comprehensive library can be daunting. In this talk, I’ll cover some of the lessons we learned while gradually migrating from a RecyclerView.Adapter, populated from a tightly coupled domain and presentation layers, to Paging library. You’ll learn about the main components of the Pagining library, where they fit in your architecture, how decoupling the UI and the data/domain layers results in more maintainable & testable code. You’ll understand which DataSource type you need for your use case see how you can display multiple data types in the same RecyclerView and how to handle other use cases like interactions with a view item, deleting or inserting an item, selection states or showing section headers. Learn from our experience how to migrate to paging and the benefits we saw.

Source: droidcon Turin 2019 Do you know how many hours you spend on your mobile phone? How many times do you pick it up? Studies show that an average person spends up to 4 hours daily on their phones, almost half of them scrolling in some kind of social media. Most of the time, at some moment, people are not even happy anymore using some apps, still, they cannot help themselves and just keep opening alerts and notifications from these apps every day, even every hour. We are all consumers of digital products but, more than that, we are its creators. Autoplay, infinite scroll, notifications about everything - we know how to make people spend more time than they actually want on our apps, we know how to grab their attention, create a habit - not good ones sometimes - and maybe we are creating meaningless experiences just to win the attention race, and maybe we are trapped in these "features" too. I will talk about Ethical Design: how can we be aware of non-ethical designs? How to create a better relationship with technology and develop digital products that respect the people that are going to use it.

Source: droidcon Turin 2019 With the advent of media streaming, consumption of content via Smart TVs and Streaming Media Players is skyrocketing. However, designing and developing apps for the Big Screen provides unique challenges: crafting an easy-to-navigate UI, implementing a fail-proof login experience, introducing new monetization models and more. In this session you will learn: • How to implement a solid TV-centric UI/UX • Navigate through case studies and scenarios for the 10-foot experience • Developer tools and APIs that facilitate the creation of high quality TV-centric apps