By Waseef Akhtar

The Navigation is a powerful component in Android Development which provide easy access to destinations in your app. If you’ve come to this article, you probably know that and considering the title of the story, you’ve probably implemented it before.

By Suraj Shah

Just in case you have been living under a rock and haven’t heard of Kotlin, I implore you do read this. And, if you have heard about it, tried it and used it at production level, then I would recommend you to read how an amazing compiler level optimization, which forms the basis for APIs like Collections and frameworks like Ktor, works.

By Ali Azaz Alam

Android Jetpack is a collection of components and libraries (represent as X) to build a better application and navigation architecture component is a part of it. Navigation Architecture Component is a collection of libraries and plugins that provide its own set of classes to get rid of complex  Fragment Transition including Bottom navigation → that we will discuss it in our next part.

By Josef Raska

There are many situations where you want to add functionality to all of an app’s screens. Examples can be: Analytics, Navigation, Displaying dialogs on screen, Handling runtime permissions, Reacting to lifecycle events for various libraries

By Magda Miu

The journey in Kotlin Wonderland continues with an article about classes and objects. Until now we discovered details about Kotlin philosophy, basic types, control flow expressions, null safety and functions.

By Adam Hurwitz

The Lifecycle 2.2.0 update including simplified initialization with by viewModels(), by activityViewModels(), and by navGraphViewModels(...) syntax for the ViewModel (VM) component is great for quickly creating VMs. What about re-using the VM instance throughout fragments, passing arguments/parameters into the VM while also enabling saved state? 

By Vasya Drobushkov

Error handling is fundamental in reactive programming. Reactive streams might fail with exception and propagate it as an event downstream notifying consumers on the error that happened. As in previous articles, we’ll try to compare RxJava and Kotlin Flow error handling mechanisms. This might help us to migrate existing code from RxJava to Kotlin Flow and also understand how to properly use Kotlin Flow.

By Michael Spitsin

I’ve seen and used different ways to organize work with lists of data through the adapters: vanilla method, delegates by type, each item as its own delegate and little bit exotic adapter’s composition. Each of them can be used in different situations. And what interesting, depending on the case and on the team agreements each can be more suitable to apply.

By Chirag Kunder

Kotlin DSL for Gradle provides a type-safe way to write build logic and an alternative syntax to the Groovy DSL. Kotlin, being a statically typed language, provides compile-time checking while enhancing developer experience with auto-completion, suggestions, refactoring, documentation, navigation, etc.

By Idan Atsmon

Each week I try to watch at least one session from the latest Google I/O or Android Dev Summit. I always learn something new, even with subjects that I am quite familiar with, and that is exactly why I keep watching year after year.

By Oleksandr Kucherenko

As Android native developer I was involved in upgrading our existing RN project. The business requirement was simple: Enable biometric authentication for users in our app. Business promise - Devs implement JTBD.

By Daniel Beleza

Tracking can be boring, but if we think it right, tracking has a huge role in a company, because it helps to plan and effectively decide the best path for each feature. Either if your app is an E-commerce, a game, or some day-to-day tool, Google Tag Manager (GTM) has a great tool to track your users' actions.

By Andrew Lord

When developing apps we will often need to use secret values that we don’t want anyone to get access to, such as tokens, IDs and API keys. There are many reasons they may be needed in our source code and in Gradle scripts, the most common being when we are asked to provide one to authenticate with a third-party API.

By Mark Ng

Choosing a dependency framework for your Android app is a big decision, it’s not something that you can easily replace later on. Dependency injection spans all layers of your app so it’s important that the DI framework that you choose meets all your requirements and that includes testing.

By Danny Preussler

Parameterized tests are a very powerful feature. Those are tests that are taking method parameters. This is very useful if we need multiple runs of the same test but with different input arguments.

By Igor Escodro

In 2018, Google Play introduced a new application serving model, the Dynamic Delivery, to help generating and serving optimized APKs based on the device configuration. It uses the Android App Bundle format to dynamically generate the APK for each device variant, which is much better than manually generating them.

By Fernando García Álvarez

This is a follow-up to my previous post about Scoped Storage, so I highly recommend reading that one first since this post will build upon that foundation. On February 19th, the first Developer Preview of Android 11 was released and it introduces changes to Scoped Storage, adding new features and fixing some annoyances.

By Patrick Cousins

I’m a big fan of determinism. It’s part of why I love Kotlin as a programming language. I like pushing problems to the compiler. I like using types for expressiveness and safety. And I really like sealed classes for representing state. One of the tools in Kotlin that allows us to achieve greater determinism is the language’s when expression.

By Fábio Carballo

In the previous article in this series on making use of custom Lint rules, we covered what is Lint and what we have to do to create a simple custom Lint rule. If you haven’t read it yet, I would highly recommend that you take a look to get some more context:

By Lukasz Kalnik

At grandcentrix we are looking into ways to improve the architecture of our apps. Recently we have found a way to use Kotlin functional programming features to simplify behavior injection. In Kotlin we have the possibility of declaring values of functional type. Let’s explore how we can use them to inject behavior in the classical three-layer Clean Architecture.

By Tam H. Doan

TL;DR: The plus sign in “@+id/” tells Android build tools that you are declaring a new resource. And if it does not exist, add to R.java file. But basically, you don’t have to think, just use “@+id/” anywhere you want!

By Tam H. Doan

TL;DR: To write JVM unit test for Android build version, you can: Modify the build version field at runtime or Create a wrapper for build version checking.

By Oleksandr Kucherenko

Man in The Middle — This is when they proxy between your app and server. Intercepting all requests and modifying data in both directions. Examples are: replacing TLS/SSL certificates by custom one, controlled by proxy code, and encrypt/decrypt/re-pack all data for server-side. HTTPS can up the bar for these scenarios.

