By Carlos Mota

It’s Monday, no releases this week, and… there’s a new version of Jetpack Compose — beta 03—available. What a perfect time to just increment 02 to 03 and see what’s new. The API is (almost) final so after updating from alpha to beta there weren’t any big changes to do. However, and remember that’s still in development, there’s always something that I need to update. 

By Chetan Gupta

Scopes make your code more readable? think again... You are going to encounter these scope functions namely let, run, apply, also, within every Kotlin codebase, along with all the mischievous ways developers exploit their usage from the way they were intended for. Let see how popular opinion on those ends up just as a code noise.

By Jaewoong Eum

DataBinding is one of the most important factors for MVVM architecture. The basic concept of DataBinding is to link the view and view model via observer patterns, properties, event callbacks, etc. Linking and automating communication between the view via the bound properties or something in the view model has a lot of benefits in the MVVM architecture concept.

By Mayank Kharbanda

Kotlin Multiplatform (KMP) is a code-sharing technology that allows us to use the same code for different platforms whether it’s JVM, Android, iOS, watchOS, tvOS, Web, Desktop, or WebAssembly. In this article, we will use Kotlin Multiplatform Mobile (KMM) which is a subset of KMP with the focus on providing better tooling and support for sharing code on mobile platforms i.e. Android and iOS.

By Dinorah Tovar

This is the final part of this series “Practical Network for Android Developers” today we are gonna discuss testing and the way we can handle specific integrations of details with an HttpClient and other things to address like mocking and testing

By Dinorah Tovar

This is the fourth part of this series “Practical Network for Android Developers” today we are gonna discuss what is redundancy, concurrency pools, some parts of Coroutines, and the performance in OkHttp. This part is incredibly big and I will create a second part outside this serial just to address any problem of Performance from coroutines to a network request, whatsoever, feel free to ask any question below.

By Dinorah Tovar

This is the third part of this series “Practical Network for Android Developers” today we are gonna discuss Authenticators and Interceptors in OkHttp and why they are important for coding APIs.

By Dinorah Tovar

This is the second part of this serial “Practical Network for Android Developers” today we are gonna discuss TSL, Certificates, and Pinning logic! Transport Layer Security (TLS) is the successor protocol to SSL. TLS is an improved version of SSL. It works in much the same way as the SSL, using encryption to protect the transfer of data and information. 

By Dinorah Tovar

This is the first part of this serial “Practical Network for Android Developers” when we are gonna be talking about the Network data layer with a different vision that usually is addressed, cause networking on Android is difficult to work it, with multiples carriers, different and rich contents, streaming and all of this should arrive at our users without missing a single detail

By Suleyman Fatih Giris

Since Jetpack Compose has joined our lives, it has been changing the way of our thinking and coding day by day. But more importantly, creating UI’s is becoming much easier compared to the old Android view system. This empowers developers to learn and adapt to the Compose environment in a much faster way (especially for animations 🥳).

By Igor Escodro

When developing an app, we need to carefully focus on the user experience, specially in the actions that may require a confirmation or possibility to revert the user decision. If we use Alertdialog in every single interaction we need this behavior, it will easily annoy the user.

By Gaurav Bhola

To understand how we arrived at the current state of the mobile app development. To also understand what the modern mobile app development is headed towards?`Web` in this article refers to single page web apps made for mobile. They may or may not be progressive (PWA).

By Krzysztof Marczewski

Recently I was configuring detekt in a multi-module project. To make it easier to pass knowledge about using it I wrote this article. Feel free to use it as documentation inside your project, to speed up using linter by new developers.

By Igor Escodro

Handling screen navigation is a complex task in any framework. Luckily we already have a great tool for helping in this flow, but some different scenarios may need more attention. One of these scenarios is opening the application on a specific Composable in Jetpack Compose.

By Asidahan

I assume that most of you (I’m talking about you, mobile developers) had to deal with production issues like crashes, bugs, and unexpected app behavior at some point in your career. Ok… now you have a production issue that happens to many users (possibly millions) with different devices, different OS versions, different countries, and the list goes on and on.

By Johann Blake

A sample application that uses a custom navigation library allowing you to navigate screens with animated transitions and pass any data type. The app is about showing a list of cats in a grid, displaying details about each cat and navigating to a fake “adoption” screen. It also features a fancy navigation drawer as well as collapsible/fixed toolbars.

By Tomislav Smrečki

Even though still in the Alpha version, many developers welcomed the new Paging 3 library from Android Jetpack considering the previous attempt was poorly designed and required a lot of coding.

By Arildo Borges Jr

First, what is Cyclomatic Complexity? Cyclomatic complexity is a software metric used to indicate the complexity of a program. It is a quantitative measure of the number of linearly independent paths through a program’s source code. Its formula is: M = E - N + P, where E = number of edges, N = number of nodes and P = number of connected components

By Begüm Yazıcı 

Hi all, I decided to write this article because I’d like to share my #AndroidDevChallange week 2 experience. Let’s rock and roll! 🥳 Android Jetpack Compose has been published by Google and now it is currently in beta 🐣. Jetpack Compose is Android’s modern toolkit for building native UI. It simplifies and accelerates UI development on Android.

By Denis Crăciunescu

The first requirement of an application is to solve your problem. 
If it can’t do that, it is not complete. But is solving the task all that matters? The experience should be equally important. The design team might spend days choosing the shiniest colour palette and picking the right fonts.

By Yasin Kaçmaz

Imagine having a modular Android app. Different teams working on different modules without even touching another module. We will make the CI pipeline faster for those team members. In the below images, you are seeing a modular app structure and relations between modules.

By Abdul Hakeem Mahmood

Data Binding and Dependency Injection are very hot topics for Android developers in the software industry nowadays. They once were a plus point in job descriptions but are now a mandatory skill requirement (rightly so). 

By Eric SilverbergHow do you initialize a repository? More precisely, how do you initialize application-scoped classes with database dependencies? If you’re an iOS developer, the answer to the question about is probably “synchronously on the main thread, in my Application delegate during didFinishLaunchingWithOptions, what’s the big deal?”  

By Alexey Glukharev

It’s not enough to use only Canvas to work with dynamic UI elements that use shadows, real-time filters for photo or video, or responsive UI or lighting. It would be best if you had something more powerful. In the past, we were able to use RenderScript for this, but is it supported anymore?

By Robert Levonyan

Caching in Android is an interesting task, because nowadays we have quite a few available options for that purpose, but here’s the question. Which is the best for me? With this article I want to try to answer that question, and help you to understand, which one of the mentioned libraries or frameworks fits best for your next project.

By Ziv Kesten

The introduction of Kotlin as a first class language for Android development around 2018 had kicked off a new era of MAD — Modern Android Development, and with it, we received a new type that can emit multiple values sequentially.

By Rasul Aghakishiyev

As we can see Jetpack Compose grows like crazy. Last week they announced that Jetpack Compose went to Beta! Today we will talk about how to create bottom sheets in Jetpack Compose. To implement the bottom sheet, we need to use BottomSheetScaffold.

By Jordi Saumell

In the previous articles I have proposed several significant changes to traditional Android development, and there was one last subject left to be explained: how do we avoid using the Android ViewModel. So in Part III we will focus on this, and then I will present an open source sample app that I built to showcase what we have seen in this series, and a bit more.

By Raul Hernandez Lopez

The most important part of an iceberg is not what you can observe from the surface. What really matters is what is under it. That is what will make it float above the surface. Comparing an iceberg with Declarative UIs, we can tell that essentially our iceberg would be powered by a Reactive approach to producing successful updates. 

By Ian Alexander

Written as of beta01. Compose is evolving rapidly so some syntax may have changed. App architecture has come a long way in Android world over the last decade. From god activities to MVP to MVVM to MVI with a sprinkling of event buses, clean architecture, and a variety of other patterns along for the ride.

By Michael Spitsin

When working on Android applications, from time to time you face surprise situations. SDK behavior ambiguity, lack of important and easy functionality, false hopes on optimizations, which you encountered in other places. And that’s fine. 

By Tarek Ben Driss

Since the launch of iPhone 6s and iPhone 6s Plus, Apple have introduced the 3D touch in its products.Replaced now by the Haptic touch, this feature allows you to carry out certain tasks instantly through quick actions.
 

By Vladimir Petrovski

Can we upload our APKs to AWS S3? Sometimes some files need to be uploaded to S3 rather than Bitrise, which has a default step for public download and access. For those who don’t know what the AWS S3 is, check it out here first, then go back and complete this post.

By Nishan Wijesinghe

With Android Jetpack components a lot of things are happening here and there. Nowadays most of the developers tend to use Single Activity architecture, with that communicating between fragments become more crucial.

By Gabor Varadi

I’ve been meaning to write this article in a while. Hopefully, the following tips and style recommendations (in no particular order) will help you write better Kotlin! Let’s get on with it, shall we?

By Torkel Velure

I’ve been working on this app recently: Fjelltoppjakten. In Fjelltoppjakten we use Firebase/Firestore for everything! The app is simple; you can view all the mountains in Bergen(Norway), and if you reach the summit, you can check in and gain points!

By Arnaud Giuliani

Components Lifecycle in Android is one of the biggest pinpoints for Android developers. Let’s add dependency injection complexity with scope management over that … and you can go into a very complex and frustrating situation😭

By Mark Ng

We just completed our engineering road map for our Android apps at Australia Post. Each year we get together and try to decide on what we are going to do from an engineering perspective for the next 12 months. Each team gets to decide on what should be done now, what they want to complete by the end of the year and whats on the horizon for next year.

By Eric Silverberg

The Android activity lifecycle is one of the first architectural concepts learned by a new Android developer. Ask any Android dev and they’ll likely all have seen this handy diagram from Google: 

By Jobin Lawrance

Let’s say we have a third-party class that we are using as a type in one of our data class that we want to be serialized, then we have to write a custom serializable for @Serializable to work.

By Robert Levonyan

The TextView is one of the most common Views used across all the Android apps. It has very simple API to show the text on the screen. Not only a simple text, but also styled text with clickable parts. So if everything is that simple, why we need new API for text?

By Rasul Aghakishiyev

Declarative way programming becomes so popular nowadays. There are a lot of frameworks such as Flutter, SwiftUI, JetPack Compose which use this way of programming. Until recently Flutter and SwiftUI were the only frameworks that allow you to develop cross-platform applications using the same codebase. But today, meet new framework Compose for Desktop.

By Robert Levonyan

Have you ever been in a situation where you needed to create an Android app with drag and drop feature? I was. And if you were too, I know what you might feel right now, believe me.

By Perihan Mirkelam

In the previous articles, we talked about the definition of IPC, AIDL, and Messenger. Then we created client-server applications using the AIDL and Messenger techniques. All parts of the series linked at the end of the article. Now we will improve these two applications to support the Broadcast technique.

By Perihan Mirkelam

In the previous articles, we talked about the definition of IPC and the AIDL method, and we created client-server applications using the AIDL method. You can find all parts of the series at the end of the article. Now we will improve these two applications to support the Messenger method.

By Perihan Mirkelam

You should use this method if you need a multithreaded IPC structure. If you are not going to perform concurrent operations, you can choose Messenger instead of AIDL. In this method, an application calls the method in another application on the same device, namely RPC (Remote Procedure Call).

By Perihan Mirkelam

IPC is a general concept that means inter-process communication. Let’s talk about IPC for Android. When it comes to Android, IPC means one of the following two situations: 

By Raul Hernandez Lopez

