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 StefMa

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

By Oliver Spryn

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

By Piotr Ślesarew

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

By Adam Hurwitz

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

By Dmitry Si

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

By Zohaib A.

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

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

By Arif Nadeem

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

By Mikhail Kulaha

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

By Łukasz Marczak

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

By Gabor Varadi

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

By Danny Preussler

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

By TJ

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

By Siva Ganesh Kantamani

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

By Alexander Berezhnoi

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

By Stavro Xhardha

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

By Uberto Barbini

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

By TJ

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

By Philippe Boisney

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

By Vladimir Ivanov

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

By Eli Fox

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

By Denis Brandi

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

By Uberto Barbini

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

By Chris Cooper

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

By Miguel Ángel Ruiz López

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

By Elye

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

By Nicola Corti

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

By Joosep Lahe

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

By Tam Doan

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

By André Ramon

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

By Nikit Bhandari

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

By Oleg Osipenko

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

By Shreyas Patil

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

By Nikolai Kotchetkov

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

By Alex Zhukovich

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

By Oleg Osipenko

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

By Mayowa Egbewunmi

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

By Sergii Zhuk

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

By Peter-John Welcome

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

By Peter-John Welcome

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

By Martin Devillers

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

By Marcin Oziemski

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

By Michael Spitsin

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

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

By Danny Preussler

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

By Dmitry Si

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

By Vasya Drobushkov

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

By Stavro Xhardha

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

By Dmytro Danylyk

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

By Dmytro Danylyk

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

By David Debre

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

By Serap Bercin

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

By Paolo Rotolo

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

By Alex Zhukovich

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

By Domenico Rotolo

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

By Pamela Hill

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

By Diva Vikash

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

By Saurabh Arora

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

By Altuğ Keçiciler

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

By Ivan Shafran

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

By Peter Törnhult

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

By Idan Atsmon

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

By Elye

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

By Ian Alexander

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

By Saurabh Arora

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

By Thomas Sunderland

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

By Caer Mert CEYHAN

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

By Michael Spitsin

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

By Kirill Rozov

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

By Fred Porciúncula

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

By Chan Myae Aung

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

By Kirill Rozov

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

By Lin Min Phyo

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

By Suchi Bansal

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

By Uberto Barbini

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

By Tam H. Doan

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

By Filipe Batista

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

By Nikit Bhandari

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

By Matt Dupree

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

By Abhilash Das

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

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

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

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

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

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

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

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

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

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

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

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

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

By Martin Bonnin

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

By Joshua Schriever

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

By Husayn Hakeem

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

By Prasad Pulikal

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

By Carlos Palacin Rubio

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

By Vasya Drobushkov

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

By TJ

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

By Patrick Cousins

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

By Josias Sena

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

By Kirill Rozov

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

By Dmitry Akishin

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

By Fernando García Álvarez

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

By Mikhail Kulaha

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

By Nikit Bhandari

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

By Kishan Maurya

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

By Vasya Drobushkov

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

By Zsolt Kocsi

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

By Abhilash Das

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

By Gabor Varadi

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

By Rick Busarow

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

By Prasad Pulikal

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

By Suchi Bansal

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

By Facundo Rodríguez Arceri

Last week I was working on a feature that syncs data between phone and backend. That sync mechanism is triggered under certain conditions and we needed a way to bypass those conditions and force the sync when enabling some preference in debug mode. Leaving aside the details, the resulting code was something like the following:

By Nikit Bhandari

With Jetpack Compose’s “0.1.0-dev05" release, a new component called AdapterList was released. In this blog post we will be exploring this component.

By Clinton Teegarden

Recently, I was discussing Model-View-ViewModel (MVVM) & Google’s Architecture Components with a colleague of mine. One seemingly trivial task that came up in discussion is not all that obvious on the surface — Navigation and Event handling.

By Michael Spitsin

Sometimes we need to use delay. To postpone some handling. To hide the keyboard, because otherwise, it will not work for some magical reason. To scroll to the new position of Recycler’s view list, when we start submitting a new one.

By Waseef Akhtar

The Navigation is a powerful component in Android Development which provide easy access to destinations in your app. But 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 Vasya Drobushkov

Throttling is also one of the essential features of reactive programming. Streams might emit more values than we’re expecting to receive, so ability to limit number of events in a stream is very important.