Welcome to this coming back here of .droidconGreece

When you use Android App Bundles (AAB), you get an initial size saving through splitting your application by: screen density, language and ABI.
But that’s just the beginning!
With AAB as your distribution format, you can use the Play Core library to make your app smaller, on-demand and always up-to-date

In this talk you will learn about AAB, dynamic delivery and the features that the Play Core library enables in your applications. It will cover:
* Why and how to start using AAB and dynamic delivery
What is the Play Core library and how it interacts with dynamic delivery
* On-demand delivery of additional modules and language resources
* In app updates, covering blocking and non-blocking flows with some bonus UX considerations

We’ll finish by looking at how you can use the new Internal App Sharing to distribute your test builds.

Are you a web developer who always wanted to write an app for both iOS and Android, but want to write it only once? Do you want a true, performant, native app, but don’t want to learn yet another language, yet another framework and get used to yet another IDE? With NativeScript, this is easier than you might think! NativeScript is an open source framework that lets you build truly native apps from one code base using Angular, Vue.js, TypeScript or JavaScript. You will get 100% access to all native APIs directly from your JavaScript or TypeScript code. In the workshop we will build a robust Video On Demand (VOD) app and a Music Streaming App with NativeScript and Android. And Peter Eijgermans show you NativeScript’s strongest capabilities to access Android APIs inside JavaScript/TypeScript.

Screenshot Testing is a fast, simple, and fun way to develop UI while keeping your sanity and avoid visual regression bugs. In this talk Nikos and Christoforos will explain what is Screenshot Testing and how it protects and speeds up UI development. They’ll point out some common gotchas while paving the road to the “perfect pull-request”.

Since the early days of mobile that we keep seeing new frameworks being designed to overcome one of the biggest challenges:
* How can I develop for both Android and iOS?

Although it’s initial promises, when we talk about performance, maintainability or even customization we keep discarding these solutions and we always choose native.

Fast forward to the present, and now we have two new languages: Android is Kotlin first and iOS, Swift. And if you put them side by side you can see a lot of similarities between both what will ease switching between one to the other if you have to develop for both platforms.

But what I told that you could just develop in Kotlin and run it seamlessly on all devices?

Here comes Kotlin Multiplatform!

Dagger has become one of the most widely used libraries in Android development, and is often one of the first to be thought of when bootstrapping a new project, but there are still many nuances and caveats that often get overlooked!

Many questions arose after the adoption of Kotlin, on how to continue following best practices from Java, so whether you’re using dagger-android or vanilla Dagger, I’ll go through some tips and tricks to make sure you’re using Dagger to it’s best capacity.

Are you willing to share your biometric identification with someone else? Thanks to Zero Knowledge Proof(ZKP) you don’t have to. With ZKP you can convince about your identity without sharing it.

Blockchain is disrupting software industry. The term itself has become a popular topic. Everyone is talking about blockchain and its usages in decentralized applications. How can we be part of it? In this talk, i am going to explain to you roughly about dApps, Blockchains, and how can we interact our Mobile Android App with the Ethereum Network.

In this talk we’ll see how, using a large deal of the Kotlin Coroutines API, we can build asynchronous mechanisms in Android applications, which are testable, scalable and clean.

We’ll touch upon the topic of dispatching, thread switching and synchronization mechanisms, building operators using coroutines, and creating our own API which abstracts away the threading, contexts and dispatching logic of coroutines.

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.

Let’s recharge!

Let’s recharge!

Jetpack’s Navigation component solves many long-running pains of every Android developer. We were early adopters of it at Air Bank Germany. Our large codebase is packed with the current best practices including multiple modules. Come to learn more about our architecture with focus on navigation. Dark corners, hidden gotchas and practical examples incoming.

AutoML has been is product that has been helping many people create custom machine learning models without having any code experience. However it was always hard to use these models in mobile apps. At Google I/O 19 the firebase team announced support for AutoML in firebase, making it easier for mobile developers to access these custom models in their apps. This talk will cover what AutoML is and how we can use these custom machine learning model in our android app through firebase.

Developing mobile games with Unity has become more and more popular these years, and Unity developers often need to tackle OS specific challenges.

Through this talk you will discover how to work with Unity as an Android Developer. You will see how to build Unity plugins using the JNI and Java/Kotlin, which is the most efficient way to link Unity with the Android framework.