By Mustafa Khaled

As we mentioned in part 1, FirebaseAppDistribution is a tool provided by Firebase where you can upload your beta .apk files. You can find many posts that use Slack channels as their CD channel. In my opinion, this isn’t a perfect channel because it’s plan limitation. Their free plan has storage of 4 GB for all channels within the workspace, which may limit your App APK files to be uploaded.

By Filipe Batista

The Android emulator has improved a lot these years (for reference how it was before, see this old StackOverflow question). Nowadays the emulator is much faster with better performance and with easy settings option.

By Mustafa Khaled

As an Android Engineer, think about how much time you waste in deploying an APK for someone to test. ⌛️It may be done in many steps, compile your project, run unit test, start generating your .apk file, then upload it to a third party (e.g. firebase distribution, diawi, etc ..). After that, you have to notify the testers that your build is ready for testing.

By Ali Azaz Alam

Powered by Android Jetpack (Google I/O 18 and soon in I/O 19). Being an android developer we mostly interact with fragments and we make sure to implement one activity architecture.

By Husayn Hakeem

Fragment constructor injection is now -and has been for a while- supported in Android thanks to FragmentFactory. While it isn’t an API developers have to use, it can be regarded as a better design approach in certain situations and can help when testing Fragments with external dependencies.

By Andrew Lord

For codebases with many different entities, most of us will at some point have hit a bug due to the wrong ID being assigned to a property or passed to a function. Why don’t we use the type system to give all of our IDs their own type and ensure this never happens again.

By Magda Miu

Kotlin promises concise, expressive and safe code. In the previous articles I covered topics like basic types, control flow instructions, equality checks, null safety. In this article we will have some fun with functions and learn new keywords from the Kotlin Wonderland.

By Tushar Saha

Method reference in Kotlin is one of the most talked about and loved features. I have always wondered how method reference internally works. Syntax is pretty straight forward. You can declare a method and pass it as shown below.

By Johann Blake

This article describes a new way of developing and testing Android apps/libraries although the primary focus will be on a new methodology in testing. This new form of development came about with the need to:

By Süleyman Fatih Giriş

We have seen how to use Flow in the repository layer and how to change the app theme with Flow & LiveData in Part I. In this post, we will see how to remove LiveData (even MediatorLiveData) and use only Flow in all layers. We will also dive deep into the common Flow operators like map, filter, transform, and more. In the end, we will implement a search bar example given by Sean McQuillan in “Fragmented Podcast — 187: Coroutines with Manuel Vivo & Sean McQuillan” with using Channel and Flow.

By Nikhil Panju

MotionLayout is the new kid on the block for animations, transitions, complex motions, what-have-you. In this article, we’re going to look at how MotionLayout and Coroutines can help us structure multi-step animations.

By Vasya Drobushkov

This article unfortunately is not that dive deep (because of complexity of internals of coroutines), but instead trying to compare RxJava and Kotlin Flow mostly as black box with trying to find out differences in behavior and how to migrate from RxJava with its backpressure solution to Kotlin Flow.Hopefully this article will give you direction on where to look at if you decide to migrate to Kotlin Flow. 

By Vasya Drobushkov

Modern Android development is based on Kotlin, which is interoperable with Java. Whenever we use some cool feature from Kotlin (say High-order functions) under the hood (when running on JVM) the feature is implemented in terms of Java bytecode. This might lead to some overheads in memory and performance if used without caution (for example excessive usage of lambdas with parameters without inlining might produce a lot of anonymous classes and put additional pressure on GC).

By Thierry Schellenbach

Android development has come a long way over the last few years. The Jetpack components significantly speed up development. In this tutorial, we’ll build a functional clone of WhatsApp with Kotlin. Building a messaging app used to be difficult; in this tutorial, you’ll get a chat experience up and running in roughly 20 minutes. 

By Roger Taracha

GOAL: The goal of this article is to demonstrate how to add a CI service to your project and use Fastlane to not only upload an APK to the same QA slack channel (for your team to review the app internally) but also add Firebase App Distribution to the mix. 🛠

By Federico Puy

Scope Functions do not introduce new technical capabilities, nor do they have a real impact on performance. So you may wonder, what´s the point in using them? Well, they are here for the same reason that the Kotlin Language was intended for. Making code easier to read, more concise, and more efficient to write.

By Zsolt Kocsi

Earlier on, I got inspired by the Kotlin-Pokedex project and its Flutter counterpart: flutter_pokedex, and started experimenting with a Compose-based solution for it, out of which compose-pokedex was born. All these projects are based on the beautiful original design done by Saepul Nahwan:

By Husayn Hakeem

FragmentContainerView is now the recommended View to use in order to host Fragments instead of the previously common way of using FrameLayouts. In addition to correctly handling Fragment transactions under the hood, it has some additional features that coordinate with Fragment behavior.

By Vipul Asri

Developing native apps for mobile is still a first choice for the businesses who are working at scale and want to reach masses with performance efficient products. We will not go into a debate on which platform outperforms another, that’s a whole different discussion.

By Vasya Drobushkov

For a long time RxJava was undisputed leader for reactive solutions on Android, though with Kotlin expansion and introducing cold streams (Flow) seems situation might be rapidly changing in the coming years. Though reactive programming is not related to threading in the first place, concurrency and parallelism are very important anyway.

By Dan Rusu

Java 8 streams are available to be used within Kotlin code when targeting JDK 8 or later. A common question among developers that use Kotlin for backend development is whether to use streams or sequences. Although Android developers can’t target JDK 8, I’ve included some surprises that affect the way we work with sequences and structure our code.