(This article was featured at Compose #3 Digest, Android #452 & Kotlin #236Weekly) Most of us Android engineers probably remember that Google IO on 2019 where Romain & Chet presented Jetpack Compose, a modern Android toolkit to build native UI. They mentioned some awesome core features of it, among them that it is Reactive & Kotlin.

By Pavel Sidyakin

Continue the series of the articles about modularization of Android Applications. In the current article, we consider another approach to gluing modules, with lazy initialization and automatic reset.

By Andrey Beryukhov

This article is a continuation of the previous one with common thoughts about our approach to splitting a monolithic Android-application code base into modules. It is strongly recommended to see through it before reading this one.

By Andrey Beryukhov

Splitting a monolithic Android-application code base into modules is not a new theme, and this way of code organizing is becoming more common. Even our colleague had already published a couple of articles about best practices for working with modules when we first started the division.

By Abhishek Bansal

Android Kotlin Extension Gradle plugin is deprecated in favor of ViewBinding. That marks the end of too good to be true kotlinx.android.synthetic bindings for XML files. While synthetics were very convenient they had the following shortcomings

By Daniel Horowitz

For some time now and for different projects i’ve been using this combination of Unit tests + MockWebserver in order to fully test my Retrofit network integrations and let me tell, it saved me a lot of time bug fixing or trying to figure out what’s wrong with my JSON parser.

By Dennis Anderson

What to do during the COVID-19 pandemic… well I cleaned up my house and found some old phones that I wasn’t using anymore. I thought… what a waste! This machine power could be useful in some way. So hereby I introduce to you my device lab.

By Stojan Anastasov

The recommended approach from Google for Android development is holding the UI state in a ViewModel and having the View observe it. To achieve that one can use LiveData, StateFlow, RxJava or a similar tool. But how to model the UI state?

By Dmitrii Kachan

My fella Android devs know that It’s a little bit of a pain to implement zoom-in — zoom-out for your ImageView. It becomes more complicated when you want to be able to drag image on a screen at the same time. With traditional XML layout approach there are several ways of doing that.

By Björn Kopiske

Last time, we’ve seen the most basic things one should know about Data Binding: what Data Binding actually means and how to solve common tasks the Data Binding way. In this second part, I’ll show you some — still common — examples on what more you can get out of Data Binding.

By Karan Dhillon

A complete guide on how to setup the bottom navigation bar. The last article was about how to set up navigation in a project built purely in jetpack compose. To give an overview briefly:

By William Gouvea

Be able to track crashes on Android and gather the below metrics from mobile clients Affected sessions: is the percentage of separation in which there was at least one failure. A daily session adjusts to a day when the app was used. For example, if both users use the application for two days, four will be eliminated.

By Michael Ferguson

Several years have passed since Jose Alcérreca published his article on “The SingleLiveEvent Case”. This article was a great launching point for many developers as it got them thinking about different communication patterns between ViewModels and the associated View, be it a fragment or an activity.

By Karan Dhillon

Jetpack compose is the new kid on the block. Though its relatively new, compared to the traditional android UI toolkit, soon will come those days when projects will start migrating to jetpack compose, and more & more companies will put it as a requirement for their potential android developer. 

By Denis Crăciunescu

Imagine a populated parking lot. Cars are coming in, cars are going out. 
Some cars might occupy one parking spot. Whereas the bigger ones might occupy the whole parking lot. People are generally mad here.

By Ashish Yadav

The idea of library internals has always been intimidating to me. Most people being an app developer prefer to assume the library as a black box. How do people code it, test it or release it? You are in for a treat as in my series of articles I will take you on a journey of creating, running and publishing an actual working library.

By Metin Özcura

In the previous post, a simple implementation of Paging 3 was described. If you do not have sufficient information about Paging 3, please see the post about the usage of Paging 3 first. In this article: I will cover refresh and retry functions, load state adapters, loading state listener, and list separators.

By Metin Özcura

Most apps display a large list of data, however, users generally see only a small part of it, so fetching all of the list data from the network is not an optimum solution. The Paging library is a much easier way to implement this approach. 

By Jordi Saumell

In part I we saw how, with Compose UI, we can (should?) get rid of Fragments, Android-ViewModels, and configuration changes to make Android development easier. Here we will see how to apply those changes, so make sure you read part I beforehand, to understand why.

By Jaewoong Eum

In modern Android development, constructing network structure is an important factor and we can implement network communication structure using HTTP client tools like OkHttp, Retrofit, or Volley. Also, it is an important factor to design how to handle callback responses from the network.

By Max Kahinkin

When we start learning coroutines we always try something quick by using the runBlocking builder. Let’s take a look at one slightly weird thing regarding runBlocking in which, if you write this code on the UI thread, you will deadlock your Android app forever.

By Seanghay

Epoxy is an Android library for building complex screens in a RecyclerView. Working directly with RecyclerView.Adaptercan be challenging when we have multiple view types. However, Epoxy solved that by using Code Generation (Annotation Processor) to generate builder classes & Kotlin extension functions. It uses RecyclerView.Adapter & ViewHolder under the hood!

By Paulina Sadowska

This time instead of only writing a post I also created for you a video on the same topic 🎥. So if you prefer to listen to me talking about measurement inaccuracies in Profiler instead of reading, I’ll be thrilled if you check it out! I’m planning to add more videos for experienced Android Developers in the future on this channel.

By Yusuf Ceylan

MVVM is the recommended architecture and many developers use it. But just like other things, architecture patterns are also evolving. MVI is the last member of MVx family. It has a lot in common with MVVM but has more structured way of state management.

By Jaewoong Eum

Hilt is a dependency injection tool that has been introduced by Google in the last year. Hilt makes our projects cleaner and reduces setup time for constructing our DI environment than Dagger-Android. It has been steadily getting feedback and developing for several months. Now Hilt is more stable than the earliest was.

By Jordi Saumell

Jetpack Compose is the new Android toolkit that will change how we build the UI of our mobile applications. Since it was built as a UI framework, there are a lot of posts and talks that focus on how it works internally, and on how to use it to build UIs. 

By William Gouvea

Increasingly, organizations have stringent requirements from the time data is generated, to the time actionable insights are delivered to the users. Therefore, data needs to be collected, stored, processed, and analyzed within relatively short windows — ranging from daily to real-time.

By Ivan Kuten

So, how can you update Android on mobile devices? While developing software for Smart TVs and Android-based set-top boxes, we’ve narrowed it down to four ways, discarding some very exotic options:

By Hadi Lashkari Ghouchani

This post is on the tail of Railway Oriented Programming in Kotlin by Antony Harfield. So you need to read it first and continue here. As it’s obvious I really liked it and tried it out. It needs every process have a result like

By Stojan Anastasov

Once Retrofit added RxJava support, RxJava became my go-to concurrency framework for writing Android apps. One of the great things about RxJava is the excellent testing support. It includes TestObserver, TestScheduler, RxJavaPlugins so you can switch your schedulers in tests.

By Danny Preussler

And why you should avoid using the “NewApi” suppression! The idea of “Compat” libraries was probably one of the key aspects of Android dominating the mobile space. Other than with iOS, Android users often could not update their operating system after a new version launch, simply as their phones won’t allow them to, the Android problem of fragmentation.

By Alexander Shafir

Per AndroidX Lifecycle docs: Lifecycle-aware components perform actions in response to a change in the lifecycle status of another component, such as activities and fragments. These components help you produce better-organized, and often lighter-weight code, that is easier to maintain.

By Eric Ampire

The RecylerView is one of the most used Android components when it comes to displaying a list of items in an Android application, and since the arrival of Jetpack in the Android ecosystem, some libraries have come to life to simplify its use.

By Gabor Varadi

Merry Christmas to all! The subject of this article is one that has been on my mind for a very long time. After all, “Clean Architecture” is often seen as the end goal, the hallmark of the finest of Android application code structure — it is the best of the very best. 

By Ankur Gupta

State is a crucial part of any frontend application. We do not want the UI to end up in an un-intentional, glitched, or lose state, no matter what the user does. It is where predictable states come into the picture.

By Viktoriia.io

This article will provide you with the base knowledge & usage tips for adding Extended FAB to your project. Today we’re going to have a quick dive into Material ExtendedFloatingActionButton. Good that we have it already done by Android team :).

By Rasul Aghakishiyev

Animation in an application has a significant role because it helps to provide a better user experience and makes your application more attractive. Jetpack Compose provides a nice API for creating animations in our application. We can do any type of animation, for example, alpha or scale animations.

By Eric N

One upon a time, there was a singularity named :app module. Then came the smaller monoliths, namely persistence, networking and models. Why layers monoliths is a mistake?

By Michael Spitsin

Hi. The new year is coming and it is a great time to recap things that we learned and achieved during this year. I thought what could I write this time. And in 2020 we started to work remotely. We started to share our knowledge with colleagues through our internal chats, instead of just verbally showing some fun and tricky things. 

By Oliver Spryn

Sometimes, you have to say it straight: Google does not build Android with unit testing in mind. Even as recently as API 30, the platform continues to evolve in this unfortunate direction, making critical components of your app increasingly challenging to test. Thus, if you want to build an app with 95% or higher code coverage, then the burden lies with the app developer to make this a reality.

By Roman Kamyshnikov

A common scenario in Android applications is the need to repeat a request when something goes wrong, for example when there are problems with the users internet connection. Let’s assume that we have a screen with several HTTP requests and we need to show a dialog that lets the user retry the request that failed.

By Sherry Yuan

I came across Michaela Greiler’s Code Review Checklist earlier this year and it’s now one of my favorite and most frequently-used programming resources. However, it’s a high-level checklist and doesn’t include anything specific to a platform or a language.

By Julius Uy

Just last week, news broke out that Twitter is shutting down Periscope. This left a rather sobering reminder that paranoia in perpetuity is perhaps the only surest way to survive a dog-eat-dog world. Periscope was huge back then.

By TJ

I think Kotlin delegates are underused; they are the best implementation of the “favor composition over inheritance” refrain. In the above, the ListContainer is a List that can be iterated through by delegating to the backing List within itself. Delegates are so much more than that however; fundamentally a Delegate allows for a property to have its read and/or write semantics implemented by an arbitrary bit of code.

By Suraj Sau

Implementing Neomorphic views (hopefully I haven’t slaughtered the terminology here 😅) is explained to a greater clarity in this awesome article by gihub/fornewid. As a TLDR; to the article, the impression of smooth elevation and subtle depression upon ‘pressing’ is achieved by animating two separate blur-edged shapes of two colors, a lighter shade and a darker shade of the general surface color.

By Jobin Lawrance

This is a simple way to mock runtime dependencies in Instrumentation tests when using Koin Library. First, let’s take a look at how an application would mostly be set up when using Koin for DI.

By Shivam Dhuria

You might come across a situation while developing an app where you’d want to retry a certain request when an Exception occurs without user’s intervention. A pragmatic example would be a case of an IO Exception. Consider this use case. You want to fetch a list of dogs from the server, however, you get an IO exception due to a network issue.

By David Ferrand

The implementation turned out to be quite complex, with subtle tweaks needed in order to reach a really smooth UX. In this blog post, we’ll be implementing the carousel step by step and I’ll comment on some of the choices I’ve made, such as: ViewPager, ViewPager2 or RecyclerView?

By Rishit Dagli

This blog demonstrates how you can get started with on-device ML with tools or plugins specifically launched with Android 11. If you have earlier worked with ML in Android, you will explore easier ways to integrate your ML applications with your Android apps.

By TJ

This post is part of a series that shows how Views in android can be represented purely as a function of some state with no side effects helping to build a robust, easy to scale and maintain app with the help of ViewBinding.

By Mustafa Yiğit

Recently, Jetbrains team released a new update for Kotlin. (Kotlin 1.4.20 Released) With this update, synthetic import has been removed from use. And now ViewBinding is recommended as an alternative. Let’s see how we can add ViewBinding to our project.

First of all, we must tell gradle that we will use viewBinding.

By Ian Alexander

Written as of alpha08. Compose is evolving rapidly so some syntax may have changed. If you’ve developed for android you’ve inevitably come acrossRecyclerView, it’s a massive improvement over ListView which came before, but still pretty far from fun. Making a RecyclerView involves a messy pile of boilerplate — often difficult to re-use between screens — and complexity even for basic tasks, like headers, item callbacks, and multiple item types.

By Rishit Dagli

This blog is equally contributed to by preet parekh. This blog has now also been published on Official Google Cloud Tutorials. You have probably seen this image below, it's quite popular by the way. And you too might have faced issues like Android Studio is very slow, build takes a lot of time, AVD starts after a long time if you are on a slow machine like mine.

By Pamela Hill

This article series is for developers and designers interested in learning more about accessibility, particularly related to the Android platform. The first article in the series aimed to clarify what accessibility is and which services the Android platform provides to make Android a platform for everyone. 

By Kanchan Pal

Clean Architecture comprising MVVM + Room DB with Pagination + Other Android JetPack Components. So if you’ve landed on this page, I am sure you are very curious to build a very responsive, fast and reliable Android application from scratch with latest/widely used tools and technologies out there.

By Elena Stepanova

Create a Face Recognition App on Android. In the previous article I’ve given an overview of some promising cloud services that can be used to build a face recognition application on a mobile device. In this chapter we’re going to have a closer look at the design and implementation of a face recognition prototype app.