Every Unity project can be exported as an Android Studio project with a Gradle support. You’ll also see how you can integrate Unity inside a native Android Java/Kotlin application, or how to get a full control of the build process so you can benefit from the best of both worlds.

Nowadays the hype around Flutter is raising a lot. But what about the “(not so) old-fashioned” React Native?
In this talk, we will see the basics and the differences between the two frameworks. In particular, we will understand how to build User Interfaces and how the internals of the two framework works. Finally, we will try to understand when and why to choose a cross-platform framework and which of the two.
All this journey is based on the true story of an Android Developer that he wanted to explore the cross-platform jungle both for work and fun reasons.

Kotlin Multiplatform is a language feature that allows compiling Kotlin code for Java, JavaScript, iOS, and even Native targets. While there are plenty of resources on how to use this feature, this session takes a look at converting a real-world Java Swing Application to Kotlin Multiplatform and when it actually makes sense to use it.

Starting from with the basics of Kotlin Multiplatform, you will get to see its
beauty and simplicity. After that, you will learn about gotchas, caveats and
lessons learnt from converting and refactoring a Java Desktop Application to Kotlin and running it on multiple target platforms. In this talk, we will take a look at running our refactored code in the browser.

You’ll leave this talk with a solid grasp of what’s possible with Kotlin
Multiplatform, where it makes sense to use it and where it maybe doesn’t.

Building a decent app is easy this day, there are plenty of tutorials, videos and blog post about it. In this session, I’ll try to go over some of the top mistakes that every one of us is doing while building his app. This will cover all the aspects of building a bad app- technical, UI & UX, and product. So each one of you will be able to adapt his favorite bad pattern and ruin his app.

You can either have a break or join us in an impromptu Speechless session

You can either have a break or join us in an impromptu Speechless session

We’ve made some mistakes building our client-facing SDKs over the last two years at Babylon Health.

RxJava has been around in Android development for years, and we’ve learned a great deal about it. It’s a powerful tool, but with great power comes great responsibility. And really – you should always use the right tool for the job, not the most “powerful” one. Now we have a new tool in our toolbox – Coroutines – and they seem better suited to a typical Android business layer. It doesn’t mean RxJava should be entirely out of the window, as for us it’s still quite useful on the UI layer.

We’re here to share why and how we went from a heavily RxJava based SDK architecture to a more client and developer-friendly approach replacing most of our code with Kotlin & Coroutines and compare both solutions.

We will admit to mistakes, share the principles that guided us in our planning for fixing them and show you how we came up with a plan and executed it.

Are you tired of decrypting the JUnit test that you wrote a few weeks back?
Do you want to write nice, readable & structured tests that are actually fun to write and joy to read?

If you have answered yes to at least one of the questions above, I have a solution for you. Join this talk and fall again in love with unit testing.

We will cover:
– Describe how Spek works
– Comparison with JUnit
– Sample tests for a project following a clean architecture pattern (data, domain & view layer)

Do APK or app size matters?
Does a user think about the APK size before downloading it?
Does a user think about space, an app occupying on the phone?
Is your App size is more than just a few MBs?

What if we provide very basic functionality and let the user decide whether he wants the advanced or additional functionality or not?

Yes, The user thinks about the app size before downloading or updating an app which has a size larger than a few MBs. The user thinks about the data also over which he will be downloading or updating that app. He or she even think about how much space will it take on his or her device. In this fight of space in the device and size of the app, the apps having a smaller size and frequent utility wins the battle.

What if we provide very basic functionality and let the user decide whether he wants the advanced or additional functionality or not. What if he or she can download only the features he needs on demand and keep the app compact.

Google new feature of dynamic delivery enables us to deliver the features on demand. This helps us to reduce the size of APK and even enables the user to choose what features he needs. From a developers perspective, this is very easy to implement and maintain.

Even we (Sharechat) were also at the same state where the size of APK was an issue with the new set of features we were trying to implement. Google Dynamic delivery came to the rescue.

What is actually a dynamic delivery?
How can we reduce the APK size with it?
How it can help a user?
How to implement it in Android?
How difficult is it to implement in the existing code base?
How will it look to the user in the app?

Well, let’s get all these questions answered in the talk along with our experiences and challenges we faced.