By Carlos Daniel

Have you realized that in some situations the basic ActivityRule is not enough to cover all the scenario for your tests? Moreover, what if we can write custom rules that define custom behaviours to save us from writing tons of code and to make like sort of setup procedures more shippable to other classes?

By Alexander Sitnikov

There’s a lot of articles explaining how to use scopes and create scoped components in Dagger 2, but hardly ever it is mentioned where to store those scoped components.

By Nikit Bhandari

In this blog post we will explore how we can use Tabs in Jetpack Compose. If you are interested in exploring other components in Jetpack Compose you can check out the series of articles that I have written.

By Igor Malytsky

Welcome to Under the Hood. Here we dive into the new Android tools to find how do they work to get prepared for the possible pitfalls and to keep our knowledge in a good shape.

By Süleyman Fatih Giriş

Lately, I have been searching for the best practices of Kotlin Flow in MVVM architecture. After I have answered this question about LiveData and Flow, I’ve decided to write this post. In this post, I will be explaining how to use Flow with LiveData in the MVVM pattern. Then we will see how to change the app theme by using Flow.

By Vasya Drobushkov

Dark theme on Android is on a hype at the moment. More and more apps add support for Dark theme over time allowing users to customize their phones, save battery and provide better accessibility. Though another trend which grows today is animated theme changes. First app I saw support of this was Telegram:

By Vasya Drobushkov

SQLite is one of the most used database. This is because it is used on almost all mobile devices in the world. As SQLite is very similar to SQL everyone already knows the basic concepts like querying, inserting, updating, deleting data; databases and tables; joining tables etc. But SQLite also has some advanced features and this article is about one of such called Trigger.

By C'Aira Shields

I’m going to guess that since you’ve clicked on this article, you have an interest in learning about one of the key Android Architecture Components: LiveData. I won’t, however, assume that you’re a dummy. That was just clickbait. Let’s jump right in and learn about how we can make our Android apps better!

By Javier Arroyo

During the KotlinConf 2019 there were several talks about Kotlin Multiplatform, in one of them Alexander talked about different libraries developed by IceRock to achieve MVVM pattern, share resources or widgets using the same code on different platforms (Android, iOS, JS or web).

By Kurt Renzo Acosta

This article aims to discuss code sharing between Android and iOS using Kotlin Multiplatform. You may or may not have the knowledge of Android and iOS development but having them would help you grasp the topic.

By Nikit Bhandari

In this blog post we will learn how to make a Toolbar and a Bottom Navigation Bar in Jetpack Compose. If you are interested in exploring other components in Jetpack Compose you can check out the series of articles that I have written.

By Vladislav Ermolin (Uladzislau Yarmolin)

This article is targeting those developers who uses dagger-android to do DI in their projects and want to switch to the constructor injection into Fragments. Thus to read it smoothly you might first need to get some insights on that tech. The article also heavily uses Dagger multibinding feature, so if have not encountered it before you might want to check it out too.

By Rick Busarow

If you use Kotlin coroutines, you’re probably familiar with the Dispatchersobject. And you’re probably aware that you can define a default dispatcher when you’re implementing or creating a CoroutineScope:

By Volodymyr Buberenko

ViewPager is a well-known citizen in lots of Android apps since its first appearance. We use it for setup wizards, introduction screens, books and tons of other scenarios with customizations of all kinds. Yet, it wasn’t ideal and developers saw some room for improvement. So after some back and forth Google released a reworked version and named it ViewPager2.

By Fred Porciúncula

That might've been the worst title I've ever come up with. But it also might be the shortest blogpost I've ever written, so maybe that makes up for it. 

By Nikit Bhandari

Creating views in Jetpack Compose is really easy but not all components have onClick listeners, this is where we can use either Clickable or Toggleable. We can use it to wrap our components and provide an onClick listener to them.

By Alexander Berezhnoi

FFmpeg is a great tool with many features available right out-of-the-box. On top of that it supports integration of many external libraries that provide even more features. And they are available through the single FFmpeg API. In this part, I’d like to show the concept of integration of an external library as well as several specific examples.

By Fábio Carballo

Lint is a static analyser, which has the goal of finding bugs on our source code without the need of compiling or running it. And even if you are not totally sure what I am talking about, you have definitely seen it in action during your Android development work. Are this type of messages familiar to you?

By Kishan Maurya

Sometimes while developing an application, we have encountered a situation like based on some logic, we have to render some new view in the layout that is rarely used. A general approach for this is to make View visibility GONE/VISIBLE. So always inflating this rarely used view in a layout, is not a good idea and also it impacts the rendering of the layout. So what to do in this case?

By Tomáš Mlynarič

Android Developers team finally @Provides opinion about dependency injection and the winner is  Dagger. From my perspective, Dagger is “not great, not terrible”, but it scales well and when properly set up, you don't need to “touch” it later. In this article, I'll try to explain how to setup Dagger to work with ViewModel and SavedState module in the most universal way — set it once, use for ever.

By Igor Escodro

Learning new released libraries is great, but applying it right away in your professional project can be very dangerous: the libraries are released on alpha, with some bugs and lacking stability. One way of keeping updated with the latest technologies without compromising the production code is having a personal application to be used as playground.

By Adam Hurwitz

When I started building the Unidirectional Data Flow (UDF) with LiveData pattern, I did not have testing experience. Working on a small/fast moving startup team, Close5, owned by eBay, and building Coinverse from scratch, I had not been required, nor did I allocate the time to develop tests. One of the touted advantages of UDF is optimizing the architecture for testing. This made for a great opportunity to develop testing fundamentals explored in the Coinverse code below.

