Android Essence

Managing Multi Table Inserts With Room

Sat, 25 Apr 2026 00:00:00 +0000

A properly relational database may have a type that appears referenced multiple times. In my SpaceNerd playground app, that is the Country object. An Agency has a country, and an Agency is a dependency of a Launch, of a Space Station, and likely more types to come.

How do I enforce that any time I insert an Agency, I also insert the Countries associated with it? That’s what this blog post sets out to explore, and the answer is much simpler than I thought when I started.

Reflecting On A Decade Of Content Creation

Tue, 02 Sep 2025 00:00:00 +0000

Ten years ago today, I published my first blog post. There’s something special about looking back an entire decade at an achievement like that. A chance to reflect on what my life was like then, the motivations that got me into writing, and where I am today as a result.

It has been an honor to learn in public over these last ten years, whether that be here on AndroidEssence, on Twitch, on YouTube, at Droidcon, or the countless number of meetups, hackathons, and other events that have enabled me to connect with the amazing Android community.

Sharing Shared Element Keys

Sun, 24 Aug 2025 00:00:00 +0000

Shared Element Transitions are a fantastic way to add visual flair to your applications. They allow us to animate content between two separate screens. One complication is sharing keys for these components across different screens in a consistent manner. Let’s explore one simple option.

Wrapping Android XR For KMP

Thu, 19 Dec 2024 00:00:00 +0000

Recently I’ve been finding myself immersed in Compose Multiplatform, a way to build cross platform mobile applications with Jetpack Compose UI. Of course, when Android announced their extended reality framework Android XR this week, I initially worried I wouldn’t be able to try it out in my newest side projects.

However, one of the biggest benefits of KMP is how seamless it is to provide platform specific functionality for your shared code. So let’s do that with Android XR.

Interface Naming Conventions

Sun, 05 Feb 2023 00:00:00 +0000

Many engineers will tell you that one of the most complicated responsibilities of our job is naming things. Variables, classes, functions, everything we write requires conscious thought.

A special case among these are interfaces. This is because we not only have to name an interface, but we need to decide how to name the implementations as well.

The Imposter's Guide To Dependency Injection

Mon, 31 Jan 2022 00:00:00 +0000

Dependency Injection is one of the hottest topics in Android and software development in general. It’s also a topic that can provide a lot of anxiety and create imposter syndrome for developers.

In this post, we’ll take incremental steps toward understanding DI, why we need it, and how to implement it inside our applications.

Five Essential Developer Experience Concepts For Android

Fri, 10 Sep 2021 00:00:00 +0000

In the most recent live stream for Tasks Of Affirmation, we looked at creating a good developer experience. It’s important to consider developers at the start of any new project, so we can ensure that over the lifetime of a project anyone who contributes can understand how to contribute, match any guidelines that a team has, and get up and running quickly. We also want to ensure that our codebase maintains a certain quality of formatting and a lack of code smells - and putting these checks in place before you even start prevents them from ever being introduced at all.

Let’s look at five developer experience concepts I consider essential to every project.

Tasks Of Affirmation: A New Twitch Live Stream Series

Thu, 02 Sep 2021 00:00:00 +0000

In the late summer of 2020, I began live streaming on my Twitch channel. We started off by building an Android Study Guide application. The purpose of the application was to build something people would be interested in using, while also taking the opportunity to build an application out in the open.

For a number of reasons, discussed in the latest video, I’ve decided to sunset that project and begin a new live stream series: Tasks Of Affirmation.

Unit Testing Custom Lint Checks

Mon, 01 Mar 2021 00:00:00 +0000

In our previous post we looked at writing a custom lint check to enforce usages of a custom view instead of an Android framework implementation.

In this post, we’ll go over how to unit test such a scenario, and take the opportunity to look at some additional options of unit testing with lint as well.

Enforcing Custom View Usage With Android Lint

Mon, 22 Feb 2021 00:00:00 +0000