By Waseef Akhtar

Recently, I got myself engaged in a new world of Android development: publishing an open source Android library. I can say that the struggle of publishing the library was real after realizing that I spent more time publishing the library than writing the entire library itself! 🤦‍♂️

By Vivek Singh

Previously there was no official support for paging in Jetpack Compose, but with the release of compose version 1.0.0-alpha06, jetpack officially released the paging-compose library which provides integration between compose and Paging 3 library.

By Ievgenii Tkachenko

More than two years ago, I faced the issue that to debug requests from the Android device or emulator, you should use some third-party tools, and none of them was built inside the Android Studio. 

By Patrick Steiger

Kotlin Coroutines recently introduced two Flow types, SharedFlow and StateFlow, and Android’s community started wondering about substituting LiveData with one of those new types, or both. The main reasons for that are:

By Arkadii Ivanov

In my last article “Decompose — experiments with Kotlin Multiplatform lifecycle-aware components and navigation”, I mentioned two cases when we can’t share code using Kotlin Multiplatform. The first one was navigation and the second one was UI. In that article we managed to share the navigation logic using the Decompose library. But UI was still platform specific.

By Shalu T D

This article discusses the Kotlin annotations used while developing the Android app. Here we will explore the annotations @JvmStatic, @JvmOverloads, and @JvmField. As Google suggests Kotlin as the official language for Android development, most of the people are in the process of migrating existing Java code to Kotlin code. But we can’t convert all source code from Java to Kotlin in a single sprint itself.

By Sergio Belda

The navigation component in Jetpack Compose helps you navigate between composables and take advantage of the features it provides. The NavController keeps track of the back stack of composables and the state of each one. It is also stateful which means that can directly change or mutate state.

By Hongbeom

App Startup is a part of the library of Android Jetpack. This provides a way to initialize the components needed to start the application. In this article, let’s take the Koin library as an example to learn how the App Startup library works and what benefits it has.

By Ashu Tyagi

This is the second part of multi-part series about Binders in Android. It is highly recommended to read Part I (if you haven’t already) otherwise this part probably won’t make much sense.

By Nikit Bhandari

Recently I was figuring out ways to detect screenshots in Android. It turns out there is no official API to do that but there are workarounds to detect if a user has taken a screenshot while using the app. You might have wondered how apps like Snapchat and Instagram can detect screenshots as soon as you take one. In this blog post, we will be exploring how to do that.

By Nicola Corti

My favorite feature of Github Action is: build matrix. A build matrix is a set of keys and values that allows you to spawn several jobs starting from a single job definition. The CI will use every key/value combination performing value substitution when running your job. This allows you to run a job to test different versions of a language, a library, or an operating system.

By TJ

This post is heavily inspired by Jesse Wilson’s post of the exact same title which I’ve shamelessly lifted. Please give it a read here. This post isn’t a rebuttal, but rather a series of juxtapositions; there is going to be a problem, and two solutions to the same problem will be compared on the abstractions they use to solve said problem, culminating in one comparing View systems on Android.

By Abhishek Jangra

Hey friends, I hope you’re doing well. In this blog allow me to share something rather interesting which can be achieved using custom views on Android. As you may know I am an Android developer working with Gojek.

By Filipe Batista

Back in 2019, Google announced in I/O 2019 a new “extension” for the notifications that would replace and deprecate the SYSTEM_ALERT_WINDOWAPI. Bubbles were created to provide the user a simple and easy way to participate in conversations. 

By Denis Craciunescu

The Kotlin compiler is smart. By performing static analysis on your code, the compiler identifies mistakes in your code as you type it. One of the most notable features of the Kotlin compiler is smart casting. The compiler has the ability to perform a cast based on the type checks done by the developer.

By Gökhan Alıcı

After some years of application development experience, I started working on the Android library development side. This article is the first article on my library development experience series which is about resources file usage that could be useful for library developers and integrators.

By Ziv Kesten

Recently I was interviewed for an Android software development position, and I was asked to live code a simple app that demonstrates fetching a list of items from a network resource and display their information in an endless list. I was given an API that supports paging and off I went coding away. There was just one problem.

By Ziv Kesten

Navigation in Jetpack Compose has been somewhat complicated to implement up until the latest release from the Compose toolkit team. Navigating between Android app screens was quite troublesome for years, using fragments and activities, with lifecycles and process deaths that catch you by surprise, I remember scanning through enormous code bases trying to find where one screen was replaced by another and why.

By Rajan Ks

As a developer who is always excited about new enhancements in Technology, I recently started exploring Jetpack Compose, Android’s own Modern UI toolkit to build Native UI in declarative style inspired from Modern frameworks like Flutter, litho etc.

By Niharika Arora

Knowing how that picture in your mind (or that wireframe a designer gave you) translates into actual layouts and Views is one of those key skills that every Android developer can benefit from.

By Ibrahim Süren

Creating open-source Android libraries benefits for both library owner and the other developers. A code written by a developer can save other developers from building the same thing, and also the other developers can contribute the same code. Thus, a library that will be useful for many people is can be created with the contribution of a few people.

By Ziv Kesten

Being an Android developer is a wonderful and frustrating position to be in.
On the one hand, we can create amazing apps, design our logic in a coherent, elegant codebase, and let our users enjoy the show. On the other hand, if you ask experienced Android developers about what are the pain points of Android development, most would provide the same answer.

By Phrase

Does your app have the potential to impact millions of people worldwide? Make sure it can reach as many as possible with these best practices for Android app internationalization (i18n) and localization (l10n).

By Jobin Lawrance

Anyone working on Android development for a while would have come across this crash if they’ve written any fragment code. This happens when Android’s FragmentManager is unable to instantiate the current fragment as it couldn’t find an empty fragment constructor.

By Maribel Maisano

When talking about Android development we use to think that the product that we are creating with our code will end up as a published application. We also use to think that people that receipt our work are always the final users: they will install and use our app on their devices (smartphones, tablets, smart TVs, cars, etc).

By Zohaib A.

While migrating to the new Paging3 library in the Jetpack suite of libraries, I ran into a problem, my onClickListener on the items of my RecyclerView was no longer able to get the data of the clicked item as the viewModel returned a flowable instead of a List which can be directly used in the PagingDataAdapter using the DiffUtil.ItemCallback.

By Idan Atsmon

A little over a year ago, following Google’s Kotlin First approach in Android development, I created and hosted a course for Android developers in my division, covering the basics needed to start writing in Kotlin and migrate our old Java projects to Kotlin.

By Shalu T D

Hey Android devs, we have discussed Preferences DataStore and Proto DataStore in the earlier part of this series. If you already have an Android app, probably you are using      SharedPreferences. So, here we will discuss how we can migrate such existing SharedPreferences data to DataStore. 

By Vadims Savjolovs

I have talked to many Android developers, and most of them are excited about Kotlin. So am I. When I just started learning Kotlin, I was solving Kotlin Koans, and along with other great features, I was impressed with the power of functions for performing operations on collections. Since then, I spent three years writing Kotlin code but rarely utilised all the potential of the language.

By Christian Schmitz

The RecyclerView.ViewHolderdescribes an item view and metadata about its place within the RecyclerView. Also it is responsible for caching potentially expensive View.findViewById(int) call results. In combination with the same synthetic properties that provide access to layout specific views of activities and fragments, this is basically the purpose of the Kotlin Android Extensions LayoutContainertype.

By Kartik Singhal

Continuous Integration and Continuous Deployment is very important for Android development as it solves a lot of problems such as manually running unit and lint tests, pain of building multiple APK variants manually (such as production & staging/debug builds) and then sending them across to your QA team. With CI/CD, you can automate this and much more.

By Khaled Qasem

In this article, we will learn how to create Barcode scanner using Google ML Kit and Jetpack CameraX. June 3,2020, Android: 16.0.0 / iOS: 0.60.0: This is the first release of ML Kit as a standalone SDK, independent from Firebase. This SDK offers all the on-device APIs that were previously offered through the ML Kit for Firebase SDK.

By Perfachhi

Did you know that android now runs on over 2.5 billion devices across the world? With the emergence of budget smartphones and affordable internet connectivity, people are using more apps and consuming more mobile services than ever before.

By Farhan Rasheed

Samsung, Google, OnePlus, etc would be the manufacturers that you generally would be working with because of the larger software-based consumer markets. Android, however, is a sophisticated operating system that can be used to integrate very specialized hardware to do some tasks very efficiently. There is a very niche category of devices that use integrated hardware to perform highly specific tasks.

By Michael Spitsin

Some time ago I worked on a new feature: sending images in the app’s internal chat. The feature itself was big and included multiple things, but actually, initially, there was no design for uploading animation with the ability to cancel the upload. When I moved to this part I decided that Images Needs Their Uploading Animations, so let’s give them that. :)

By Usama K.Zafar

Starting November 1st 2020, Google has made it mandatory for any developer offering in-app subscriptions to implement the Account Hold feature. I’ve spent the last week implementing it for my own application, following link after link to various pages of the documentation and I’ve decided to write this article for combining the entire process.

By Usama K. Zafar

In this part, we will create our backend service to integrate with the Google Cloud Notifications that we set up in Part 1. If you don’t have a Google PubSub topic that is configured with the Google Play Console, you need to go through the part 1 first.

By Seanghay

ViewBinding is a new feature of Android Gradle Plugin which allows you to access view hierarchy with type and null safety. ViewBinding is integrated with the Android Gradle Plugin directly, so it doesn’t depend on Annotation Processing (KAPT) as Butterknife does. Also, it much safer and cheaper than Kotlin Synthetic which uses HashMap under the hood.

By Abhishek Bansal

Slow build speeds are not unfamiliar to us Android Developers. It specifically becomes a nuisance when your codebase is large. Nowadays Kotlin  is the preferred choice of development language for many developers(including myself).

By Souvik Biswas

Navigation is one of the core concepts to master if you are working on any Android app having a complex navigation system. Properly handled navigation also helps to reduce any security flaw in your app, like authenticating the user before navigating to any sensitive content of the app or preventing any sensitive information to be shared with other apps on the device.

By Chizoba Ogbonna

I recently had to write tests to assert that the correct resources are being retrieved depending on a user’s locale. In a bid to write tests for each user locale, I realised I would have up to 18 different test methods which will look alike.

By Shashank Mishra

Recently, I had to work on displaying a custom timeline for a video playlist. Since a picture speaks a thousand words let me just show you what it looked like: As you can see, there are a few things which need to be accomplished.

By Dai

In Part 1 I demonstrated how we can use AndroidView to render traditional Views inside our Compose UI. For this part, we are now going to make newly created Compose UI components work inside traditional Views and Layouts with another special class, ComposeView.

By Dai

Like most Android developers following the development of Jetpack Compose you are probably wondering if you will need to rewrite your views or your entire app from the ground up. Well, it turns out, you might not have to, in fact, just like the days when we were all beginning to adopt Kotlin, we can slowly adopt new views and even make our current UI work with Jetpack Compose.

By Mudit Sen

Using WebViews in your native application is very common these days but when it comes to performance, rendering of a WebView is quite slow. As most of the heavy lifting done by WebView is loading images. In our Web-Pages we tend to use many images and most of those images are really large in size and loading them every time the user opens the App’s WebView is not good.

By Raul Hernandez Lopez

Synchronous communication in simple terms is when we start an action whose output may produce an immediate effect or reaction that must be handled as soon as possible because we are waiting for this process to finish. This is the opposite of Asynchronous communication, when the response is not coming instantly, with situations or examples like:

By Dmitry Si

Scope functions in Kotlin are powerful tools that can make the code more concise but, like any powerful tool, can also ruin it if not used properly. This article covers the typical scope function issues and gotchas and offers mitigation practices.

By Isaac Udy

I recently read an article by Jesse Wilson titled “Building on the Wrong Abstraction”. If you haven’t read the article already, I would highly recommend it. Reading Jesse’s article started me thinking about one of my favourite problems in the Android world: Navigation. Navigation is a key part of any application that has more than two screens. Which is probably most of them. But navigation on Android sucks.

 By Adam Hurwitz

You’ve spent too much time testing if you have had to reconfigure a feature’s code to make it testable or have debugged the ordering of actions/events and the resulting test output. Using the Model-View-Intent pattern (MVI) provides the ability to test built-in to the pattern following the best practice of Test Driven Development (TDD).