By StefMa

In my last post "Our use case of using Kotlin Mutliplatform" I described how my team and I use Kotlin Multiplatform. This time — as promised in the last post — I’ll share some code with you so that you can directly jump into it and start by yourself. Additionally I have a nice GitHub template for you as well.

By Oliver Spryn

You can find a Gradle plugin to do just about anything with Java. If you have ever worked on any modern Java application with this build tool, then you are no doubt accustomed to importing and applying plugins to the top of your .gradle files before you can build. However, in some cases, you’ll encounter a missing link that cannot be adequately addressed by anything on the web. I have encountered this situation several times and was surprised how easy it was to mend this discrepancy.

By Piotr Ślesarew

My life has many journeys and the most inspiring are those that bring me personal joy and satisfaction. Programming is one of them, and the more I am into it the more exciting it is. I used to be pretty shy in terms of publishing my knowledge and sharing my thoughts with a broader audience. Every single public speech that I made was a disaster and a huge drama.

By Adam Hurwitz

Based on amazing feedback from the Android community and taking advantage of Kotlin’s natural language features, the Android Unidirectional Data Flow (UDF) with LiveData 2.0 improves and simplifies upon the original pattern. Version 1.0 improved the efficiency of Coinverse's newsfeed, removed adjacent native ads, and made audiocast loading faster.

By Dmitry Si

RxJava in the unit-tests can swallow the exception which would crash the real Android app. Here is how to fix the tests. Suppose we’re using RxJava in our Android app, and we cover it with unit-tests. Does it mean the same code that passes the test won’t crash the app in production on the same input data? No! But why?

By Zohaib A.

Since the release of Retrofit2 version 2.6.0, there has been added native support for coroutines, this helps to achieve better performance and reduces boilerplate significantly. I haven't seen many people adapting to this change, So I hope this article helps you to adapt your app. In this article I will be using the example of an air quality finding app that I made, the application is written in Kotlin and uses MVVM...

How does a non-null property wind up null in Kotlin? Let’s find out!

By Arif Nadeem

I watched the recent Android Dev Summit online and there’s one particular video that got my attention,a talk by Jose Alcerreca and Yigit Boyar on using LiveData with Kotlin Coroutines and Flow where they demonstrated how one could use LiveData builder with coroutines and Flow. This got me thinking and I wanted to see if I could take this further and understand how these three things (Coroutines + Flow + LiveData) fit together.

By Mikhail Kulaha

Welcome to a series of Spy security articles where we’ll learn how to hack an APK and modify it for educational purposes. Today we’ll look at how to eavesdrop and spy on your competitors, enemies, ex-colleagues or anyone else in order to obtain their trade secrets, classified algorithms, funny puns and do a lot of other crazy things. In this article we’ll discuss how we can enable logging on any kind of obfuscated release APK.

By Łukasz Marczak

Assisted Inject is interesting feature of dependency injection, but looks very weird at a first grasp. Let me explain when it could be potentially useful. ‘Hey Dagger! Please provide me following component with Dependency1, Dependency2, … and DependencyX BUT be kind and let me provide DependencyX on my own, don’t look through your graph, I can handle this.’ Like in the following example:

By Gabor Varadi

We’ve reached the one year anniversary of me not writing any articles! Clearly, this is a streak that’s ought to be broken. So, it’s time for me to share a few things I’ve been seeing the past couple of months, that actually disturb me a bit each time I see them. Time to do something about that, after all 😉

By Danny Preussler

While working on my KotlinConf presentation about types I stumbled upon this post by Maximiliano Felice about Phantom types with Scala. The idea: prevent objects from having an illegal state or forbid illegal operation at compile time. The example given was a class Door. A door is either open or closed. In Kotlin this would look like:

By TJ

It’s been a little over a year since the post above, and a lot of things can change in a year. Specifically, I’ve since moved to Kotlin as my primary language for Android development, and I’ve found a cleaner and more aesthetically pleasing way to create an expandable floating action button in Android; let’s talk more about the latter.

By Siva Ganesh Kantamani

CameraX is a Jetpack support library which is in Alpha at present. CameraX library is build to simplify the usage of camera features in app development. CameraX provides an in-depth analysis of what camera is pointed at through Image Analysis and also provides a way to use built-in device camera features like HDR, portrait mode and so on through extensions.

By Alexander Berezhnoi

The compilation of FFmpeg is only a half of a story about using it on Android. The next thing we need to do is to actually integrate those compiled libraries into an Android project and make some use of them.

By Stavro Xhardha

Android’s WorkManager has been around for a while. However my own expectations about it were a little higher. I wished that the WorkManager could fire events at exact timing. But since it was made to respect doze mode, I should respect that too. That means that if the phone is idle, the WorkManager  won’t run.

By Uberto Barbini

It should be apparent, even to the casual reader of this blog, that I really like Kotlin as a language. One of the reasons is its Type Hierarchy, which is both very easy to work with and extremely powerful. It is also quite close to the Java Type System, so the interoperability is excellent.

By TJ

Material Design is an excellent design and visual language on Android, it is also very ambitious, which makes the actual implementation of its guidelines without dropping any of the visual flair a daunting exercise. To this end, the Android community relies on multiple 3rd party libraries and codes samples that provide implementations of these Material patterns...

By Philippe Boisney

When you’re developing an Android application, it’s sometimes necessary to exactly debugging what’s going on behind the scenes, especially for network requests (HTTP & HTTPS). Some powerful tools already exist in order to help you for this purpose and they do amazing work...

By Vladimir Ivanov