Sometimes an Android project will have to implement a custom view that is an extension of an existing Android view. We may do this for style purposes, or to implement additional logic, or any number of customization purposes.

This solution brings a new problem for our codebase - how do we enforce that other developers use our custom view, instead of the Android framework view? We can solve this problem by writing our own Android lint check.

Storing Network Responses With Apollo Normalized Cache

Fri, 05 Feb 2021 00:00:00 +0000

In our previous post we looked at the HTTP cache from Apollo Android for storing network responses. In this post, we look at its counter part, the normalized cache.

Storing Network Responses With Apollo HTTP Cache

Mon, 01 Feb 2021 00:00:00 +0000

Caching is the practice of storing data that we requested previously so we can serve it faster in the future. This creates a better user experience by decreasing loading times. It also has long term benefits like reducing the number of network requests, to save on phone resources or potentially provide offline support. Today, we’re going to discuss how to use the HTTP cache for the Apollo Android SDK.

Comparing Three Dependency Injection Solutions

Sat, 22 Aug 2020 00:00:00 +0000

During a recent live stream on my Twitch channel, we explored three different solutions to dependency injection on Android. A do it yourself approach, Koin, and Dagger Hilt. Let’s revisit them side by side, and look at the nuances between them, so we can determine which solution we want to use in our own applications.

Mastering Room Database Migrations

Thu, 14 May 2020 00:00:00 +0000

In the last post, we demonstrated the different types of database relationships in Room. Next, we’re going to explore another niched concept of Room database management: database migrations. A migration is a way to handle moving from one version of a database to another as users update your application from the play store.

Room Relationship Recap

Mon, 27 Apr 2020 00:00:00 +0000

In this post, we’re going to explore some advanced concepts of the Room Persistence Library. Room is a great tool for storing complex data for your Android applications inside a SQLite database. As you begin to store more data in your applications though, it can be difficult to determine how to organize all of it.

We’re going to demistify database organization, and break down everything you need to know about database relationships in the Room library.

Getting Started With Test Driven Development

Mon, 02 Mar 2020 00:00:00 +0000

One of the many buzzwords thrown around the software devleopment community is Test Driven Development, or TDD. It is one of those phrases that sounds great when you say it - who wouldn’t want to have tests be their first priority when writing code?

However, it’s not always clear what TDD means. Does it mean you write code with testability in mind? Does it mean writing tests first? How can we write tests if we don’t have code to test? This post will answer all of those questions, and teach you how to implement TDD effectively on Android.

Contributing Code Samples To Kotlin Documentation

Mon, 24 Feb 2020 00:00:00 +0000

The Kotlin language used by Android developers all over the world is open source and available on GitHub. This means it’s open for contributions from anyone! It may, of course, feel very intimidating to contribute to a project of that size. Especially for those of us who are new to open source contributions.

The JetBrains team makes this process a lot less scary than it sounds. There are some beginner friendly ways to contribute to the language, and this post will walk you through every step.

MVWTF: Demystifying Architecture Patterns

Fri, 16 Aug 2019 00:00:00 +0000

As an Android developer, one of the questions I constantly see asked within the community is “what architecture pattern should I use?”

This discussion usually leads to a handful of buzzwordy acronyms:

MVC
MVP
MVVM
MVI
MVU?? (We don’t talk about this but apparently it’s the new kid on the block)

This can be really intimidating to new Android devs, as well as seasoned veterans who are constantly questioning if they’re using the right one. Whether you’re trying to decide which one to learn, or wondering if the one you already use is best for you, this post will help lead you to the right decision.

Repository Pattern: Properly Organizing Your Data Layer

Mon, 20 May 2019 00:00:00 +0000

How to properly architect your application is a concern we as developers constantly face. There’s unfortunately no one size fits all answer to it, and sometimes we don’t even know where to begin. I’ve learned along my Android journey that the answer can also vary depending on what portion of your app you’re trying to organize. Of course, you might say, it depends.