By Arkadii Ivanov

Kotlin Multiplatform is a technology that enables code sharing between different platforms. It is completely up to developers how much of the code they want to share. But there are cases for which we just can’t write shared code, even if we would like to.

By Abhishek Bansal

In this article, we are going to use Half data type from the Android platform and also explore the caveats of it. This post is add on to a previous 3 part article series.

By Farhan Rasheed

APK stands for Android Package. It is the package file format used by the Android operating system for the distribution and installation of mobile apps. There are multiple use cases of working with a compiled package. The absence of source code is the primary reason why you might be reading this but I’ve listed down some other use cases I’ve encountered in the past in the last section.

By Ashu Tyagi 

First of all, why do we even need to know about binder? Have you ever thought what prevents us from tricking the system into hiding the soft input keyword which is being used by some other application, or releasing a wake lock acquired by another application, or from hiding another application’s windows from the screen?

By Zhelyazko Atanasov

One of the first things that every new Android developer learns is how to create a simple user interface. We’ve all been there, reading about all the XML files needed to build a UI — the layout, strings, dimensions, styles… Then we were taught how to use those in our Activities and Fragments. 

By Aman Bansal

In mobile development, the Android and iOS versions of an application often have a lot in common . The business logic behind the apps is probably pretty much the same. Download files, read from and write to a database, get and send data to a remote host, parsing the remote data, etc. So why not we write the business logic only once and share it between different platforms?

By Chetan Garg

Learn pure Kotlin DI then migrate it to HILT or Dagger. Dagger is one of the popular frameworks that has been known for Dependency Injection (DI) for Java and Android platforms. It’s in most of the Android projects whether small or large, developers tend to start off with the basic scaffold of Dagger just not to deal with the huge boilerplate or to avoid huge migration of adding it later to the project. 

By Jaewoong Eum

A new UI toolkit Jetpack Compose is announced by Google. Jetpack Compose is Android’s new modern toolkit for building native UI based declarative component approaches. In contrast to imperative programming, declarative programming is a programming paradigm that expresses the logic of computation or drawing UIs without describing its control flow. 

By Mohammed Hemaid

Extensions is one of the coolest features in Kotlin as it provides the ability to extend a class with new functionality without even inheriting that class! Remember how we were doing that using other programming languages that doesn’t support extensions, by inheriting the class or use design patterns such as Decorator, but what extensions will do is to reduce writing that boilerplate code by defining just a functions, today we will talk about the common extensions in Kotlin.

By Halil Ozercan

It is not uncommon that once you run into an issue with Intrumentation Testing in Android, you’d feel like the loneliest person in the world. This might be an unforeseen effect of abundance of Android knowledge that exists on the Internet. Whatever you search for, there is always a StackOverflow answer or a Medium article that exactly describes what you need to do.

By Hán Trung Kiên

Following on from an official site of the Dagger, Hilt is built on top of the popular Dependency Injection (DI) library Dagger to provides a standard way to incorporate Dagger dependency injection into an Android application.

By Jean-Michel Fayard

Hello Human! This tutorial is for you if you have an Android or Kotlin or Java project built with Gradle, you write unit tests, you have no Continuous Integration system setup to run your tests on the server. Having the guarantee that your unit tests run on the build server is a keystone to establish a culture of testing withing your team — either at work or in an open-source project.

By Alexey Soshin

So, you develop some of your services with Kotlin and Ktor. Normally, your Ktor services will sit safely behind a reverse proxy, that will handle all the basic security concerns, including SSL, for you. And in your test environment, you would be running without SSL at all, simply bypassing all security. That’s usually the case. But in my case, I had a particular HTTP client that I needed to test, that would only support HTTPS.

By Damian Burke

Building software is a complex task. Some software is built by a single person, but often times there are teams behind software. These teams can range from two people up to hundreds of people. Working with many people in the same code-base brings quite a few challenges. Tools like githelp out with working in parallel by enabling us to version our code (i.e. see changes over time) or to easily spot changes suggested by team members. 

By Erick Sumargo

It’s nice to have personal documented guides, it’s such time-saving instead of rewriting similar arguments in every code review activity. Without further ado, below are my coarse-grained compilation factors taken into every review action (reading in order is recommended):

By Souvik Biswas

Designing a complex user interface on Android having a nested view hierarchy was a common thing previously. But, with the introduction of ConstraintLayout, this has changed a lot. It reduces a lot of challenges of building complex layouts as now you can design them using the GUI of Layout Editor, by just dragging UI elements into a visual design editor instead of writing layout XML by hand.

By Husayn Hakeem

Android’s biometric APIs allow for secure authentication on the Android platform. They manage a system-provided biometric authentication prompt, and provide a seamless experience by supporting various authentication types, including biometric ones such as fingerprint and face, as well as non-biometric types like PIN, password, and pattern.

By Denis Crăciunescu

Jetpack Compose is a modern, fully declarative UI toolkit created to address the challenges of the old View system. Unlike the old View system, Compose provides a declarative API that enables your UI to react to changes, without imperatively mutating the frontend views.

By Abhishek Bansal

Weather visualizations are mesmerizing to the eyes, and, they are equally fascinating from a technical standpoint. In this article series we are going to explore how can you render such a beautiful visualization with little understanding of data and Computer Graphics.

By Elvina Sh

Hi there! In the Navigine team, we’ve been providing indoor and outdoor positioning mobile technologies that enable advanced indoor navigation and proximity solutions for eight years. In our previous article, we wrote about handling tap, pan, and pinch gestures in Android views using gesture detectors. 

By Rob Pridham

Hello. I’m Rob and as of January 2020, I work on the Android version of BBC Sport. Our codebase started its life in 2013 and it’s fair to say we have amassed some tech debt over that time — we are now trying to sort out our fundamentals.

By Vivek Singh

Ever since the release of Android Jetpack it has come up with several libraries which makes us writing better Android code, avoid boilerplate code, etc. and now this time it has brought us an another awesome library called Datastore which according to official blog aims to replace the Sharedpreferenced API which has several drawbacks.

By Elvina Sh

Hi there! In the Navigine team, we’ve been providing indoor and outdoor positioning mobile technologies that enable advanced indoor navigation and proximity solutions for eight years.Today we want to tell you more about WiFi scanning on different versions of Android devices and the restrictions you could meet during the development process. 

By Aleksei Jegorov

jUnit tests or automation tests? That is the question. Every project developed along with unit tests. Sometimes it based on TDD/BDD approach, when test and method under the test developed in parallel. Also there are mock tests, integration tests and UI tests. In case of UI Java Android it is a Espresso and UIAutomation standard libraries.

By Erick Sumargo

Given the “find out how to en-decrypt data in Android” requirement, what would you do Unless you are a security expert or developer with a security career dedication that writing the cryptographic code from scratch is just a trivial task, it’s very common for us to start “Googling”, deep dive in “Stack Overflow” to find security-related implementation answers until we probably find below similar snippet:

By Anup Ammanavar

Creating loosely-coupled Reactive Feature Components. Re-usability is a pattern that solves the problem of duplication. It can be as simple as creating Functions, Classes, Interfaces to more complex UI-Components and Feature-Components.

By Husayn Hakeem

Android Q introduced new thermal APIs to allow better handling of thermal issues. This article goes over why these APIs were needed, the information and controls they provide, and how you can test your app under different thermal stress levels.

By Michael Spitsin

There are different Architecture approaches in Android. The ways you can structure your code and organize the project. In each approach, there are tonnes of variations of how things can be provided/organized/transferred or shown. Moreover, from time to time you may mix different approaches and result in a half-blood architecture that is fitted for your needs, for your team, for your way of work.

By Pavlos-Petros Tournaris

A lot of modern Gradle projects are starting as a monolith during the prototyping phase, but soon enough when the project has matured you start realising that a modularized project has a lot of advantages.

By Michael Spitsin

Android makes UI development interesting and fun by giving the ability to create some custom widgets or animations. Today let’s try to make some fun by creating a sonar-like animation:

By Nikit Bhandari

Using ML Kit’s Digital Ink Recognition API, we can recognize handwritten text or sketches made by the user on a screen. I made a simple app to play with this API as you can see in the video below, you can draw anything and the app detects it in real time. These guesses are pretty accurate and I am quite impressed, to be honest.

By Niharika Arora

In the last article, I showed off my love for fashion which lead me to correlate it with the topic at hand i.e, how UI is created and what will be the impact of view lifecycle methods in the context of various layouts. In this blog, I will be discussing various tools I used to measure performance...

By Nicola Corti

One of the first things I set up when working on a project, is a Continuous Integration (CI) system. I’ve recently spent some time migrating several projects of mine to Github Actions. I have to admit that I was amazed by how easy it was to set up, together with the performance boost I gained from it.v

By Tarun Sharma

Almost every Android mobile phone works on a multiCore processor. Multithreading or concurrency is an awesome way to use a multi-core processor environment and build fast and efficient applications. The Concurrency has a direct relation with Android application Performance.

By Niharika Arora

Imagine, you’ve just joined a new job and you need to shop for a whole new wardrobe that goes with your workplace culture and outlook (formals in most cases). You walk into an apparel store, head straight to the formals section, and you notice that some of the items hanging there are quite impractical and uncomfortable.

By Suleyman Fatih Giris

Dagger is an advanced dependency injection library and it is not easy to understand at the first glance for most developers. Using Dagger in Android requires much more effort for framework classes since it requires some boilerplate code. Hilt helps to reduce Dagger’s complexity and boilerplates with a set of ready components, scopes, and annotations.

By Prafull Mishra

After a series of bombardment of new features by the Android Developers team (huge round of applause for the results 👏🏻), time to get back to our regular daily dev bytes! The topic I am going to pick is covered with dust and spider webs. Mostly because it got overlooked in favor of other things that keep happening in Android world, but its still useful, or at-least can be, if you lie in its target area.

By Bhavya

With the ever-increasing complexity of mobile applications, you would always want to avoid user reviews like “this app is janky” or “it is too slow on my device”. So today we are going to learn about how complex layouts can cause this janky behaviour, how to diagnose it, and then finally some tips on writing performant layouts.

By David Vávra

Google Play Core library version 1.8.0 brings a long-awaited feature: native in-app review dialog. I added it to the latest version of Settle Up and I’m very satisfied with it — it instantly boosted our ratings and the integration was very simple. Goodbye annoying custom dialogs asking for a review.

By Alankrita Shah

WorkManager is an Android Jetpack library that enqueues deferrable background work and guarantees their execution when its constraints are met. This is the second blog post of the WorkManager series. Previously on WorkManager… 

By Vivek Singh

I strongly suggest you to read the first part of this series How to Use the Paging 3 Library in Android before continuing. In the first part of this series, we learned about the basics of using Paging 3 library in android. Now in this part, we will learn about creating headers and footers to show the loading state in the RecyclerView itself and then we will learn about creating list separators in the same RecyclerView.

By Nikit Bhandari

Recently I was testing some Google Play Store related functionality in different emulators and I realised that it is a bit tricky to install Google Play in some emulators. It is easy to install Google Play Store for API 24 and above as we can directly select an emulator that has Google Play from the AVD manager.

By Huga Matilla

Managing the look and feel of an Android app can get tedious, and more when the app gets bigger. Style definitions, color attributes, sizes, etc. grow and grow if we don’t manage them properly. Even if we can control them, a big set of style definitions can be difficult to follow.

By Vivek Singh

Most apps displays a large list of data to the users, but at a particular time the user sees only a small chunk of data in your app, so fetching all the data from the network is not an efficient solution. The solution is to fetch small chunks of data at a time, and as soon as the user reach at the end of the list, then the app will load more data. This is called Paging.

By Matthew Dolan

When updating my Android caching library, layercache, with built-in support for the new Jetpack SecurityEncryptedSharedPreferences I started to write unit tests using Robolectric, but soon came across the exception java.security.KeyStoreException: AndroidKeyStore not found.

By Egbai Smile Mmumene

In software development one of the most prevalent things is state management or simply put, knowing what to do and when to do it. The main focus of this series would be the presentational layer of an app and devise modelling of received data into a state object and interpretation at the view i.e managing the view in correspondence to emitted state.

By Nicola Corti

Kotlin, as most of the programming languages, has several reserved keywords. You can find all of them listed on this page of the official documentation: keyword-referenceI invite you to spend some time going through the list. 
Do you know all the keywords?