Hi, folks! I am kicking off a series of articles about development and not only pipelines that would ensure the proper quality of the mobile apps being developed. The main idea is to cover major mobile technologies used nowadays: native Android and iOS, React Native, Xamarin and Flutter. 

By Eli Fox

Over years Android architecture evolved to support complex, robust, production-quality apps on any scale. It is great to see how Google recommendations are aligned with Android community needs and choices.

By Denis Brandi

Over the years I’ve seen many implementations of the repository pattern, yet I think most of them are wrong and not beneficial. These 5 are the most common mistakes I’ve seen (some of these are also in the official android documentation):

By Uberto Barbini

How to use Extension Functions and Properties to improve the readability of your code - Extension Functions (and properties) are a new thing for Java developers, they are present in C# since long but they landed in the JVM land for the first time by courtesy of Kotlin.

By Chris Cooper

The latest project my team and I are working on involves manipulating a large amount of data. As this has the potential to block the UI thread and give a poor user experience, we took this as an opportunity to get more familiar with Kotlin Coroutines and use them to handle the heap of data in the background.

By Miguel Ángel Ruiz López

Coil is the new boy in town and is becoming increasingly popular. But why is it arousing so much interest? Well, this library is a breath of fresh air in the image loading context which nowadays is dominated by mature libraries. Coil is different because was created with Kotlin in mind.

By Elye

Ever wonder if we could have a component dependent on another component of same scope? It's a no-no in Dagger 2, but checkout... In my example of Setup Android Modules with Dagger 2, due to different module have different component, I can’t have them in the same scope, even though they don’t need to be in different scope.

By Nicola Corti

Chucker, a fork of Chuck, is a simple library to inspect OkHTTP traffic directly on your Android device. Here some story on how we built...

By Joosep Lahe

If you are building an app, there’s a good chance you’ll need to implement login and increasingly popular passwordless is a good way to go — it’s safe and easy for the user. There has been a lot of questions and confusion on how to implement passwordless authentication with Flutter. This article puts forward one approach to passwordless authentication on Flutter.

By Tam Doan

Firebase (and Google Cloud Services) have become very popular with developers. It’s easy if you only develop your app on local machine, until you use some kind of Continuous Integration service (e.g: Travis CI).

By André Ramon

Using the same language throughout your whole project can further streamline and speed up your development process. With the stalbe release announcement of the Kotlin DSL for Gradle, things got even more compelling for modern Android development considering Kotlin is now the preferred language for Android.

By Nikit Bhandari

Recently I was working with in-app updates in Android and I found this API extremely useful but there are certain parts where this API can be a bit confusing.

By Oleg Osipenko

UI-tests are a necessary part of our development routine in AUTO1. Although that wasn’t the case a while ago. One of the issues, which was blocking developers from writing and running UI-tests, was the need to set up UI-tests.

By Shreyas Patil

Hello Developers, You might use Google’s Apps like Gmail, Google Photos, Google Drive, Keep Notes, etc. You have seen their Navigation drawer and it seems much attractive 😍 and best Material Design implementation there. 

By Nikolai Kotchetkov

Keeping your app up-to-date on your users’ devices enables them to try new features, as well as benefit from performance improvements and bug fixes. Although some users enable background updates when their device is connected to an unmetered connection, other users may need to be reminded to update. In-app updates is a Play Core library feature that introduces a new request flow to prompt active users to update your app.

By Alex Zhukovich

Testing is an essential part of the software development process and product release. Often, there is a situation when there are two mobile applications to test: iOS and Android versions. Even here, we have different options:

By Oleg Osipenko

Back in 2015 when I only started trying Kotlin (many thanks to Jake Wharton for his thorough investigation) and then later, when Kotlin 1.0 was released and year after announced by Google as a priority language for development on Android, in the long list of shiny Kotlin features, presented by the articles and blog posts related to the new language, sealed classes were one of the most interesting for me.

By Mayowa Egbewunmi

In this tutorial, I will introduce you to how to implement continuous location update with Android architecture components and Google FusedLocationProviderClient. By the end of this tutorial, we would have achieved 3 objectives:

By Sergii Zhuk

This post will help engineers get the best results out of their work with managers, and achieve career goals in a predictable way. After many years of being an individual contributor and Tech Lead, I decided to transition to the Engineering Manager role.

By Peter-John Welcome

DevOps and pipelines are words that we hear a lot in our development environments and they are always being done by either people doing infrastructure or a DevOps engineer. But what if you wanted to build a DevOps pipeline for your new app?  This series of blog posts will help you with getting from starting a new app, to automatically deploying your app to the Google Play Store/App Store.

By Peter-John Welcome

When thinking about a DevOps pipeline the first thing most people think about is where am I going to host my build server? This infrastructural discussion is important but thinking about your day to day work and how your app will get released is just as important. This is where git strategies come in.

By Martin Devillers

The Kotlin object declaration is a convenient feature, used to create a singleton instance while avoiding boilerplate. However, it’s also a very strict feature, in the sense that an object is necessarily final. This means that it’s impossible to extend from it.

By Marcin Oziemski

In this article, I would like to focus on the topic of how to test code with coroutines. Let’s start with some example of ViewModel. It’s a simple ViewModel that is fetching data from the server.

By Michael Spitsin

I’ve heard so many times: “I wish I could rewrite this project from scratch”, “if I would write all that code from the beginning I would do everything right”, “we should maintain that, but we all know that want to rewrite whole that code”.

This paper is intended for the Android application developer  who wishes to learn about why the Arm 64-bit instruction set architecture  is an important mobile device building-block for the future. Additional information about the advantages, benefits, and considerations for 64-bit Android application development as well as guidance about where to find additional information is also provided.

By Danny Preussler

