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

By Magda Miu

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

By Adam Hurwitz

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

By Vasya Drobushkov

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

By Michael Spitsin

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

By Chirag Kunder

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

By Idan Atsmon

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

By Oleksandr Kucherenko

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

By Daniel Beleza

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

By Andrew Lord

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

By Mark Ng

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

By Danny Preussler

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

By Igor Escodro

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

By Fernando García Álvarez

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

By Patrick Cousins

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

By Fábio Carballo

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

By Lukasz Kalnik

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

By Tam H. Doan

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

By Tam H. Doan

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

By Oleksandr Kucherenko

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

By Mustafa Khaled

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

By Filipe Batista

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

By Mustafa Khaled

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

By Ali Azaz Alam

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

By Husayn Hakeem

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

By Andrew Lord

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

By Magda Miu

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

By Tushar Saha

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

By Johann Blake

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

By Süleyman Fatih Giriş

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

By Nikhil Panju

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

By Vasya Drobushkov

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

By Vasya Drobushkov

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

By Thierry Schellenbach

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

By Roger Taracha

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

By Federico Puy

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

By Zsolt Kocsi

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

By Husayn Hakeem

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

By Vipul Asri

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

By Vasya Drobushkov

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

By Dan Rusu

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

By Carlos Daniel

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

By Alexander Sitnikov

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

By Nikit Bhandari

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

By Igor Malytsky

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

By Süleyman Fatih Giriş

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

By Vasya Drobushkov

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

By Vasya Drobushkov

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

By C'Aira Shields

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

By Javier Arroyo

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

By Kurt Renzo Acosta

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

By Nikit Bhandari

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

By Vladislav Ermolin (Uladzislau Yarmolin)

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

By Rick Busarow

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

By Volodymyr Buberenko

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

By Fred Porciúncula

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

By Nikit Bhandari

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

By Alexander Berezhnoi

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

By Fábio Carballo

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

By Kishan Maurya

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

By Tomáš Mlynarič

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

By Igor Escodro

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

By Adam Hurwitz

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

By Eli Fox

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

By Denis Brandi

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

By Uberto Barbini

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

By Chris Cooper

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

By Miguel Ángel Ruiz López

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

By Elye

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

By Nicola Corti

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

By Joosep Lahe

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

By Tam Doan

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

By André Ramon

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

By Nikit Bhandari

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

By Oleg Osipenko

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

By Shreyas Patil

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

By Nikolai Kotchetkov

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

By Alex Zhukovich

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

By Oleg Osipenko

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

By Mayowa Egbewunmi

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

By Sergii Zhuk

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

By Peter-John Welcome

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

By Peter-John Welcome

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

By Martin Devillers

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

By Marcin Oziemski

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

By Michael Spitsin

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

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

By Danny Preussler

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

By Dmitry Si

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

By Vasya Drobushkov

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

By Stavro Xhardha

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

By Dmytro Danylyk