React Native is an awesome cross-platform solution with which you can just write once (in Javascript) and run anywhere, or… is it?

In this talk, I’m gonna show you some real-life examples of why React Native projects still need from Android experts if they want to create really amazing apps and I’ll share with you some of the things I’ve learnt working as an Android developer in the React Native infrastructure team at Skyscanner.

The success of any technology is depending on its ecosystem. We want to see meaningful APIs and effective SDKs, but we also rely on the community ecosystem and its support.

Whereas K/N is relying on Kotlin as a language, K/N will need the support of libraries that provide with extra functionality. JetBrains is doing a great job in this direction, but this needs to rely as well on the community.

Learn on this talk what are the current State of the Art libraries for K/N, how to get started with them and apply them in your projects. We will showcase libraries from some of the main actors in the K/N realm (JetBrains, Touchlab), as well as some of the independent agents arising.

Unit, integration, UI tests are part of the famous test pyramid, different tools were used in order to full fill it, but still today there are lot of issues about how to execute it in a proper manner and how to sync all environments (local, ci, etc) in order to satisfy all the testing criteria, and having a good reports.

From IO 2018 with the announcement of project Nitrogen, Google’d like to “nitrogenize” our tests creating a single entry point and solve all issues
we had in the past. With October release of Robolectric 4.0 and androidx.test 1.0.0, both testing environments are converging on a set of common test APIs. Robolectric now supports the AndroidJUnit4 test runner, ActivityTestRule, and Espresso for interacting with UI components.

Let’s see togheter how to organise different levels of our ‘test pyramid’, with a focus to the last news/releases in order ot be ready for the Nitrogen release.

Thanks to the latest advancements in Machine Learning, we’re now capable of interacting with machines through natural language. The age of voice assistants is here with Alexa, the Google Assistant and others. But, as an Android developer, what can I do on my existing app in relation to conversational features?

When we think about developing features that are voice-forward, we think about existing voice assistants such as Alexa and the Google Assistant. What about the fully-capable computers that we have with us all the time, our smartphones? Some moments on our day to day lives are very well suited for voice interactions: while in a car or cooking for example. Let’s not forget that voice interactions are extremely accessible, not only in a physical way (for people with dexterity or motion impediments) but also in a cognitive way (I think we all have a loved one in our lives that really struggles with technology, and people from some emerging countries have very limited access to computers and are not at ease with technology).

In this talk, I’ll explain what integrations can be done on Android:
– 1st-party solutions such as the SpeechRecognizer and TextToSpeech APIs
– Other Google solutions such as ML Kit, TensorFlow and Dialogflow
– 3rd-party solutions such as Porcupine, Snips, Amazon Lex, Snowboy and PocketSphinx
– Integration with the Google Assistant via App Actions

An application ID might define your app among all others, but its signature is what proves and confirms its identity and integrity. From working in distributed teams to fending off fraudulent clones of your application, you eventually come to understand the importance of signatures.

In this talk we’ll take a deep dive into the Android keystore system, certificates and  signatures, and go over key points necessary for any application’s long and productive life. Also, we will cover some security tips and tricks that will help ensure your app is safe to use, even if the users are faced with its evil twin.

At the end you should walk away with a deeper insight into everyday mechanisms that are often taken for granted, and the impact that they have on your users’ security.

While Dagger has been the go to library for DI in Android, in this talk we explore Koin (which recently hit 2.0) and see whether it can be a viable alternative for you and how it compares with Dagger.

For the last couple of years, Room was the preferable solution for work with SQLite. But recently was released a new version of SQLDelight with kotlin multiplatform support, overhauled API and full generated kotlin code, RxJava2 extensions, paging library support and many more. With its feature of live typesafe code generation from SQL queries with the help of Android Studio plugin is hard to compete. So is it still worth considering other solutions?

In this session, we will go through the core features of SQLDelight and in the live demo, we will see how SQLDelight works. We will go through the main use cases and will think about future possible use cases of multiplatform application of SQLDelight. You’ll leave this talk with a solid understanding of how SQLDelight works and the confidence to get started.

–Bring your laptop–

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 and this guarantees the privacy protection that a lot of different use cases need.
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.
This is a live session where you will be able to try all the development tools needed to unleash all the capabilities of a Neural Processing Unit