Data binding is an amazing feature in Android development. We can bind view model properties directly to the XML, the place where they are needed. No ugly ‘handwritten’ glue code in between, which also means less code in the Activities and Fragments.

By Dmitry Si

A lot was written about the TDD approach, in essence, it relies on one assumption — your tests are fast... But what if there is a way to try TDD, even with slow UI tests, and still increase the productivity and the code coverage at the same time?

By Vasya Drobushkov

In RxJava there are the following throttle operators: throttleFirst, throttleLast, throttleLatest, throttleWithTimeout / debounce. Although using debounce to avoid multiple clicks on buttons is commonly suggested, this is bad UX. Let’s finally look at available options in RxJava and find out when it is better to use what.

By Stavro Xhardha

So what the hell is testing?   Testing is just a piece of code where you invoke your written production code and check its’ behavior.  So lets get more specific about Unit testing...

By Dmytro Danylyk

Decided to write about several things which in my opinion you should and shouldn’t do (or at least try to avoid) when using Kotlin coroutines.

By Dmytro Danylyk

One of my colleagues told me that wrapping third-party libraries is a controversial topic, but I will try to convince you that it’s actually something worthy of consideration.

By David Debre

Users like fancy and functional interfaces and experiences. From the user perspective, it doesn’t matter how the business logic or communication with server are implemented — as far as it’s functional. However, it matters how a UI is designed and how much of it is functional and intuitive. The Material Design Components (MDC) as a tool, comes to help to be consistent in the implementation and thus in the app UI.

By Serap Bercin

Earlier this year, Google announced ViewPager2 alpha-04 in Google IO/19. ViewPager2 is the replacement of ViewPager and is much better. The biggest change in the ViewPager2 API is that it now uses the RecyclerView. In this article, I won’t go into AndroidX migration too deeply but just to say/mention I didn’t encounter any big issues during migration even in the big scale project.

By Paolo Rotolo

Libraries are certainly something developers are dealing with every day. They help make big projects modular, giving us lots of advantages likeGradle’s selective module compiling for faster build time and smoother git flows. If some libraries are strongly related to some particular features, they also simplify the creation of different feature modules for dynamic deliverywith Android App Bundles.

By Alex Zhukovich

Analyzing User behaviour we can see that a lot of applications are changing the state of them from foreground to background and in the reverse order. However, as being developers, we would like to know when our application moved to the background. It’s a very popular use case for analytics. Different analytics solutions define sessions in different ways, some solutions allow developers to define “sessions” meaning.

By Domenico Rotolo

In May 2018, at the I/O developer conference, Firebase announced new Machine Learning APIs that are now available for free to developers. They introduced Object Recognition, Face Detection, Barcode Scanning, Language Detection and much more; We might focus on these in future articles, but today we’ll check out Smart Reply.

By Pamela Hill

This article series is for developers and designers interested in learning more about accessibility, particularly related to the Android platform. There are many misconceptions about accessibility, so the first article aims to clarify what accessibility is and which services the Android platform provides to make Android a platform for everyone.

By Diva Vikash

Activities, the building block of any Android app. Something so simple, yet so complex. Here we are going to talk about something similar related to activities which looks very simple from the outset but gets complex pretty soon. We will build a full screen layout with transparent status bar. I'm not going to talk about why would you need a full screen layout and in what situations. That's a topic for another discussion.

By Saurabh Arora

Over the last year or so, we have seen a lot of apps provide support for Dark Theme in their apps. Android Q brought this toggle to the system setting. Eventually, users will expect all apps to have/provide support for Dark theme and apps not doing so will be the exception rather than the norm.

By Altuğ Keçiciler

Android doesn’t provide any easy to use native API for getting touch held down callbacks continuously. So here is my approach to the problem. Since Android lets us handle incoming touch events on a view we can easily adopt OnTouchListener for our use case. Before getting straight into implementation lets list some possible requirements that developers need.

By Ivan Shafran

In the article we take a look at the unit test evolution from beginner to pro-level. “Rate us” dialog is a popular feature, and it will be a good example. Typical “rate us” dialog has requirements like: Should be shown after some condition or user action, Has “rate us” button that leads to Google Play...

By Peter Törnhult

In case you have tried writing Unit tests for your application business logic but gotten stuck at testing your Room logic where some database calls are wrapped in a runInTransaction call, I just figured out how to stub it using MockK and thought I’d share it.

By Idan Atsmon

Many things have changed in the Android ecosystem over the years, but one thing remains constant - the need to display data to our users in the most convenient way. Since 2014, the recommended way of displaying data in our Android application is with RecyclerView.

By Elye

In Android, when we want to have some Text, we would just use TextView. However, in case we want to have a custom view and have better control of the text, we could use the Canvas' drawText api to draw the text.

By Ian Alexander

This series provides an introduction to a variety of techniques used when architecting Android apps and why we use those techniques. We’ll start with a basic MVP app which uses Retrofit and RxJava to display a list of Github repositories, and by the end we’ll have a modern Android app.

By Saurabh Arora

Over the last year or so, we have seen a lot of apps provide support for Dark Theme in their apps. Android Q brought this toggle to the system setting. Eventually, users will expect all apps to have/provide support for Dark theme and apps not doing so will be the exception rather than the norm.

By Thomas Sunderland

For Android developers who are making the transition from Java to Kotlin one of the more interesting features that you will eventually encounter are destructuring declarations.

By Caer Mert CEYHAN

I worked on SMS Retriever API for verification screen of arabam.com application a while ago. After many attempts, I learned that this cannot be done in Turkey. Because the API has difficult requirements.

By Michael Spitsin