When it comes to your data layer, though, there are some really good tips on how to write clean, maintainable code. One of them is the Repository Pattern, and I’d like to provide a quick walk through of what it is and why it’s important.

Unit Testing RxJava Or Coroutine Code With Constructor Injection

Tue, 30 Apr 2019 00:00:00 +0000

Putting aside the long lasting debate right now about whether you should use RxJava or coroutines for your asynchronous code on Android, both camps often hit the same problem. How do I write unit tests for this?

Unit testing asynchronous code is tricky, because we may need to know how to properly test callback APIs, or perhaps we just want things to run instantly and not worry about thread changes. We may also be wondering how to handle not having a “main” thread in a junit test, unlike a connected test. This post will be focusing on handling that last one.

Showing A Fragment For A Result

Fri, 04 Jan 2019 00:00:00 +0000

A number of developers preach a single activity architecture on Android, which is something I’ve been trying to move forward to as well. In the process, though, I ran into one tricky problem. I don’t have something like startActivityResult for fragments. If you’re unfamiliar, startActivityForResult is a method that allows you to launch an activity with a specific request code, and when that activity finishes, your first activity will get a callback in onActivityResult and can do stuff with it.

This post is going to walk through how we can achieve that same affect using fragments.

Building An Application With MVVM

Sun, 28 Oct 2018 00:00:00 +0000

This is the second post in what will be an ongoing series to demonstrate a few different architecture patterns that are used for Android development. You can find the code for each of them, often appearing before the blog posts, by following this repo. Give it a star!

In our previous post we discussed the MVP architecture for building an app. This time, we’re going to check out MVVM.

Building An Application With MVP

Sat, 20 Oct 2018 00:00:00 +0000

This is the first post in what will be an ongoing series to demonstrate a few different architecture patterns that are used for Android development. You can find the code for each of them, often appearing before the blog posts, by following this repo. Give it a star!

The first architecture pattern we’re going to walk through is MVP.

Breaking The Buzzwords Barrier Part 3: ViewModel

Fri, 01 Jun 2018 00:00:00 +0000

So far we’ve covered four big buzzwords used in our application:

Model-View-ViewModel
Room
RxJava
Repository Pattern

Now, we should circle back to the beginning. Following our diagram outlined in the previous parts, the next component we can begin to work on is our AccountViewModel:

Naturally, this may bring up some confusion. We already discussed ViewModels in part 1. Well, depending on context, we may not be referring to the same thing.

Breaking The Buzzwords Barrier Part 2: Rx, Room, and Repository

Thu, 31 May 2018 00:00:00 +0000

In part 1 we discussed how we were going to architect the various components of our application. Now it’s time to build them. To understand what we should build first, we should revisit the diagram:

I would start with three spots:

The account
The database
The repository

A good rule of thumb to remember this, is that these nodes don’t depend on anything else just yet (well, the repository depends on the database, but that was included). I can’t build my ViewModel until I have my repository, and so on.

Let’s start with persistence.

Breaking The Buzzwords Barrier

Wed, 30 May 2018 00:00:00 +0000

MVVM? Retrofit? RxJava? Data binding? Architecture components? LiveData? Kotlin?

Right now, these buzzwords are heard all over the Android community. Every podcast/blog/conference talk is referencing one of these. Which can be very intimidating to new developers. Which one should I learn first? Do I need all of them? What are these things even used for?

The purpose of this series is to break all of that down, and show that none of these buzzwords are truly that scary. We’ll go over an application I’ve published called CashCaretaker which is a simple finance tracker with all data stored locally on the device. It uses all of the buzzwords I mentioned further up, and we can go through them step by step.

You can checkout a simple gif of the project here:

Breaking The Buzzwords Barrier Part 1: MVVM

Wed, 30 May 2018 00:00:00 +0000

When you’re starting out with Android development, and even as an expert, you will hear about a lot of different architecture patterns. Anything from:

Model-View-Controller
Model-View-Presenter
Model-View-ViewModel
Model-View-Intent

It can be extremely hard to know which one to pick, what their differences are, and why they matter. I will tell you that even with my three years of Android experience at the point of writing this, I have trouble answering the first two questions. I can, however, explain why these architecture patterns matter - and it boils down to the idea of separation of concerns.

Fingerprint Authentication Tutorial

Tue, 02 Jan 2018 00:00:00 +0000

When Android released version 6.0 Marshmallow (yes, a little outdated at this point), a whole slew of new developer APIs came with it. One that I’ve personally enjoyed as a consumer is fingerprint authentication. I skimmed over the official docs, and even through their Fingerprint Dialog Sample but had a difficult time following what was going on.

Eventually, though, I was able to recreate the flow. This post is going to be a step by step guide to integrating your own fingerprint dialog in your Android application.

Developing And Publishing Android Libraries

Thu, 19 Oct 2017 00:00:00 +0000

Third party libraries are a huge part of mobile app development. Popular tools like Retrofit, RxJava, Picasso, and many others prevent Android developers from reinventing the wheel everytime we need to do something over the network, asynchronously, or loading images.

However, developing and publishing these libraries can be intimidating to many people. I think this occurs for a number of reasons - worry about keeping up with maintenance, being outshined, or sometimes thinking no one would use your code. I have many thoughts on those ideas, but will save them for another blog post. In this one, we’ll just go over a step by step guide to creating and publishing a library to JCenter.

App Review: Digilux

Mon, 09 Oct 2017 00:00:00 +0000

DISCLAIMER: This application no longer exists in Google Play, but the post has been kept for posterity.

Controlling the brightness of your phone can be a hassle. Currently we’re stuck with the two step process - swipe down on the notification drawer, and then deal with the slider trying to get it just right. However, with the release of Android Oreo and a new fingerprint gesture API, a new solution was born. Enter DigiLux.

Leveraging The Robot Pattern For Espresso Tests

Tue, 04 Jul 2017 00:00:00 +0000

Espresso is a testing framework for Android that allows developers to write automated tests for their applications. The benefit of automated testing is that you can write a test plan, and simply hit run and have all of the important features in your app tested effortlessly, and arguably more consistent and thorough than manual testing. There is no doubt that it is a lot faster.

However, one of the lesser known development patterns for automated testing is the robot pattern, which makes writing tests much easier while providing a painless way to update tests whenever your app changes. Let’s take a deeper dive into what makes the robot pattern so powerful, and how to implement it in your next test suite.

Understanding Nullability In Kotlin

Wed, 28 Jun 2017 00:00:00 +0000

Every Java programmer has faced the dreaded NullPointerException at some point in their life. Sometimes it’s your fault, sometimes it’s a pesky race condition. Regardless, it’s a head ache and generally leads to a ton of if (myVariable != null) { } conditions all over your code. However, the latest craze Kotlin can help with that too. Kotlin introduced null safety into its type system, with the potential of removing all NPEs.

This post is both going to review the official docs linked above, as well as provide some common tips and tricks to work with the nullability - something that is new in this language for many Java programmers.

Getting Started With Room Persistence Library

Sat, 10 Jun 2017 00:00:00 +0000

This year at Google I/O, the Android team announced Android Architecture Components a combination of new, helpful libraries for Android development. One that particularly interested me was the Room Persistence Library, which is an abstraction layer of SQLite designed to make database access and creation a lot easier. Right off the bat it reminded me of Realm, which I learned about at Droidcon NYC and really admired, so I decided to dive in and build a todo list using Room & RxJava.

How To Build A Todo List In Kotlin Part 1: Creating A New Project

Sun, 21 May 2017 00:00:00 +0000

This blog post is going to discuss creating a project from scratch in Kotlin. We will build a sample Todo List application that will not be very complicated, but covers enough to show the benefits of Kotlin. Part 1 will discuss creating a new project and configuring Kotlin. If you’re familiar with that, copy the MainActivity.kt code and skip to part 2 to begin building the app.