Key takeaways:
– Understanding the advantages of using on-device AI
– Having an overview of our platform for on-device AI
– Realize a full Android app that integrates computer vision capabilities

Let’s recharge!

Let’s recharge!

Google introduced the Google Play Instant feature few years ago and more recently a new way to package an application with dynamic delivery capabilities. The user can now access instantly to a native application through a simple link without installation and then download only the main features at the installation-time (to delay the download of certain optional features).
During the presentation I will introduce this new package format, its benefits, and show you how to use it to deliver your application on the Play Store (even an existing app).
You will learn how to architecture your application to take advantage of this new bundle format and benefit from dynamic delivery. Finally I will provide additional development guidelines to enable Instant Application without cost.
At the end of the presentation, you will be able to transform an existing application to an optimized native app.

Whether you’re coming from the Android world or not, you’ve probably heard about Kotlin (the programming language) and its asynchronous programming concept called Coroutines. It’s a neat concept that helps you create execution blocks similar to light-weight threads, while at the same time allowing you to write your asynchronous code in a synchronous fashion.

On the other hand, many of us got really (really) used to Reactive Extensions in many languages, and we prefer to go down this road. With ReactiveX, you can chain your asynchronous blocks in future-like structures, and easily control threading around them.

Well, you know how it usually goes – you read about something (aha! what is this coroutines thing)… maybe you see a couple of talks on the topic, maybe you get interested. After you try it out and decide to use it in a real project, you start typing your code… and boom! Your program crashes. You then go to StackOverflow to check for answers to your problem, and surprise: you’re not handling errors properly. You copy-paste the solution without any edits or tests and you’re ready for release.

Hopefully this is not you. You want to check everything before using a new language or library, you want to fully understand the consequences of switching over to a different solution from the one you currently have. There are some quirks in every approach, sure, but do you know all of the corner cases?

That’s why we need to have this talk. Let’s go together through the most interesting examples of how we can get (and handle) errors with ReactiveX and Coroutines.

What sets apart a good action is personalizing the experience for each user, adapting to their needs and offer the best experience for whichever device the user is currently using. Customizing the responses, storing information and manipulating the medium of the displayed response, can all be achieved by learning how to leverage the AoG SDK. Together we will learn the differences between the DialogFlow SDK and the AoG SDK, how to perform all the above and some best practices that will help you build your action faster and better.

ML Kit is the SDK that makes machine learning features more straightforward for the mobile developers to incorporate in their apps. Since ML Kit has been made a core ingredient of Firebase ,its robust ML APIs can be implemented seamlessly in both android & IOS apps like it’s any other feature such as analytics, crashlytics etc.

The flexibility provided by ML Kit for mobile developers to use On-device or On-Cloud ML Apis as per the use case is quite significant . In this session we will take deep dive in the different ready to use APIs of ML Kit encapsulating the features of Mobile Vision, Google Cloud Vision API, TensorFlow Lite and Neural Network API and also will discuss how custom models can be hosted seamlessly.We will understand new features such as Language Identification & Smart Reply using NLP . Additionally , we will look into the applications of recently announced Object Detection and Tracking APIs along with sneak peek into AutoML Vision Edge using which custom image classification models can be created as per our requirements .

Clean Architecture and app modularization are often used together to achieve a better code structure and a faster build time. But how can we use Dagger in an app structured in that way? Can we use subcomponents (with or without Dagger Android) or are component dependencies enough?
In this talk we’ll see how to leverage Dagger to organize the dependencies in a multi-module project with particular attention to testing and decoupling. The examples will be both in a standard layered architecture and in a Clean Architecture where the Dependency Inversion increases the overall structure but can complicate the Dagger code.

Android Studio is the tool of the trade hands down. When it comes to Android (app/library/IOT) development, the first thing that comes to mind is to install Android Studio and get going from there. However, it has not been a smooth road as expected for me. In my own experience, I talk about my love-hate relationship with Android Studio. I try to cover what Android Studio gets right and what it doesn’t. The talk focuses on how to be embrace performance when Android Studio is the bottleneck in the workflow (slow build times and reduced productivity), how switching to a terminal and various tools that exist in the ecosystem can give Android developers the much-needed speed boost and in-depth view in their development workflow. By the end of this talk, you would have embraces a workflow that allows for increased productivity and faster development.

Android then and now