In this article we will talk about what is a Service Locator, describe its cons and will make a basic refactoring of this conception. Also, We will slightly touch some problems of dagger, kodein and why we can consider Service Locator as an alternative still nowadays at least in the begging.

By Kirill Rozov

During Google I/O’19 many new and interesting things were presented for Android Developers. I am sure that Jetpack Compose is #1 in the top list of them. Unfortunately, it’s not ready for production and trying it was a difficult quest because you need to build your own version of Android Studio. Everything changed on October 10 when Google released the first dev builds of Jetpack Compose libraries.

By Fred Porciúncula

We're reaching the end of 2019 and we just started our migration from Dagger 1 to Dagger 2. If there's one thing we learned from our experience migrating from Cupboard to Room is that migrating the whole thing at once is painful. So even though finding a step by step strategy might seem tricky at first, it'll most likely be worth it. So how do we migrate step by step from Dagger 1 to Dagger 2?

By Chan Myae Aung

We were recently inspired by a Google Material Design case study Rally, therefore we have implemented this project for fun, as well to learn new things. While working on this project, I came across a situation where I needed to draw some shapes, such as the picture above, using Canvas API. In this article, I am focusing on drawing a Bezier curve, rather than the whole graph.

By Kirill Rozov

Kotlin removes much boilerplate code that we need to write by hands or generate with an IDE or third party libraries like Dagger 2. What's is price of Kotlin null safety and how to remove additional bytecode. Let’s check decompiled Java code produced by the Kotlin compiler and find out how to bring down the price.

By Lin Min Phyo

Constraint Layout Flow – Even though Constraint Layout is powerful, Linear Layout is enough to show 2 views horizontally, like the following.

By Suchi Bansal

Android 10 gives users more control over when apps can get access to device location. When an app running on Android 10 requests location access, users see the dialog shown in Figure.This dialog allows users to grant location access to two different extents:

By Uberto Barbini

Understanding how tailrec keyword works and how to take advantage of recursion in Kotlin – It is already passed a year since I wrote the first Kotlin Pearl blog post. Thanks to everybody (and you are really a lot) who supported me and clapped or liked my posts. This post will cover:

By Tam H. Doan

Wandering search online, I find out that many people have the same problem as me. So I decide to write an article to share some tips for better manage res/layout folder in Android Studio.

By Filipe Batista

It is often said that developers are lazy and that is (usually) a good thing. It just means that instead of repeating the same task or code over and over they tend to find ways to prevent that repetition and optimising their time.
Android developers for several years have tried to avoid the boiler plate code regarding findViewById . Let’s imagine you have the following layout:

By Nikit Bhandari

With AutoML Vision Edge, you can create custom image classification models for your mobile app by uploading your own training data. Firebase ML Kit has a lot of features that allows you to perform machine learning on the user’s phone. In this blog post we will build an app called SeeFood, the app sees food and tells you what food item it is.

By Matt Dupree

Remember those gimmicky fitness products that made you think you could “get fit” without actually going to the gym/dieting/etc? Because I live in Orlando and have seen the Carousel of Progress at the Magic Kingdom a bunch of times, the first example of this kind of gimmicky product that comes to mind is a thing called an “exercise belt.” 

By Abhilash Das

To make the fragments reusable and make them part of a modular architecture, Fragments should be self-reliant and should define its implementation independent of any activity or fragment so that a developer can connect the fragment to any activity or fragment and it should fit in perfectly as any jigsaw puzzle.

What are some strategies for dealing with Kotlin and Android Lifecycles? In this screencast, cast you'll learn how Android Lifecycles appear to inhibit some core behaviors of Kotlin.

In this post, I’ll show how to add a range action. Ranges allow users to control any field that accepts a discrete range of options, such as volume or brightness.

Today, over 90 percent of enterprise data is sent to the cloud. In the next years, this number will drop to just 25 percent according to Gartner. Where is the rest of the data going? It’s not going anywhere. It is being stored and used locally, on the device it was created on. This is edge computing. Our pragmatic definition.

Class extensions are a powerful feature of Kotlin that allow you to add behavior to classes without extending them. In this video we will take a look at how to work with class extensions, some of the subtleties of how class extensions work with custom objects, and how to define your own class extensions to simplify your code.

How do I set up user authentication using Firebase with Android? User authentication is very useful for mobile apps but can be tricky to get right. Firebase allows your users to authenticate with a wide variety of options and is very easy to set up.

In this video you will learn about ConstraintLayout. It will cover how to use the graphical editor, how to add constraints to your views and tweak their attributes to position them on screen, and it has an example of converting an existing layout to use ConstraintLayout.

App shortcuts give you the ability to provide convenient shortcuts to specific actions in your application. In this video learn how to implement app shortcuts and give your users quick access to the functionality they want.

How do you create adaptive icons for Android? Android Oreo introduces Adaptive Icons which allow device manufacturers to choose the outline, or mask, of all app icons on the device We'll show you how to implement these icons in Android Studio.

How do you convert a Java Android Project to Kotlin? In the process, we will also learn Kotlin language fundamentals, including the null safety features of the language, safe call operator, and how statics are represented in Kotlin.

Dagger is a dependency injection framework. In this screencast you will learn how to set up Dagger in a Kotlin Android app and some best practices. Check out this Screencast video from Big Nerd Ranch on how to set up Dagger

Dependency injection is a great tool to break up your dependency creation into reusable pieces. This helps separate your code into logical chunks where some create the dependencies and others consume them...

Learn these useful navigation and editing keyboard shortcuts in Android Studio.

By Martin Bonnin

Android Lint is a great tool to catch structural errors and improve your Android codebase. Unfortunately, the documentation can be a bit sparse and does not go in the details of precedence and XML options. We’ll try to do that here.