By Hossein Abbasi

What is better for a developer than writing code once and run it on various platforms, natively? (but in real! and not like Java which runs anywhere(WORA) that a JVM only exists!) Let me quote from Kotlin website to show you the power of Kotlin and what we’re gonna talk about in this article:

By Ruslan Myhal

In this article, I will not go into detail about ViewPager2, the difference between an old ViewPager, I will attach some links at the end of the article, in which this is described in detail. Here I will show an example of using ViewPager2 with mutable fragments collection with DiffUtil and what problems are hidden there.

By Elvina Sh

Hi there! In the Navigine team, we’ve been providing indoor and outdoor positioning mobile technologies that enable advanced indoor navigation and proximity solutions for eight years.In the previous article, we told you about the Bottom Sheet Behavior and how to animate the button on top of it. Today we want to tell you one interesting feature we implemented in our Navigine Android app which will make your UI more attractive.

By Ian Alexander

Depending who you speak to, putting @Inject on a constructor is either akin to whipping your own grandmother or is such a blindingly obvious thing to do that the question is ridiculous. But which is right?

By Shivam Dhuria

Knowledge of Retrofit, Room and Coroutines is a must for this guide.In this tutorial We will build an app that fetches dog breeds from DogApi using Retrofit and then save it to database using Room. We will then use Flows to display the list of dogs from the database.

By Niharika Arora

Android development continues to dominate the world of mobile development. Fun projects, great pay, and tons of job prospects are just some of the reasons developers are starting their journeys into the exciting world of the Android operating system. Some experts say that there has never been a better time to learn Android skills, especially since the recent updates, like the addition of Kotlin and improvements to Google’s policies.

By Adam Hurwitz

You may think of ‘magic mushrooms’ when you hear ‘fungi network’. However, just like the Model-View-Intent (MVI) pattern, the forest’s organized fungi network of a connected info sharing system, like Model-View-Intent’s pattern, is indeed not magic.The Unidirectional Data Flow (UDF) pattern does a great job to ensure information is sent in one direction from the view to the business logic, is retrieved, and processed in order to build the view.

By Vladimir Petrovski

Last year’s Android 10 announcement came with many new features like Gesture navigation, Dark theme, Location control and more. If your apps haven’t yet been migrated to the newest version, go ahead and do it! There have also been many changes at the API level, so check this linkbefore switching to Android 10.Well, enough announcements about Android 10 since Android 11 Beta is already out.

By Miroslav Kacera

As a software developer, you have probably heard that too. Naming is one of the hardest things in programing. According to Phil Karlton it comes with caching. But for caching you have lot of libraries at hand nowadays, right? That probably makes naming the single hardest thing out there.

By Aung Kyaw Paing

Since the pandemic starts, my work has shifted to remote working, and this changes a lot of things for me. But you’re not here to read about me talking about good and bad of remote work. So, I’m just gonna go ahead and give you a little background on why I thought of playing around with UIAutomator in the first place. We’re using a human resources management system called BetterHR.

By Kishan Maurya

In my previous articles on unit testing, I have talked about ViewModel, Usecase, Repository testing using JUnit & Mockito. Today I am going to explore about Spek framework for unit testing.Spek is a Kotlin-based Specification Testing framework. Spek is written in Kotlin and specifications or tests we write will be in Kotlin. However, our SUT (System Under Test) can be Java or Kotlin.

By Aidan Mcwilliams

Note: If you’re viewing on mobile, the code snippets are better in landscape. While reading Danny Preussler’s article Keep your interfaces simple, I had some thoughts on how to use some other Kotlin features to take it a step further. I’d suggest reading that first for context. Lets say we have our feature flags defined like this:

By Elvina Sh

Hi there! In the Navigine team, we’ve been providing indoor and outdoor positioning mobile technologies that enable advanced indoor navigation and proximity solutions for eight years. Recently, we have devoted a lot of time to working with graphics on mobile devices and handling gestures. 

By Volodymyr Buberenko

Today I would like to tell you about a convenient tool to automate Gradle dependencies updates called Dependabot. It feels like this tool was overlooked in the Android community, so I would like to fill this gap. I started to use Dependanbot a few months ago and tried to use different versions of it, so this article is based on personal experience.

By Catalin Ghita

The goal of this article is to familiarize you with the development of processing voice input in Android. Therefore, this piece will allow you to understand how to transform the user’s input into text and most importantly how to parse and extract relevant information from it. In order to achieve such an effect, we will use the native Speech API interface on Android and the 3rd party NLP tool (Natural language processing) named StanfordNLP.

By Julián Ezequiel Picó

Welcome to the last (at least, for now) article of this series, where we are going to discuss what is a StateFlow and its behaviour. You can see some examples by checking the GitHub Repository. There, you will see how a StateFlow is implemented and how it works. Now that you will have a basis about Kotlin Streams API, you can fork and modify all the examples that you have there

By Jossi Wolf

We recently joined a new project with heavy LiveData usage, everywhere. The search for main thread blockages led us down a rabbit hole of removing a significant portion of our LiveData usages.We started off with Repositories, ViewModels and Fragments. The repositories would connect to data sources and expose LiveData. The ViewModels would then expose the LiveData to the UI Layer.

By Danny Preussler

Writing your classes with a good API is hard but important. As the writer is trying to make it easy for the user, we sometimes tend to repeat ourselves by adding convenient methods.Think about the List interface in Java. To check if there are no elements in the list we could check list.getlength() == 0  or we simply ask for isEmpty ().

By Leandro Ocampo

I have been working as a software developer for around 10 years, and during those years I have been looking for patterns and the perfect architecture that will help me to build any kind of product. You will find even in social media that well known developers in the community will have different opinions on what that perfect architecture is.

By Thanos Tsakiridis

Recently, while I was investigating a weird issue of double network calls, I discovered that the root cause was not some bad network state or my HTTP client, but something much more simple and often overlooked. User double-tapping on a button too quickly…A few years ago (like a lifetime in Android development) ButterKnife library was extremely popular for Java-based apps to bind views and avoid all the findViewById calls.

By Shubham Panchal

Android animations are important for rich user experience. An interactive UI where every change takes place with fluidity engages users to the app. Animations plugged with colors, widgets and dialogs will make your app a huge success. Animations and Transitions in Android have gone through various changes over the past API levels.

By Rygel Louv

Koin is an amazing Dependency Injection Framework for Kotlin and Android projects. It has gained huge popularity over the past two years and many Android developers (including myself) have adopted it, use it in production relying on its powerful mechanism to help perform dependency injection. And we just love it!

By Manuel Ernesto 

Today we will continue our series about Android Jetpack, and for this post, we will cover Jetpack Compose.Jetpack Compose, is a modern toolkit for Android development and it’s the Google answer to simplify the development of UI in Android. Jetpack Compose is new and was announced last year at Google I/O 2019. Jetpack Compose combines a reactive programming model with the conciseness and ease of use of the Kotlin programming language. It is fully declarative like we already see on flutter, Swift UI, and React Native.

By Seanghay

WebP is an image format that is developed by Google, focuses mainly on optimization and quality. One of the cool features of WebP is that it is lossless and lossy which means it supports both types of compression, unlike PNGs and JPGs. WebP is fully supported on web browsers such as Chrome, Firefox, and Opera (see the image below). On the Android side, WebP was added since API 14, so it is more than safe to use WebP on Android these days.

By Jomar Tigcal

As an Android developer, you’re most likely using Android Studio for development. Installing, updating, and uninstalling, especially you have several variants, is sometimes time consuming and can distract us from coding. I recently learned something which can help make this easier for developers, the Toolbox App.

By Andrey Beryukhov

Jetpack Compose is one of the most discussed topics covered in the recent Android 11 video series. It is expected to solve most of the problems with the current Android UI toolkit, which contains lots of legacies. Another promising tool for Android-development is Kotlin Coroutines and especially Flow API which is supposed to help avoid over engineering with RxJava.

By Jomar Tigcal

App Signing by Google Play has been around since 2017. With App Signing, Google manages your app signing keys and uses it to sign your APKs for distribution. Enrolling your app in App Signing is optional. You might have decided to handle the signing and storage of your keys instead of uploading them to Google Play.

By Manuel Ernesto 

Hello, today we will be starting a new journey of learning Android Jetpack. Android Jetpack was introduced by Google at Google I/O 2018 and since then so many things have changed in the Android development world. Android Jetpack is a set of components, tools and architectural guidance that make it quick and easy to build great Android apps. Components are individually adoptable but built to work together while taking advantage of Kotlin language features that make you more productive.

By Merthan Erdem

Today I’ll quickly tell you a way to make every log in your application look like this with a clickable hyperlink to the location, just like with Exceptions. This was simply logged in the method getImageCaptureId() at line 222 of AddPictureFragment, and the call simply looked like this, no need to specify anything:

By Reza Bigdeli

An old tale of composition over inheritance, sort of! One of the good practices when writing code is “Reusability”. Instead of writing the same code multiple times, we should write it once and use it wherever we need to. Simple as that! Well not so fast! How can we achieve it though? The first thing that comes to mind is to find the similarities/duplications and put them in a base class. This way whoever that is extending our base class can have the functionalities out of the box without needing to write them over again! But there is a problem with this approach

By Catalin Gheorghe

One thing we can all agree on is that any project can benefit from well written unit tests. There are some cases where writing unit tests feels repetitive and sometimes we can end up duplicating code just to change the input and the expected output.

By Kumar Gaurav

When we talk about refactoring the code, the very first thing which comes to mind is that “Why to change something which already works”. We often convince ourselves by telling that we should focus more on fixing customer issues, adding new requirements/features as this is the area from where actual money comes in. 

By Sujata Swamy

Hello guys!! We all know how important it is to keep our android gradle build tools updated. This post is not about any prerequisites to upgrade gradle version to 6.1.1 but its just the experience i wanted to share that i faced on upgrading the gradle version from 5.4.1 to 6.1.1. So as always we receive the message to update the gradle, so we are tempted to update it to get the benefits of the improvements in the build system.

By Julián Ezequiel Picó

We already know what cold & hot streams are (and if you don’t, check the previous article, link below). Now, let’s discover our first Kotlin Stream implementation: Flows. Again, you can see some examples by checking the GitHub Repository. There are very small and simple cases that will help you to understand how to use Flows and some other stuff.

By Hongbeom

My first Android DI library was Koin. Dagger had a high running curve at the beginning and it was difficult to learn, and at that time, I used Koin to build an app at the company I work for. Recently, the Android studio unveiled a library called Dagger-Hilt, which makes it easier to use Dagger, which has a disadvantage of being difficult to learn. I didn’t know anything about the dagger, but I thought I should learn it someday, so I started using the Dagger-Hilt.

By Rafa Araujo

When we build our project with Gradle, either by command line or by Android Studio, a long-running background process that runs the builds called Daemon is used. The Daemon is used not only to avoid the cost of starting the JVM for each build but also to cache information about the project structure, files, tasks, and more in memory. This makes the next compilations much faster.

By Niharika Arora

“Every problem is a gift — without problems, we would not grow.” ― Anthony Robbins. When we have to display information for a short span of time in Android, we use Toast. Here are some key features: It provides simple feedback about an operation in a small popup, It is a view containing a quick little message for the user, It only fills the amount of space required for the message and the current activity remains visible and interactive.

By Javier Marsicano

ExoPlayer has been a widely used library to implement customized video players into Android apps since it’s an open source library supported by Google. It is an alternative to Android’s MediaPlayer API providing many more out-of-the-box features as well as supporting a lot of video formats and sources. Hence, we can develop an advanced and tailored video player avoiding reinventing the wheel.

By Fábio Carballo

If you are using instrumentation tests in your Android app, it is likely that you are using Espresso— allowing you to define expectations about your app screens and how to interact with them. During your day-by-day as a developer you will eventually implement some custom views.

By Nicola Corti

Have you ever experienced something like this: Have a great idea for a weekend project, Create a new repository, Setup a proper CI to build your project, Setup a code formatter to enforce code-style, Start reading articles about tool name here...Weekend is over 😅, Repeat

By Aleksandar Balalovski