This tutorial assumes a basic knowledge of programming, and some familiarity with Android. If you have any questions please leave them in the comments, and I will udpate these posts with a deeper explanation.

How To Build A Todo List In Kotlin Part 2: Implementing A RecyclerView

Sun, 21 May 2017 00:00:00 +0000

Following up on part 2 which demonstrates how to create your Android app and configure Kotlin, we’ll begin building the heart and soul of a Todo List application - the list!

How To Build A Todo List In Kotlin Part 3: Adding Items

Sun, 21 May 2017 00:00:00 +0000

Following parts 1 and 2 you should have a working Android app in Kotlin that displays a list of Tasks to be completed and lets you mark them as complete. This segment is going to show you how to implement support for adding new items.

How To Build A Todo List In Kotlin Part 4: Storing Items

Sun, 21 May 2017 00:00:00 +0000

If you’ve been following along with parts 1-3, you now have an (almost) working todo list application. The only thing we are missing is persisting the data. Running your Android app now and rotating your screen will show you that the items you add won’t persist, and disappear anytime an activity is killed and recreated. This post will show you how to write the list to a text file and read from it.

Maintain Library Versions ACross Modules

Fri, 05 May 2017 00:00:00 +0000

It is tough enough maintaing your app by updating the support library version numbers every time a new version is out, let alone factoring in any other third party libraries you may use. This is especially painful if you have multiple modules, as you have to update the version in each build.gradle file. Thankfully, we can make use of the project level gradle file to make this more maintainable.

Creating Android App Shortcuts

Fri, 14 Apr 2017 00:00:00 +0000

Android app shortcuts are a special feature added in Android 7.1 (API 25). Shortcuts are special actions that appear when you long press on a launcher icon, that will trigger a specified intent. With this post you will learn how to create both static and dynamic app shortcuts. The only pre-requisite is that your app is targeting API 25 or greater.

Static Shortcuts

Static app shortcuts are shortcuts that are defined via XML. This means they are created at compile time, and will be consistent as long as your app is on the user’s device. Common use cases for this would be to launch a regularly used activity in your app that is not the launcher activity.

PinchZoomTextView Library Released

Sun, 27 Nov 2016 00:00:00 +0000

I was recently asked if there was a way to increase/decrease the font size of a TextView by pinching on it, just as you can with many iamges. Well, it turns out that’s quite possible!

All you have to do is override the onTouchEvent() method of your view, which is exactly what I do in my latest library, which allows you to pinch your screen to zoom in and out of a TextView. Check out the sample gif below:

Getting Started With Retrofit In Android

Thu, 13 Oct 2016 00:00:00 +0000

As a new or intermediate Android developer, getting started with Retrofit, a popular HTTP client, can seem pretty daunting. However, using this library is not as scary as it sounds. Here are four easy steps to creating your first Retrofit application!

RecyclerViewUtils Library Released

Wed, 31 Aug 2016 00:00:00 +0000

Recently, I became tired of writing the same old tedious code for every single RecyclerView and Adpater class I used, that all did the same thing, so I extrapolated all of it into a personal library.

The RecyclerViewUtils library helps make everyone’s life a little easier with a CoreViewHolder and CoreAdapter class, described below.

MaterialSearchView Library

Fri, 22 Apr 2016 00:00:00 +0000

Android has a built in SearchView component but it doesn’t feel much like Material Design. This has even been asked on StackOverflow because developers are having trouble recreating the same MaterialSearchView that appears in many of Google’s applications. However, thanks to one of my good friends Maurício, you can now implement this great component in your own projects!

RichTextView Library Released

Sun, 03 Apr 2016 00:00:00 +0000

As a form of ultimate procrastination this weekend, I decided to spend the last two days developing a RichTextView library.