By Joshua Schriever

UI testing on Android can be very frustrating. If you have a significant number of UI tests, they probably take a long time to run and are prone to flakiness. Gordon is an instrumentation test runner designed for speed, simplicity, and reliability, so you can plug it in and never worry about flaky UI tests again.

By Husayn Hakeem

Since its announcement and Alpha launch during this year’s Google I/O, there’s been a lot of excitement around CameraX, which is part of the Jetpack suite of libraries that aim to help developers build high quality apps easier. With its next alpha release and its upcoming beta release next month, let’s take a look at some of the new APIs and features that have been added.

By Prasad Pulikal

Github has recently introduced the GitHub Packages, a package management service where developers and organisations can publish packages either publicly for the open source community or privately for use within an organisation.

By Carlos Palacin Rubio

Have you ever modify a dimensions file and realized too late, that this change has affected unexpected parts of your app? This is a common problem, especially in large teams where is hard to know who is using (or planning to use) shared resources like dimensions, colors, strings and styles.

By Vasya Drobushkov

RxJava is a very powerful library, though it has some issues as well. Specifically performance and memory issues, which come from problems library tries to solve and how the solution is designed from technical perspective. In order to minimize overhead in RxJava there are a number of optimizations, which are called “operator fusion”. And we’ll talk about them in this article.

By TJ

Fragments in Android are many things to different people. View controllers, state containers, callback hooks to system events like permissions, life cycle aware components and so on, so it comes as no surprise that a sizable amount of Android Developers find them rather polarizing. It’s 2019 however, do fragments still deserve this reputation?

By Patrick Cousins

Kotlin’s extension functions have been around for awhile, but sometimes it’s helpful to take a step back and look more deeply at core features of our favorite languages. Extension functions are often described as being similar to static “Utils” classes — a common staple of many Java codebases. Under the hood this is exactly how they work.

By Josias Sena

Recently my team and I worked on implementing WebSockets (known as subscriptions in GraphQL), to allow users to talk to each other in real-time. During this time, we saw that the documentation to this using the Apollo client for Android was pretty bad! So in this post, I will be talking about our findings and how this can be done, with the hopes that it might be helpful for others as well who might be having the same problem.

By Kirill Rozov

How to inject dependencies into Android Components constructors with Dagger 2. 
Kotlin is a beautiful language but I don’t like one thing from it — lateinit. Why?

By Dmitry Akishin

Kotlin truly is a beautiful language with some great features that make application development a fun and exciting experience. One of such features is Delegated Properties. In this post we will see how delegates can make our life easier in Android development.

By Fernando García Álvarez

On September 3rd, Android 10 was officially released and available for Pixel devices, and with it comes a controversial change: Scoped Storage. In a nutshell, Scoped Storage prevents apps from having unrestricted access to the filesystem on the device. Previously, an app could access any file on the device using the standard File APIs, and it only needed the user to grant the storage permission.

By Mikhail Kulaha

If you have had any experience with Android testing you probably know how hard and challenging it is to test some parts of the Android app, especially those which are connected to the Android classes. In this article I will tell you how to test classes which depend on or use Content Resolver.

By Nikit Bhandari

TL;DR VerticalScroller and HorizontalScroller is the answer. You would be surprised how easy it is to create a list in Jetpack Compose! If you are new to Jetpack Compose I would recommend going through the official documentation first. Beginning with Android Studio 4.0 Canary 1, you can preview your composable functions within the IDE.

By Kishan Maurya

Recently I was working on Google Maps with custom marker layout and I was inflating custom marker layout and creating bitmap from that layout as MarkerOptions accepts bitmap. So layout inflation + bitmap generation was happening in main-thread (fragment). This could create unresponsiveness and jank.

By Vasya Drobushkov

Handler and Looper are one of the main low-level Android OS things, which almost nobody uses directly (at least nowadays). But they are at the core, so many other high-level solutions are based on them. Therefore one should know what Handler and Looper are, what and how they are doing. In this article we’ll try to understand Handler and Looper in Android. What, how and why we might need them.

By Zsolt Kocsi

Screen history with back stacks based on declarative routing. Pressing the back button in your Compose app at the time of writing this article will result in your app closing. Compose is currently at 0.1.0-dev03, and my understanding is that back press handling is further down the roadmap...

By Abhilash Das

If you are coding for Android then, you must have faced such scenarios where you have to inflate multiple view types in situations where your list might be heterogeneous. This is how you might have approached it:

By Gabor Varadi

In this article, I intend to show you a few commonly recurring mistakes that some developers make by accident, that can potentially break your app. Generally, there are particular patterns that you see in code, and you know that in certain scenarios — generally after triggering process death / low memory condition — that app will crash or fail to work in horrible ways.

By Rick Busarow

Since its initial release more than two years ago, Android’s LiveData has been an incredibly popular, simple approach to safe-ish reactive programming. However, even though it was announced on the same day as Kotlin support, it is a Java library and doesn’t have perfect Kotlin interop.

By Prasad Pulikal

GitHub has recently introduced the GitHub Packages, a package management service where developers and organizations can publish packages either publicly for the open-source community or privately for use within an organization. GitHub Packages allows you to host libraries or packages, which can be reused by different projects.

By Suchi Bansal

Nearby connections is a peer-to-peer networking API that allows apps to easily discover, connect to, and exchange data with nearby devices in real-time, regardless of network connectivity. This new API uses a combination of WiFi hotspots, Bluetooth Low Energy & Classic Bluetooth to discover and advertise to nearby devices. Connections between devices are high-bandwidth, low-latency, and fully encrypted to enable fast secure data transfers.