I find any technology a tool to create wonderful things. That was one of the reasons why I gave Flutter a chance. To be honest it shook my world in a very pleasant way. One of the key benefits that I, as an Android engineer first noticed is the immediate feedback loop. If every talented and curious developer out there develops the things at the moment a creative energy flows, how many wonderful features, products or concepts can happen in a span of one Android clean-build?

By Danny Preussler

How tools made us forget how to write sane constructors. In an ideal world, developers get smarter every day. The code we write this year should be better than the code we wrote 10 years ago, which in turn should be better than the code 20 years ago. Today we have better tools, more modern languages, and better practices. But as often in life, we realize we are not living in that ideal world. 

By Ahmed Abd-Elmeged
Navigation sounds like a trivial problem to solve right? as you start an activity or a fragment and the flow goes on. But Let’s be real that is not how it works. Usually, you will have a ton of conditional navigation like, is that user is logged in? is that his/her first time should I open home? or should I open the onboarding flow? How many screens can I trigger the auth flow from?

By Jaewoong Eum

Application class is the first entry point of the android application process and it’s for maintaining a global application state. It is always running while our activities and services are running and also it is the first context to be created and the last to be destroyed. So it manages lifecycles of the whole applications using ApplicationContext, we can access the application’s resources, show toast messages, and create instances of Android SDK related classes that use it.

By Roger Taracha

This is Part 4 of the blog series Automating the Android Build and Release Process using Fastlane. In case you haven’t read the 3 posts that precede this one, here are links to Part 1, Part 2 and Part 3. This will be a somewhat long and detailed post, so I would recommend that you grab a cup of coffee as you begin reading this. ☕️

By Lukasz Kalnik

The Arrow.kt Either type is very practical for handling domain errors in the app. What if we could get the type returned directly from our REST API calls made with Retrofit and use it consistently in the whole application? Retrofit gives us two kinds of errors:

By Alex Saveau

When it comes to finding a piece of code, GitHub’s search can be less than helpful at times. In stark contrast to that, the public version of Google’s Code Search tooling absolutely kicks ass. cs.android.com and cs.opensource.google are my go-to tools for finding open source Google code, but unfortunately, they’re just that: Google Code Search. If you’re looking for non-Google code, you’re out of luck. Until now.

By Cristian Villaseca

Heroku is a cloud platform as a service that supports Kotlin. It has a free plan that will allow us to start working on integrating our clients with our API and is very easy to configure. I’m going to use a Github Action to make automatic deploys every time something is pushed to master. After you have created an account, we can follow with the next steps:

By Cristian Villaseca

Now that we have our API working we need to make sure that it works as expected, in this part I’m going to explain how to write Unit tests: They cover small pieces of code, don’t cross layers and they execute fast. I also want to mention the Integration tests, they don’t use mock data and cross all the layers, which is the reason why they are slower compared to unit tests. To do Integration testing we need a testing database which. which it is out of the scope of this tutorial.

By Cristian Villaseca

H2 is a relational database management system written in Java. It can be embedded in Java applications so it is perfect to not spend a lot of time installing and setting up a database and focusing on our API instead. 

By Cristian Villaseca

As an Mobile Engineer, I’ve tried numerous times to build an API for my App projects and I’ve always ended up frustrated for reasons like: Not understanding the language or the framework I’m using, Not willing to pay for hosting before the project goes live, Using a platform that won’t scale up. So after all these problems, I decided to write the Rest API using the Spring Boot framework, in Kotlin, and with Gradle as a dependency provider (instead of Maven).

By GuilhE

I assume the reader has knowledge and strong base concepts of Kotlin, Dagger, and Android App Architecture. The purpose of this article is to show an Activity evolution — can also be applied to a Fragment — to accommodate a ViewModel setup. Throughout this journey we’ll see how dependency injection will fit in by using the following approaches:

By Waseef Akhtar

I didn’t plan to write this at first since my last tutorial covers pretty much everything about MotionLayout I intended to write about. But..I received questions on social media about this one action several times, which is about how to move to next screen after our animation is complete. I thought it’d be easy to figure out on your own but when I looked around, I figured that there aren’t very many resources for MotionLayout yet.

By Bartek Lipinski

Initializing app start is an unexpectedly complex problem. I have already briefly raised the subject here. I will address how the new App Startup library from Google’s Jetpack handles (or doesn’t handle 😉) the problem in a different blog post. This one simply describes how to bind App Startup with Hilt.

By Raul Hernandez Lopez

The most exciting moment for a software engineer surely is when enjoys coding and gets stuff done. However, for the pragmatic developer, implementation details should be as important as the process to get things done, because the difference is on the details, isn’t?

By Nikit Bhandari

In Android 11, we can see a lot of updates that improves privacy. If your app uses thePackageManager methods to get the list of installed apps in the user’s device, you will have to make some changes in your code for devices using Android 11. In this blog post we will be discussing all our options. If you are already querying user’s installed apps, the following code snippet will look familiar. This is how you can get a list of installed apps of the user.

By Vipin KT

Logging is an essential part of software development. It helps developers to see what the application code is really doing. Android SDK has a built in class called Log. It contains utility methods to log messages with different priorities. The problem with Log class is that every time we need to to provide a TAG for the log and we have to make sure that the log messages are disabled in production.

By Kunal Chaubal

Reactive programming has been trending in Android for quite some time now, mainly because it simplifies the process of writing async code. LiveData is a variant of the original observer pattern, with the addition of active/inactive transitions, allowing communication between the data source and other UI components. With LiveData, comes Transformations, which provides a better way to perform manipulations on the LiveData instance. Think of Transformations as Util class for LiveData that helps in modifying the data as required.

By Alexey Glukharev

Today we will talk about architectural decisions that are more complex and global than the architecture of the presentation layer (like MVP, MVVM, MVI, etc). We will talk about how to build an extensive application and make this an efficient workplace for dozens or hundreds of developers. With these techniques, your application will be able to scale to any size regardless of how much code you’ve written.

By Anoop M Madasseri

The final version of the support library is 28.0.0 and it’s no longer maintained. So, If we want bug fixes or new features that would have previously gone into the Support Library, we need to migrate to AndroidX. All new Jetpack libraries will be released in AndroidX namespace.

By Elvina Sh

Hi there! I am from the Navigine team. For eight years we have been providing integrated positioning mobile technologies that enable advanced indoor navigation and proximity solutions. I wrote an article about new Android R important changes and after the release of the new Android Studio, I decided to review all the changes and new features of it. I already managed to test the new android studio, so I decided to analyze in detail each change and innovation with which we will use in the future. So let’s start!

By Manuel Ernesto

On the Google I/O 2019, the Google team presented the possibility to developers add a dark theme to the android applications and since then many application has already been updated with this feature like example: Youtube, Instagram, Chrome and so many others. In this article, I will explain how you can implement dark mode in your application in an easy way.

By Tuan Kiet

WorkManager has come a long way, there are a lot of changes and improvements in the library but the Dagger setup remains unchanged and still working well. Despise all of that, I feel like my article 2 years ago is a bit out of date. So here you are, the 2020 edition with the latest stuff and best practices updated.

By Lina Berzinskas

PreEmptive participated as a partner in droidcon Berlin, droidcon NYC and droidcon San Francisco in 2019. This article is based on comments, questions and feedback we gathered from discussions with developers at these events. We wanted to summarize our answers in an article to help you understand some of the key differences between ProGuard, DexGuard and DashO which are the three leading obfuscation, code shrinking and code optimization tools.

By Artem Gapchenko

Recently I’ve been playing with my own beacon monitoring library. I was curious if I could build something that would fit my needs while being significantly simpler than the AltBeacon solution from Radius Networks. While I was working on it, I’ve found several unexpected quirks (from bugs that lead to crashes, to bugs that lead to the necessity of the device’s factory resets) that I want to share with you today.

By Shivam Dhuria

I use val dogBreedList = api.getBreedsList().message.keys.toList() to fetch all the breeds and convert it into a List. This happens in background thread ,Dispatcher.IO as explained in Part 1 because of the suspend modifier in retrofit requests in MainActivityApi.kt.

By Peter-John Welcome

Android Studio 4.0 was recently released to the stable channel and it came with many new features. A feature I’ve been looking forward to has been the Layout Inspector. I’ve been doing mobile development for a while, including iOS development, and when debugging iOS apps, especially when it came to UI bugs, Xcode had a great tool for this. It was called Debug View Hierarchy. 

By Elvina Sh

Hi there! I am from the Navigine team. For eight years we have been providing integrated positioning mobile technologies that enable advanced indoor navigation and proximity solutions. This article will be devoted to changes in the new android, which will appear from day to day, but previews and docks for which are already available.

By Raul Hernandez Lopez

Refactoring an application to use modern techniques and libraries can be really challenging. This post is the second part where I explain how I started to learn about the concepts that are a must-do for it. Since the presentation had a limited time to speak about some topics, they were covered quickly sometimes, but here I want to tell in-depth or at least trying about a few subtle details.

By Peter Törnhult

LiveData is a great tool to use when working with Android Architecture Components. Before I knew how to use the Transformations class, I was abusing LiveData and creating a lot of code-smell. Having worked with LiveData and Architecture components for a few years now I think I’ve figured out some good practices and patterns that I’d like to share with you.

By Jaewoong Eum

Dagger is one of the most popular and most used libraries for building dependency injection, especially in Android. But the initial cost of learning is high and beginners are difficult to debug and hard to understand what’s going on in the compile time. So here is another powerful DI weapon for beginners and old dagger users: Dagger-Hilt. In this post, we will look around what’s big differences from dagger-android and dagger-hilt and what’s the benefits bu using Hilt.

By Kunal Chaubal

Animations and transitions are essential ingredients for developing any mobile application. Think about how rarely we come across apps that do not have at least one animated component. It helps in keeping the app as user friendly as possible and becomes a very effective marketing tool.

By Vipin KT

Android Studio has a set of pre-packaged templates for creating Activities, Services, Layouts etc. They reduce the burden of writing the same piece of code again and again. But if you are following a specific architecture (or a certain pattern of writing code) in your project, then these template may-not be suited for your needs as they are too generic. And it will take much time to adjust the code in each file generated by the template to follow your architecture.

By Michael Spitsin

Recently I received an interesting wish from my PM. He asked me: “If I will change one of the translations, will we need to release a new version of the app?”. I said that yes because we need to rebuild everything. And he said: “It would nice to have the possibility to not release every time when a translation is changed by PM”.

By Remco Mokveld

The hilt of a dagger, sword or lightsaber is used to be able to hold the weapon without cutting yourself in the fingers. Hilt is the latest attempt from Google to attempt to prevent you from cutting yourself when using Dagger. Shortly before the alpha release I started playing with it a bit. Being a big dagger-android fan I must say I was skeptical at first, but diving into it I found it to be pretty amazing.

By Waseef Akhtar

If you’ve been following me on Medium for a while, chances are, you might have passed by my blog posts regarding an easy approach to Navigation Drawer and styling it: Since those posts are more thorough, I know that it’s intimidating to consume so much knowledge all at once. And I know that because I received a few DMs asking about styling specific elements in the Navigation Drawer after those posts.

By Shivam Dhuria

For this tutorial, we will be styling an App with Material Theme.The application basically fetches a list of items from [Imgur Api] and displays it via a Recycler. For this guide however, we will just be working with the design of the App using everything material!

By Ahmed Rizwan

Cloned Android 10’s Calculator UI using Jetpack Compose, as it’s (surprisingly) one of the more complex UI structures. Before I get into it — previously I also covered Twitter UI —so check that out as well:

By Vipin KT

One year back while working on a project, we were tasked to create a separate application for a specific country (China). It was suppose have the same functionality of the main application but with a some changes. Initial thought was of copying the project and making changes to fit for the requirement. But the problem is that as new features will get added in future, maintaining the code will became a headache.

By Lukas Lechner

After publishing my open source project about Coroutines on Android, which currently includes 16 of the most common, real-world use cases of using Coroutines in an Android application, one of the most common questions I get from developers was whether or not we have to switch to a background thread whenever we call a suspend function to make a network request with Retrofit or a database call with Room in order to not block the main thread which would make the UI freeze and get unresponsive.

By Raul Hernandez Lopez

During this first part, I will introduce both the Use case which drove me to create the presentation called “Fueled Reactive apps with Asynchronous Flow” and what the Migration strategy I decided to take forehand. This is the story behind the scenes of the presentation

By Eric N