This weekend I built the RichTextView (the naming convention comes from the RichTextBox C# class) which allows the user to format different parts ofa. TextView in different ways. For example, if I wanted to display a string but only bold a portion of it, I could achieve that with this class.

Designing User Interfaces For Android Wear Part 2: Cards

Tue, 26 Jan 2016 00:00:00 +0000

User interface for Android Wear have all the same components as a phone’s UI, they just appear a little differently. In this post we’re going to talk about Cards. You’ve most likely seen these in the Google now app, among other Material Design apps. Cards are great because they are a component that is able to provide a consistent look across multiple platforms.

We will consider this post as a deeper dive into an existing tutorial in the Android docs, but as that one states the Cards discussed here are not the same as the Cards that appear as notifications on Android Wear. See the link to better understand this distinction. Let’s go over some of the relevant classes, and we’ll discuss their differences and how to implement them.

Designing User Interfaces For Android Wear Part 1: Lists

Fri, 01 Jan 2016 00:00:00 +0000

Rising in popularity after the latest Google I/O, Android Wear is a game changer for mobile development. Wearable technology has brought benefits from a quicker access to information to a more accurate monitoring of our physical health. Developing for this platform allows you to tap into those features that are not as readily available on mobile handhelds as well as offer a more immersive experience of your product by making it available on wearable devices.

As always, the documentation will offer the most thorough insight into what is available, but I’d like to discuss how the UI development differs and how you can get started.

Material Design Specs Library

Sun, 13 Dec 2015 00:00:00 +0000

Along with the RecyclerViewCursorAdapter library that was released earlier this week, I have now released my second open source Android library. In collaboration with my good friend Maurício, we have built a library for including the Material Design Specs in your Android application. Currently, the library has the full color palette along with some helper methods, and some elevation resources to give the proper elevation to your components. The source code, as well as instructions for including the library can be found on GitHub, so go there to check it out and give us a star!

RecyclerViewCursorAdapter Library

Thu, 10 Dec 2015 00:00:00 +0000

Today I released my first library which is for a RecyclerviewCursorAdapter.

Using a ListView to display database data becomes a lot easier when you use a CursorAdapter combined with a CursorLoader to display data from your ContentProvider. The main benefit of CursorLoader is explained in the docs:

How To Make An Android UI Part 2: Java Code

Wed, 02 Dec 2015 00:00:00 +0000

After reading part one which discusses what Views and ViewGroups are, as well as how to create them in XML, the next step is to incorporate them into your Android application. How you use the UI you wrote depends on what it’s used for. Let’s break down some of the key things:

How To Make An Android UI Part 1: XML And Views

Sun, 08 Nov 2015 00:00:00 +0000

Many of the posts on this site so far deal with nuanced tricks such as RecyclerView swiping/drag and drops, and often make the assumption that the reader has already worked with the Android UI. This post is going to break it down for the beginners, teaching you the fundamentals of mobile UI development and where you can pick up on skills to move forward.

Creating A Material Design Navigation Drawer

Sun, 11 Oct 2015 00:00:00 +0000

Top 5 Color Scheme Tools

Mon, 21 Sep 2015 00:00:00 +0000

When it comes to making an app, some of the biggest struggles developers face is outside of the code itself. What should I name the app? Who is my target audience? Or the one I struggle with the most: what colors should I use in my Android application?

This last question does not have one right or wrong answer. For that reason, it is one of the hardest questions to answer. Thankfully, there are many tools out there to help you determine your applications color scheme, and these are my five favorites.

How To Use The RecyclerView Adapter

Thu, 17 Sep 2015 00:00:00 +0000

The RecyclerView.Adapter class is used to bind a dataset to a RecyclerView to be displayed to a user. As I explained in another post, RecyclerView Vs ListView, the RecyclerView.Adapter forces the use of the ViewHolder pattern, which may be hard to understand when switching to a RecyclerView from a ListView. In this short post I am going to reference my MovieAdapter class from my Swipe-To-Dismiss example, and break it down to explain the required implementations and how to use the RecyclerView adapter.

Using Elevation In Android Applications

Tue, 15 Sep 2015 00:00:00 +0000

layout: post author: adam title: Using Elevation In Android Applications description: Discussion of some of the best ways to handle elevation in your Android application. modified: 2015-09-15 published: true tags: [elevation, material design] categories: [android]

The backbone of Material Design is to design your user interface in a way that is simple and intuitive for users, in the same way we use our intuition with real life materials. One of the many ways this is achieved is through the use of elevation in Android UI components, demonstrated here:

Drag And Drop RecyclerView Items

Wed, 09 Sep 2015 00:00:00 +0000

Before continuing this post, I recommend that you read my previous one on Swipe To Dismiss RecyclerView Items as this will build upon the ItemTouchHelper class discussed there. Once you’ve done that, come back to this short post and learn how to drag and drop RecyclerView items like this:

Swipe To Dismiss RecyclerView Items

Wed, 09 Sep 2015 00:00:00 +0000

In my last post I broke down the differences between the RecyclerView and a ListView. One of the benefits of the RecyclerView that I touched on was the ItemTouchHelper. This class is used to handle the Swipe-To-Dismiss and Drag-N-Drop behaviors of a RecyclerView. In this post I am going to teach you how to swipe to dismiss RecyclerView items using the sample application seen here:

RecyclerView Vs ListView

Mon, 07 Sep 2015 00:00:00 +0000

Introduced in API 21 (Android 5.0), along with other MaterialDesign components, was the RecyclerView widget. This widget is a more flexible version of the ListView, which to many developers was their go-to AdapterView for applications.

It is important to note here, though, that the RecyclerView does not extend from the AdapterView class. Intuitively, it sounds like it would as an AdapterView is defined in the docs as:

An AdapterView is a view whose children are determined by an Adapter.

In the AdapterView design, the Adapter is the component responsible for mapping content from the data source to the Views of an AdapterView which are displayed to the user. Through the use of Adapters and LayoutManagers, the RecyclerView is able to break up responsibilities of the layout and create opportunities for more unique designs, which are explained in further detail later. Before we discuss the opportunities given to us by the RecyclerView, let’s go over some of the benefits of the ListView (in comparison to the RecyclerView), and where it fell short.

SQLiteOpenHelper and the Singleton Pattern

Sun, 06 Sep 2015 00:00:00 +0000

The singleton design pattern is a design that limits the instantiation of a class to a single object. To quote Wikipedia:

This is useful when exactly one object is needed to coordinate actions across the system.

A great example of this is the SQLiteOpenHelper, or any other data source object. Using more than one datasource to talk to an SQLite database on Android creates the opportunity for leaks in your SQLite connection, which we will discuss later. First, let’s talk about the proper way to use the SQLiteOpenHelper and the singleton pattern. This tutorial assumes you have already created the open helper class. If you do not have any experience with SQLite databases for Android, I recommend Lars Vogel’s tutorial.

Hide The FloatingActionButton When Scrolling A RecyclerView

Wed, 02 Sep 2015 00:00:00 +0000

One of my favorite components introduced with Material Design is the FloatingActionButton (FAB). These buttons are great for emphasizing the primary action of an Activity, but quickly become a nuisance when displayed over a RecyclerView as they may block the bottom list item. To avoid this, we can hide the FloatingActionButton when scrolling a RecyclerView.

In today’s tutorial we will only be hiding the FAB when the RecyclerView is scrolled upward, and it will reappear on the next down scroll as shown here:

About

Mon, 01 Jan 0001 00:00:00 +0000

About Android Essence

Android Essence was first launched on September 2, 2015 by Adam McNeilly. It started off with Adam just wanting to share everything he’d learned about Android development with the community. You can find all sorts of historical context from these posts, like understanding a RecyclerView vs ListView, or even working with a navigation drawer (what a throwback). The problem is that there wasn’t always a rhyme or reason to the posts.