As explained by Dan Lew, it simply means passing dependencies through your class’s constructors or functions’ parameters so as to be able to swap them in unit tests. (MVP is used for simplicity here. Same concepts apply to MVVM). Here’s a very basic testable Presenter that make use of dependency injection:

By Angélica Oliveira

Let's see the difference between them and use the benchmark library to compare their efficiency. In Android it is really hard to think about an application without a RecyclerView. There are so many usages in our apps, like lists of contacts, users, clients, products, etc. Lists are part of our everyday life as developers, and of course, as users too!

By Harshal Dev

The official Android documentation carries no pages dedicated specifically to the topics of Internal and External storage. Though one of it’s pages provides an Overview of the Android Storage Model and explains the different ways you can store your application’s data, it still fails to provide any exact definitions of Internal or External storage and touches upon these topics only very briefly.

By Lukas Lechner

For the majority of developers, the concept of a coroutine is pretty unfamiliar, although the first ideas date back to the early sixties. This is because we started to learn Software Development with programming languages like Java, in which the concept of a coroutine simply does not exist. What we did learn, however, are how basic concepts like classes, functions, and interfaces work.

By Josef Raska

buildsrc is a directory at the Gradle project root, which can contain our build logic. This allows us to use the Kotlin DSL to write our custom build code with very little configuration and share this logic across the whole project.

By Gabor Varadi

Dependency injection is great. It can massively simplify our code, manage the lifecycle, instance count and scope of our object instances, and the more powerful DI solutions can even automatically resolve the dependency graph for us, potentially just by adding a single annotation to our constructor Inject), without us having to manually configure providers for our classes.

By Andrew Japar

As we know passing data and getting responses between two activities are the most common thing we do during the development phase for a long time ago. Currently, the only way to get responses back from the next activity is passing Intent and requestCode through startActivityForResult.

By Harpreet Seera

From handbags to power tools to electrical components to automobiles, 360° product photography is the most effective way to provide visual information that builds buyer trust and confidence in your brand. When searching products on any e-commerce or product based application, customers want to virtually “touch” and visualise your product/merchandise. 

By Sherry Yuan

Dagger has been the reigning dependency injection library in Android for a long time, but a few alternatives have appeared recently. I’ve used Dagger and Koin while working at Yelp and Hootsuite in enterprise-scale Android projects, and played around with Kodein in personal projects, and wanted to compare and contrast using the three different libraries.

By Vladimir Jovanović

Firebase provides a wide variety of tools, something for every developer and something for every problem. But did you know that it has a tool that enables you to see into the future 🔮😮?! Yes, you heard me right, the tool called Firebase Predictions enables you to predict future actions of your users.

By Mikhail Kulaha

If you have ever implemented analytics on Android you know how hard it can be to attach it to the existing app structure. Everything looks more or less fine as long as the number of events doesn’t go over a certain number. However, once the quantity of events starts to increase, support becomes really difficult. Events start to stick out from places where they shouldn’t be, properties start to disappear and everything becomes a huge mess.

By Deborah Yambenu

AdMob is Google’s advertising platform specifically designed for mobile applications. AdMob allows you to monetize your apps by serving ads selected according to criteria you define. So if you’ve developed an Android app and now you want to make money with your app, in this article I show you how to do it, how to add different ad formats to your apps.

By Kunal Chaubal

With Android 10 rolling out in more and more devices every month, the need for an Android app to support dark mode is on the rise. And if you haven't already updated your app to support Dark theme, your app could soon appear to be an outdated application.

By Vasya Drobushkov

Recently the article about Kotlin Flow benefits over RxJava was published by Antoni Castejón García. Though Antoni made a good work and many thanks to him for providing his feedback and experience (we need to share our thoughts, this improves community acknowledgment in various areas) — I found few places in the article with which I don’t fully or partially agree.

By Bartek Lipinski

I started writing this as a simple answer to Facilitating dependency initialization with Dagger multibindings, but it grew very quickly so I eventually decided that I should release it as a standalone post. So that more people are able to read it.

By Ivan Shafran

The article presents a pet project idea for Android developers. It includes design in Figma, useful links, and other tips. Initially, I’ve created the materials for an Android course for beginners. Most students were able to implement a project from scratch, so I believe this pet project is a good start point in Android development.

By Adam Hurwitz

One of the many great things about the Unidirectional Data Flow (UDF) to organize an app’s logic is that it works with any reactive programming pattern, whether it be Kotlin coroutines Flow (Flow), ReactiveX (Rx) based RxJava/Kotlin, or LiveData. Kotlin coroutines version 1.0 was released at the end of 2018 and anecdotally has quickly been gaining adoption, alongside functionality.

By Elye

Kotlin has lots of useful collection functions. It takes time to learn them all. To add to the challenge, some of the functions have variants where the name is appended with To, By and With. One good example that has it all is associate i.e. associate, associateTo, associateBy, associateByTo, associateWith and associateWithTo. 😵

By Mark Ng

It’s been an extraordinarily difficult time for many people and companies as we live through the Covid19 pandemic. Australia Post has not been immune from the pandemic suffering serious declines in its letters and international parcels business. However, there has been a glimmer of hope with our domestic parcel volumes seeing record growth due the lockdowns and the shift to e-commerce.

By Kunal Chaubal

As developers, you must be aware of the famous “Initial commit” that is pushed as the first commit to your repository. This forms as a base skeleton to your project on which we start building the app. This is the most crucial commit in the repository since this forms a building block of the project.

By Baljeet Singh

Augmented reality is very popular these days. A number of popular apps are using this feature like Instagram, Snapchat etc for face filters. Today we will learn about ArCore (library provided by Google) for building our first AR-based application with approximately 100 Line of code.

By Kunal Chaubal

If you have worked on android apps in the past, you must be aware of the crucial role that a RecylerView plays in the whole application. I have used this widget in all the applications that I have worked on until now and if I have learned anything about mobile apps, it is, lists are inevitable.

By Kunal Chaubal

Coroutines were introduced with Kotlin v1.1 in 2017 and since then we have experienced asynchronous simplicity at its finest. Coroutines bring in a volley of power-packed features to the game and most of us have already witnessed it by now.

By Prateek Prasad

Mobile apps have come a long way in terms of offering a rich user experience and have found new ways of structuring and surfacing information in the limited real-estate of a phone screen. Every app these days has some implementation of a “feed” of sorts that users interact with to consume the app’s content.

By Ian Alexander

This series takes a basic MVP app using Retrofit and RxJava to display a list of Github repositories; and converts it into a modern Android app — along the way it will give an introduction to a variety of techniques used when architecting Android apps, explain why those techniques are used, and perform a few experiments to boot.

By Elye

Android development has progressed more than a decade. Many lessons learned and approaches evolved. The below article provides a neat writeup of how Network Access has evolved in Android

By Alex Vasilkov

It is not an uncommon desire to split your codebase into reusable libraries (git repositories). Let’s review what options we have if we want to include external code into a Gradle project. An obvious choice can be git submodules. Creating a git submodule is easy:

By Stephen Vinouze

When working with RxJava, you’ll sooner or later end up dealing with this exception. Handling errors matter. RxJava throws an exception at you because you failed to take care of the problem. You must handle the error, or else your app will crash.

By Roger Taracha

In this article, I will explain to you the process that I used to publish my LiveData CallAdapter library. Let’s assume that you have already developed your Android library. You should have a library module in Android Studio as shown in the screenshot below: 

By Paneet Singh

Jackson is one of the famous library to parse XML or JSON data though with Kotlin, some key factors are required to avoid unexpected issues. By default, Java provides a default constructor(if there’s no parameterized constructor) which is used by Jackson to parse the response into POJO or bean classes.

By Mkhytar Mkhoian

When RxJava came to the world the Event bus pattern implementation becomes much easier, but we still need to write abstraction on top of the RxJava to make type safety API for our EventBus. First of all, create an EventBus interface.

By Chen Zhang

An example Android project and walk-through of how to publish and consume libraries via GitHub Packages, along with features and tips such as achieving transitive dependencies through Gradle API dependency, source code availability in published package and local publishing through custom repo or MavenLocal.

By Vasya Drobushkov

Many of us first learned Kotlin after Java. Learning process was fairly simple because Kotlin has many similarities when at the same time improves development experience by fighting common pain points Java developer (especially on Java 6, which is common in Android world) has to encounter every day.

By Peter-John Welcome

Testing is a critical part of the software development cycle. There are different types of tests, such as unit testing, UI testing and even manual testing. When it comes to making app builds available to QA engineers, we can do this in many ways. 

By Alexander Sitnikov

In previous blog posts, we looked at how different features of Dagger are implemented under the hood. We refactored and converted the generated code from Java to Kotlin to get a better understanding of it. In this blog post, we cover two more big topics: scopes and subcomponents.

By Alexander Sitnikov

In the previous blog post, we looked at the different types of classes Dagger generates. Converting the generated code from Java to Kotlin with some additional refactoring removes visual noise and helps us understand it better.

By Nate Ebel

GitHub recently announced GitHub CLI; a first-party command line tool for interfacing with GitHub from the command line. With GitHub CLI, developers can check the status of GitHub issues and pull requests, search for a specific issue or PR, create/fork a repo, or create new issues and pull requests right from the command line.

By Nimrod Dayan

One of the projects I was working on recently, which was among the first activity recording apps, had a very complex screen with a lot of user interaction and data (referred to as Workout Summary Screen from now on). Naturally, as you’d expect, it had legacy code and tech, which was a blocker for extending it with new features. A decision was made to rewrite this screen so that it can be easily extended with new features and also get rid of weird bugs.

By Harshitfit

If you are a beginner to Dagger and have just started learning it, then this blog is not meant for you. You can checkout Dagger for Dummies to get a basic idea of what dagger is? But if you have implemented Dagger once or twice in your application then you are good to go.

By Tomerpacific

This seemingly simple UI element has a lot of hidden features. If you have ever developed an application, you probably have used it. An AlertDialog’s main function is to notify users of something that is going to happen that requires their immediate attention and an action to be made on their end. 

By Fernando Raviola

I found coroutines a bit counter-intuitive at first glance, so I figured I would document the unintuitive bits here as a future reference for myself and anyone else interested. I’ll try to keep it short. Let’s say we want to perform an asynchronous operation using Coroutines. To start off really simple, we’ll assume this operation doesn’t even return anything back:

By Jossi Wolf

In our codebase, we use a lot of custom views for reusability — but most of the time, a custom view was overkill. Here’s how we used View Binding to replace some of our custom views.

By Prafull Mishra

While we Android Developers constantly strive to make our apps more efficient under-the-hood, often in this run, we don’t pay much attention to over-the-hood, things that can improvise the app’s look and feel. As a result, we might miss upon the things that are just lying there waiting to be picked up.

By Denis Brandi

A while ago I wrote a post about the Repository Pattern in which, among the other concepts, I explained the importance of model separation and data mapping. After reading the comments on my article I was glad to see readers agreeing on the approach and overcoming the general hate over “extra models” and “annoying mappers”.

By Phellipe Silva

Let’s say you are setting up a pipeline to improve the continuous delivery of your app. During this setup, you need to disable the animations on a target device to run your Espresso tests and see that everything is working fine. Do you remember the ADB commands to disable these animations?

By Iñaki Villar

I would say Remote Cache is one of the top features to optimize the build speed across the Development Team using Gradle as Build System. Today, we have different solutions and resources helping to create, manage and implement Remote Caching.

By Myrick Chow

AlarmManager is a bridge between application and Android system alarm service. It can send a broadcast to your app (which can be completely terminated by user) at a scheduled time and your app can then perform any task accordingly.

By Süleyman Fatih Giriş

We have seen using LiveData & Flow and only Flow in MVVM architecture in Part I and Part II. In this post, we will see how to test LiveData & Coroutines and Flow. We will be solving a common race condition problem between LiveData and Coroutines with TestCoroutineDispatcher. After that, we will see how easy to test the Flow 😎

By Ruslan Myhal

TL;DR — At first I’ve implemented instantiating fragments with FragmentFactory by using pure koin-android dependency. But when I decided to write an article about this, I saw that everything that I wrote is already implemented in Koin and shipped as koin-androidx-fragment dependency ¯\_(ツ)_/¯. So here I will show you how things are implemented under the hood in koin-androidx-fragment.

By Suraj Shah

A definite use-case driven guide to Collections vs Sequences in Kotlin. Kotlin has 2 APIs to perform operations on a list or a collection of data. Namely the Collections API and the Sequences API. Both of these have differences in the way they perform operations on the underlying elements.

By Nikit Bhandari

In this blog post, we will understand how we can use different types of animations in Jetpack Compose using Transition. If you are interested in exploring other components in Jetpack Compose you can check out the series of articles that I have written.

By Jaewoong Eum

In the last post, we found out about the motion systems in the new version of the material design. In this part, we’re going to find about the modern Android development tools and architectures.

By Javier Arroyo

When I started researching about Kotlin Multiplatform, the idea of using Firebase in my Multiplatform projects soon occurred to me. At first, there was no library that could accomplish this, until TouchLab released its implementation to use Firebase and Firestore sharing the business logic code. This library is FirestoreKMP.

By Alexander Sitnikov

Dagger is one of the most complex DI frameworks for Java and Android out there. It comes with compile-time safety and fast runtime but has a steep learning curve and requires a lot of boilerplate code to setup. When using Dagger, our goal is to set it up to generate the code that would solve our DI needs. By understanding the code Dagger generates we can better understand how to configure it properly.

By Yaroslav Berezanskyi

Most of the modern apps rely on a connectivity state in one way on another. We as developers used to utilize the CONNECTIVITY_ACTION broadcast receiver along with NetworkInfo API to get the current network state. And it’s been working like a charm for many years long, but it’s time to say goodbye since both of them have recently become deprecated in favor of NetworkCallback.

By Fabio Collini

Dagger is one of the most polarizing subjects in the Android community, either you love it, or you hate it. Some developers love it and say that it reduces boilerplate code. Other developers have different opinions and say that it’s too complicated and really verbose. So, does it reduce the boilerplate or is it too verbose? As it often happens in software development, the answer is: it depends!

By Duy Pham

When you tap on your app icon, it launches, you feel that it’s slow. Well, it’s slow, what should you do to fasten the startup time? Then you’d google something like “how to speed up android app startup time” or “best practices for android app startup time”. That’s a good way, but all the instructions would come to this fundamental:

By Tomoaki Imai

Recently, I worked on developing an Android app for my company’s product, which we have released an iOS app over a year ago. Since we are using React Native, a lot of code worked without making any change. 

By Gaël Marhic

N26, my current company, has gone through hypergrowth in the last couple of years. As an example, the Android team has gone from 4 to almost 40 engineers. Such growth brought its share of technical challenges like build times and code ownership amongst others.

By Peter-John Welcome

Generally when we think of CI/CD, we think of a build server. This could be a machine that we have locally or could be a cloud provider that lets us build our apps on some virtual machine somewhere in the world.

By Julián Ezequiel Picó

Before we start, I have something to tell you: this will be a journey. I will present a real use case, and together we will develop the requirements step by step while finding different solutions and, of course, problems.

By Duy Pham

We have started refactoring our android project for almost two years with Clean Architecture. Since that time the only topic that has been missing till now is error handling. Sometimes it’s confusing how to propagate errors crossing boundaries between layers.

By Elvina Sh

HI there! We are the Navigine team. For eight years we have been providing integrated positioning mobile technologies that enable advanced indoor navigation and proximity solutions. And in this article, we decided to draw your attention to the scanning of Wi-Fi and Wi-Fi RTT on Android devices.

By Baljeet Singh

In recent times we have seen a number of libraries launched by Google under androidx one of them in camerax which is under heavy development as of now. But some weeks back it had officially jumped into the beta stage. So today we will see how we can use this library to create a very simple camera app.

By Carlos Mota

Once upon a time… there was an issue that was hidden in plain sight! It lived freely for years without no one noticing it. Until one day, during a connectivity problem, he appeared leaving us speechless.

By Rohit Surwase

If you are already aware of basic principles of architecture patterns and MVVM and MVI patterns in detail then skip the basics and jump to MVI + LiveData + ViewModel (or second) section of the article.

By Vasya Drobushkov

One of the important parts of application development is to make it accessible to as many users as possible. This includes people with impaired vision, color blindness, impaired hearing, impaired dexterity, cognitive disabilities, and many other disabilities.
Making an app accessible is challenging but rewarding.

By Jorge Nicolás Nogueiras

We've arrived in the last chapter of this series of posts about SOLID in Android development. Let's find out the power of Dependency Inversion and how to use it in our daily work to create maintainable and robust apps.

By Baljeet Singh

In recent times we have seen a number of apps adopting dark theme. Also as now Android 10+ officially supports dark theme so many devs wanted to implement this feature in their apps, So today we will learn how we can support our apps to use dark Theme using Google material design library.

By MohammadReza

One of the nice things that recently was introduced in the Android world in devSummit19 was the new way of handling back presses in the fragments which always was a bit of pain to implement. Previously if a fragment let’s say a SearchFragment needed to respond to back press events and close the SearchView, we had to go through all the steps as below:

By Dmitry Si

So what’s the problem with NullPointerException in Kotlin? Both Google and JetBrains promote Kotlin as safe & interoperable language, not necessarily emphasizing enough that it’s not intrinsically free from NPEs, in fact, if misused Kotlin code will throw as many KNPEs and similar exceptions. How do we convert old Java code into Kotlin safely then?

By Josef Raska

One of the challenges in the Android world is accessing user interfaces from the application logic. We are taught to keep the logic out of UI code, however we also need to use that UI for things like navigation, permissions or simply interacting with users from a background service.

By Baljeet Singh

Today we will see how to use Retrofit for calling a single API multiple numbers of times and cancelling all previous calls before making a new one. Also, we will see how to use coroutines in action with Retrofit.

By Suraj Shah

Chapter 2: If you’ve somehow landed here directly, would recommend you to check out the Chapter 1 of this 2 chapter series, where we learn about why does Kotlin need an inline keyword for functions. What and how does it work internally. And if you’ve already read it or know about it, hold on to your seat, cause it just couldn’t get more interesting!

By Baljeet Singh

Many of the Android developers who have been working on Online streaming of videos must have faced issues like slow buffering. Especially the ones working on any social platform must have faced similar situations when there is a collection of huge video contents.

By Baljeet Singh

In Android applications sometimes we often need that Activities/Other apps can communicate with each other. For this medium, we can use ‘Bound services’. It is like a server in a client-server architecture where there is several clients requesting something from the server and server responds them back with the required result.

By Denys Soroka

In Sep 2008, Android provided developers with the ability to use GPS location with app users’ permission as part of the first Android 1 (API 1). Millions of apps have been built using location-based services in creative ways since then.

By Ashish Kumar

Many of us have been using coroutines to manage asynchronous taskswhich might have otherwise blocked the main thread and cause our app to freeze.

By Fernando García Álvarez

Android 11 Developer Preview 2 introduced a long-awaited feature: the ability to synchronize the app’s content with the IME (soft keyboard) and system bars as they animate on and offscreen, instead of having the view simply jump on top of the keyboard when it opens.

By William Gouvea

Generate unique ID at Android platform is a recurring theme among developers and it’s very important in order to perform:

By Denis Shilov

TLDR: I have written a simple realisation of logging through Internet. It might be helpful if your client (or, for example, a tester) has a strange bug and you want to see what’s happening on the device in real time

By Vivek Maskara

In this post, I will show you how to read and write an NFC tag on an Android device. We would be using Android’s NFC capabilities to read and write a tag. In a different post, I will illustrate how APDU commands could be used to talk directly with an NFC tag.

By Andre Perkins

There are three things I do every-time I start a codebase that I know that I will be maintaining for the long haul.

By Jaewoong Eum

Google’s material design team shared a new project including the motion system and it is released in the new version of the material design. The motion system is a set of transition patterns that can help implement motion much easier.

By Dmitry Akishin

No doubt, every developer is familiar with the concept of logging. We can log errors, debug messages and other useful information we might need during development. And although logging in Android is pretty easy and straightforward, it still can impose some challenges in a multi-module project. In this post we will look at one way to solve these problems.

By Carlos Daniel

This is a simple guide that shows how to implement within a new android app, bottom navigation view along with navigation component supporting multiple navigation graphs. This is a simple way and one among others but is the one I feel comfortable with and so far, it covers all what I currently need.

By Nikolai Kotchetkov

Shipping pre-built databases along with your application (or downloadable module) may have benefits both for user experience and your backend infrastructure: less server queries, less data transfer, faster response.

By Nikolai Kotchetkov

This is a second part of two-part series on Room-friendly way to pre-package a database and ship it with your APK. This article focuses on application sample and packing all things together. Please take a look at part 1 for database pre-populating introduction.

By Augusto Herbel

When I came to the Android world about two years ago, I didn’t know anything about how things were done. I came from a Java world learned in college and I learned about the Garbage Collector and how this piece of software affects the performance of an application, especially mobile devices where the resources are limited.

By Ricardo Costeira

A few days ago, I worked on a sample project for a tutorial. It was a very simple app: a list of images, where you could click any image to view it in full screen. The code was simple, well structured, did what it had to do, and did it well.

By Navigine

Hi there! We are the Navigine team. For eight years we have been providing integrated positioning mobile technologies that enable advanced indoor navigation and proximity solutions. And in this article, we decided to draw your attention to the scanning of Google Eddystone.

By Christian Schmitz

Support for the Maven Publish plugin has landed in Android Studio 3.6. Unofficial implementations have been around with android-maven-publish or the abandoned android-maven-gradle-plugin. But these tools rely on internal Gradle APIs and thus have to be updated with every new release of the Android Gradle Plugin or Gradle itself.

By Jorge Nicolás Nogueiras

Before starting to put some lights over the fourth principle (The Interface Segregation Principle), let’s make the "recap" of the previous ones. SOLID is the acronym that intends to join several principles about good design practices in software development. We have covered the first three letters of it and today it is the time for ISP.

By Alexey Soshin

Lately I’ve stumbled upon an interesting task — executing a function exactly once, while invoked from multiple coroutines. That is, having:

By Waseef Akhtar

In Part II, you’ve looked in to how to add color states for navigation menu items and adding shapes as background for the menu items. In this post of the series, we’re looking at how to add and style the header view of the NavigationDrawer. But first, here’s how far we’ve come since the original post.

By Mohit Sarveiya

In this article, I will explore how to implement and test polling with Channels and Flow. Prior to reading on, please check out this article for understanding the basics of coroutines.

By Vasya Drobushkov

Testing is a crucial part of whole development. Testing allows you to write programs in a reliable fashion, prevent regressions and have many other goodies. I won’t go through the list of advantages of writing tests in this article though. In testing it is important to have tools which allow you to write reliable tests and also tools which allow you to test your business logic.

By Navigine

Hi there! We are the Navigine team. For eight years we have been providing integrated positioning mobile technologies that enable advanced indoor navigation and proximity solutions. Today we decided to open the doors to our technology and talk about how to scan BLE devices when the Android application is killed and in background mode.

By TJ

The RecyclerView is an extremely flexible and indispensable Android ViewGroup. It unfortunately requires quite a bit of boilerplate to set up; a fully functional RecyclerView asks that you:

By Sergio Belda

CameraX is a Jetpack support library, built to help you make camera app development easier. It provides a consistent and easy-to-use API surface that works across most Android devices.

By David Rawson

Recently there’s been a bit of buzz around over-engineering in Android projects. Unfortunately, one person’s mere engineering is another’s overengineering. And vice versa. It’s like we’re trying to strike a median between Fizz Buzz Enterprise Edition and Big Ball of Mud.

By Andrew Lord

Do you have properties in your Kotlin types that you want to create later after initialization? You may want to avoid making them nullable, avoid using lateinit or delay an expensive set up process to a later point.

By Thomas Middel

RxJava has been around for a few years now and has been one of the main building blocks for many Android projects to date. Kotlin’s Flow is taking a serious shot at contending for this spot, but can it replace RxJava or is it too immature still to fit our needs?

By Andrew Lord

Do you want to upload a file using the clean Retrofit syntax, but aren’t sure how to receive the result as well as the upload progress? We will be using Retrofit to perform the file upload, building an implementation that is able to receive the completion progress at intervals and then complete with the remote API response.

By Vasya Drobushkov

In reactive programming we use streams. Therefore in both RxJava and Kotlin Flow we’ll have to use some streams. Though we’ll encounter some differences if we decide to migrate. In this article we’ll try to get into the stream types which have RxJava and Kotlin Flow and some important differences.

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