Wednesday, November 22, 2017

Using Android Architecture Components: Lifecycles and SQLite made easy

Before Google I/O 2017, Google avoided recommending any particular architecture for Android development. You could use Model View Presenter (MVP), Model View Controller (MVC), Model-View-ViewModel (MVVM), some other pattern, or even no pattern at all.

With the release of the Android Architecture Components project, we finally have an official recommendation for Android Application Architecture, and all the components we need to implement it.

The Android Architecture Components project spans a number of libraries, but since Room and Lifecycles recently saw their first stable release, I’ll focus on how to set up and use both of these production-ready libraries.

By the end of this tutorial, you should know how to avoid memory leaks and application crashes by creating components that are capable of managing their own lifecycles, and how to store data locally in SQLite using much less boilerplate code.

>> An SQLite primer for Android app developers

Creating lifecycle-aware components

Most Android components have a lifecycle associated with them. You used to be responsible for managing your application’s lifecycle, which wasn’t always easy, especially if your application featured multiple asynchronous calls happening simultaneously.

Failing to manage application lifecycles correctly can result in all kinds of issues, ranging from memory leaks, to your application losing the user’s progress, and even outright application crashes.

Even if you managed the lifecycle correctly, implementing all of that lifecycle-dependent code in your lifecycle methods (such as onStart and onStop) could make them bloated and complex. This makes methods difficult to read, maintain, and test.

The Lifecycles library offers a new approach to lifecycle management, by providing all the classes and interfaces needed to create lifecycle-aware components that adjust their behavior automatically, and even perform different actions in response to lifecycle events.

As of Support Library 26.1.0, Fragments and Activities have a Lifecycle object attached to them, which lets them broadcast their lifecycle state to other components within your application. For example, if an Activity features video content, then you can use this new lifecycle awareness to detect and pause the video automatically whenever the Activity loses focus, and restart it as soon as your application regains the foreground.

Since this process is automated, Lifecycles helps you avoid many problems caused by lifecycle mismanagement. Since you’re not cramming all of that lifecycle-dependent code into your lifecycle methods, your code is going to be much more organized, so it’ll be easier to read, maintain, and test.

To use the Lifecycles library, you need to add the following to your module-level build.gradle file:

dependencies { implementation "android.arch.lifecycle:runtime:1.0.3" annotationProcessor "android.arch.lifecycle:compiler:1.0.0"

If you want to use Java 8.0 with the Lifecycles library, then you’ll also need to add the following:

implementation "android.arch.lifecycle:common-java8:1.0.0"

The Lifecycles library introduces the following components:

  • Lifecycle – An abstract class that has an Android Lifecycle attached to it. Objects can observe this state and act accordingly.

  • LifecycleOwner – An interface that’s implemented by objects with a Lifecycle. Fragments and Activities already implement the LifecycleOwner interface (in Support Library 26.1.0+), and are therefore LifecycleOwners by default. You can observe LifecycleOwners— and any class that extends a LifecycleOwner— using a LifecycleObsever.

  • LifecycleObserver – LifecycleObserver receives updates about LifecycleOwner events. Prior to the Lifecycles library, you could only react to methods that were triggered by lifecycle events, like onCreate and onDestroy, but now you can create methods that are triggered by changes in a LifecycleOwner’s state. You can make a method lifecycle-aware by adding the @OnLifecycleEvent annotation.

  • Observer – An Observer receives an update whenever their assigned LifecycleOwner enters a new lifecycle state. An Observer that’s assigned to an Activity will be notified when this Activity enters a paused state, and again when it enters a resumed state. You add an Observer to a lifecycle, using lifecycle.addObserver(this).

The @OnLifecycleEvent annotation can react to the following lifecycle events:






  • ON_STOP .

  • ON_ANY.

ON_ANY is triggered by any lifecycle event. If you use Lifecycle.Event.ON_ANY, then the method should expect a LifecycleOwner and Lifecycle.Event argument.

Let’s look at how you’d create a LifecycleObserver that responds to changes in an Activity’s state. In the following code, we’re printing a message to Android Studio’s Logcat whenever the associated LifecycleOwner (MainActivity) enters a started or stopped state:

import; import android.os.Bundle; import android.arch.lifecycle.Lifecycle; import android.arch.lifecycle.LifecycleObserver; import android.util.Log; import android.arch.lifecycle.OnLifecycleEvent; public class MainActivity extends AppCompatActivity private static final String TAG = "MainActivity"; @Override protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); //Associate the LifecycleOwner with the LifecycleObserver, using getLifecycle().addObserver// getLifecycle().addObserver(new Observer()); //Create an Observer that implements the LifecycleObserver interface// public class Observer implements LifecycleObserver //Use @OnLifecycleEvent to listen for different lifecycle events// @OnLifecycleEvent(Lifecycle.Event.ON_START) public void onStart() Log.e(TAG, "ON_START"); @OnLifecycleEvent(Lifecycle.Event.ON_STOP) public void onStop() Log.e(TAG, "ON_STOP");   

You can also handle multiple lifecycle events within the same method:

@OnLifecycleEvent(ON_STOP, ON_START)

If your project already has methods that handle lifecycle events, you can add the @OnLifecycleEvent annotation to these existing methods, rather than re-writing your current implementation.

Performing operations based on the Lifecycle state

You’ll usually only want to perform an operation when a Lifecycle is in a certain state.

For example, if you attempt to perform a FragmentTransaction after an Activity state has been saved, then the FragmentManager is going to throw an exception. By using getState.isAtLeast, you can ensure this operation only happens when the Lifecycle is in a compatible state:

public void startFragmentTransaction() if (lifecycle.getState.isAtLeast(STARTED)) //Perform the transaction// 

The isAtLeast method can check for the following Lifecycle states:






You can also retrieve the current lifecycle state by calling getCurrentState().

LiveData: Keep track of changing data

The Lifecycles library also provides the foundation for additional Android Architecture Components, including LiveData, which you can use alongside the Room data persistence library.

LiveData is an observable wrapper that can hold any data, including Lists. Once a LiveData has a value, it’ll notify its assigned Observers whenever that value changes.

However, unlike a regular Observable, LiveData is lifecycle-aware, so it only updates Observers that are in an “active” state (i.e STARTED or RESUMED). If the LifecycleOwner reaches a Lifecycle.State.DESTROYED state, then the LiveData will remove the Observer automatically. This lifecycle-awareness helps you avoid the crashes and errors that can occur if you try to update a stopped Activity or Fragment.

Whenever a component enters the STARTED state, it automatically receives the most recent value from the LiveData object it’s observing. If an Activity or Fragment is resumed, or recreated as part of a configuration change, then it’ll receive the latest data.

To use the LiveData component in your project, you’ll need to add the following to your module-level build.gradle file:

implementation "android.arch.lifecycle:extensions:1.0.0"

Easier data storage with Room

If your app handles a significant amount of structured data, you can often improve the user experience by caching some of this data locally. If you persist all of your app’s most important data then users will be able to continue using your application, even when they don’t have an internet connection.

While Android has supported the SQLite data persistence solution since version 1.0, the built-in APIs are fairly low-level and implementing them requires a significant amount of time, effort, and boilerplate code. There’s also no compile-time verification of raw SQL queries, and if the data changes then you’ll need to manually update your SQL queries to reflect these changes, which can be time-consuming and error-prone.

Room is an SQLite mapping library which aims to lower the barrier to using SQLite on Android. Room abstracts some of the underlying implementation details of creating and managing an SQLite database and lets you query data without having to use Cursors or Loaders. Room also provides compile-time validation of queries and entities, and forces you to perform database operations on a background thread, so you don’t inadvertently wind up blocking Android’s all-important main UI thread.

To use Room, add the following to your project’s module-level build.gradle file:

compile "" annotationProcessor ""

In Room, operations such as Insert, Update and Delete are annotated, which is why we need to add the annotation processor as a project dependency.

There are three major Room components:

1. Database

The @Database class provides the bridge between your application and SQLite.

Your @Database class must be an abstract class that extends RoomDatabase, which defines tables present in your database, provides Data Access Objects (DAO) classes, and includes a list of entities associated with the database.

//List the entities contained in your database. Separate multiple entities with a comma// @Database(entities = List.class, version = 1) //Define an abstract class that extends RoomDatabase// public abstract class MyDatabase extends RoomDatabase //Declare your DAO(s) as abstract methods// public abstract ItemDao itemDao(); 

You can acquire an instance of Database by calling Room.databaseBuilder() or Room.inMemoryDatabaseBuilder().

2. Entity

Room creates a table for each class that you annotate with @Entity, where each field corresponds to a column in the table. Entity classes are usually small model classes that don’t contain any logic.

Room can only persist fields it has access to, so you either need to make a field public, or provide getter and setter methods. Each entity also needs to define at least one field as a primary key. Even if there’s only a single field, you’ll still need to annotate that field with @PrimaryKey.

@Entity //Unless we specify otherwise, the table name will be List// public class List { @PrimaryKey //The column name will be id// private int id; private String item; public String getItem() return item; public void setItem(String item) this.item = item; 

Room uses the class name as the database table name, unless you override it using the tableName property:

@Entity(tableName = "list")

Room also derives the column name from the field name, unless you explicitly define the column name using the @ColumnInfo(name = “column_name”) annotation, for example:

@ColumnInfo(name = "productName")

Room creates a column for each field that’s defined in the entity. If there’s a field you don’t want to persist, then you’ll need to annotate it with @Ignore.

@Entity public class List ... ... ... @Ignore Bitmap image; 

Even though most object-relational mapping libraries let you map relationships from a database to the respective object model, Room doesn’t allow object references. The reasoning behind this restriction is that this type of lazy loading typically occurs on Android’s main UI thread, which can result in unresponsive user interfaces and application crashes. Instead, you’ll need to explicitly request the data your app requires.

3. DAO

You access your data via Data Access Objects (DAO), which can either be an interface or an abstract class, but must contain all the methods you want to use in your database queries.

These annotated methods generate the corresponding SQL at compile time, reducing the amount of boilerplate you need to write and maintain.

There’s several convenience queries you can use with DAOs, including:

  • @Insert. When you annotate a DAO method with @Insert, Room generates an implementation inserting all entries into the database in a single transaction.

  • @Update. Modifies entities in the database.

  • @Delete. Removes entities from the database.

  • @Query. This is the main annotation you’ll use in your DAO classes and it’s how you’ll perform all your read/write operations.

The following DAO interface contains various operations that we can perform on our table:

@Dao public interface ItemDao //We don’t need to write all that Cursor related code; instead, define queries using annotation// @Query("SELECT * FROM List") List fetchAllData(); @Update void update(List list); @Delete void delete(List list); 

Each @Query method is checked against the table schemas at compile time. If there’s a problem with a query, you’ll get a compilation error rather than a runtime failure.

When performing queries, you’ll often want your application to update automatically when the data changes. You can achieve this by using Room in combination with LiveData – specifically, by using a return value of type LiveData in your query method. Room will then generate all the code necessary to update the LiveData when the database is updated.

@Query("SELECT * FROM List") LiveData> fetchAllData();

Room and RxJava

If you’re using the RxJava library in your project,  you can create Room queries that return a backpressure-aware Flowable. Flowable is a new addition to RxJava 2.0 that helps you avoid the issue of a source Observable emitting items too quickly for the downstream Observer to process. This can result in a backlog of unconsumed, memory-hogging items.

To use RxJava with Room, you’ll need to add the following dependency to your module-level build.gradle file:

implementation ""

If you’re interested in learning more about using RxJava 2.0 in combination with the Room library, then Google has published a Room and RxJava Sample app.

Wrapping up

Even though Room is Google’s recommended approach for working with databases, Android still supports direct database access using SQLite, so you don’t need to switch to Room.

Are you happy with Android’s default SQLite implementation? Will you be migrating to Room? Let us know in the comments!

Tuesday, November 21, 2017

Best Apple Watch Skins

The best Apple Watch skins let you transform the look of your Apple Watch without upgrading or adding any bulk. Apple only offers a limited number of Apple Watch colors, but you can buy an inexpensive skin to dress up the look of your Apple Watch by changing more than just the band.

While there are not as many options as there are for iPhone 7 skins and iPhone 8 skins, but it is a nice way to change the look of your Apple Watch without adding any bulk with a case. It’s also a handy way of keeping your watch free from scratches if you find yourself wearing it in a tough environment, but you can’t put a case on it.

One of the best parts about these Apple Watch skins is that you will spend less than $10 for most of these options, so even if you decide you want to change colors down the line, you’re not out much money. All of these skins come off with no residue, so you can remove it when you get ready to upgrade and be ready to go.

Make sure you order for the Apple Watch model and the Apple Watch size that you own, since there are some slight variations.

SlickWraps Apple Watch Skins

<figcaption class=" wp-caption-text/>The best Apple Watch skins with the most color and texture options are from SlickWraps.

SlickWraps will wrap just about anything, and they offer the widest range of Apple Watch skins and covers. There are six collections that you can choose from and you can also get a screen protector from SlickWraps, but I don’t feel the need to put a screen protector on the watch. Here are the collections, some of which are only available on the newest Apple Watch 3;

  • Carbon

  • Metal

  • Wood

  • Leather

  • Color

  • Glitz

  • Stone – Series 3 Only

  • Camo – Series 3 Only

  • Hemp – Series 3 Only

Each of these offers multiple color options and various textures. The Apple Watch skin isn’t just a new color, it can change the feel of your Apple Watch, which is something you will want to keep in mind as you select one that you like. The wraps cover the back and edges, as well as the little bit of case that comes up to the front edge. You will need a hairdryer for the installation to get everything curved just right.

There are also stickers for the side button and the digital crown. Check out the Apple Watch Series 3 skins, Apple Watch Series 2 skins and Apple Watch Series 1 skins. You need to buy the skin for your exact model. Each skin is $8.95 and you can add a screen protector combination pack for an extra $4.95. It’s important to consider what your Apple Watch bands will look like with your new skin.

BodyGuardz Apple Watch Skin

<figcaption class=" wp-caption-text/>BodyGuardz makes the best clear Apple Watch skins.

The BodyGuardz Apple Watch Skins are designed to protect your Apple Watch without covering up the color or changing the texture dramatically. This is a clear skin that protects your watch from scratches without making it thicker.

This is perfect if you wear your Apple Watch while working around machines or if you plan to sell your Apple Watch after a year to upgrade to the new model and you want it looking perfect. This includes a tough screen protector that some users will appreciate in their quest for full body protection.

The Apple Watch Skin full body protection model is $14.95 at BodyGuardz and comes in a version for the Apple Watch Series 3 and Series 2, and one for the original Apple Watch.

dbrand Apple Watch 3 Skin

<figcaption class=" wp-caption-text/>With dbrand, you can get a skin for the crown.

One of our favorite companies to get skins from is dbrand, and they offer an Apple Watch 3 skin that is very minimal. In fact, it’s basically there to cover up the red crown on the Apple Watch 3 with LTE.

This is something that comes with a full skin when you buy from SlickWraps and it is a very small skin. Instead of protecting your Apple Watch from scratches, this will hid the fact that it is LTE enabled if you choose a discrete color, or it will call attention to the crown. It’s all up to you.

The skin is $4.95 at dbrand, we wouldn’t be surprised to see it fit the older Apple Watch models as well.

35 Exciting Things You Can Do With the Apple Watch

Answer Calls on the Apple Watch

Answer Calls on the Apple Watch

You can answer a call on your Apple Watch using it as a small Bluetooth speaker phone. You only want to use this for shorter calls because the audio quality isn’t as good as when you are talking on speakerphone on your iPhone. 

The Apple Watch only allows you to answer your calls on Speakerphone, so you won’t want to use this all the time. It is very handy when you are working on a project or busy with your hands. Definitely be conscious of where you are taking calls. If you wouldn’t talk on speakerphone, you shouldn’t talk on your Apple Watch.

If you buy the new Apple Watch Series 3 with LTE, you can even make calls on the Apple Watch without your iPhone nearby. This requires adding the watch to your plan for $10 a month. You cannot answer a FaceTime video call on the Apple Watch. 

Monday, November 20, 2017

Google says upcoming update should eliminate Pixel 2’s buzzing noise

Google‘s newest Pixel phones have had their fair share of issues, one of which being a weird buzzing noise that manifested itself in the smaller Pixel 2. According to Google, however, an upcoming update should address the strange noise.

Community manager Orrin Hancock did not say when exactly the update would land, but seeing how the update will arrive “in the coming weeks,” the safe bet would be that the fix will arrive with the December security patch. Per Hancock:

Hey all,

We’re rolling out a software update in the coming weeks which eliminates a faint buzzing sound on some Pixel 2 devices when the phone is placed to your ear during a phone call.


The buzzing noise from certain Pixel 2 units have been well documented for several weeks, so it’s nice to see that a fix is on the way. That being said, this is a different issue from the clicking noise that was also reported from Pixel 2 and Pixel 2 XL owners. The clicking noise looks to have been fixed with the November patch, though folks found a way around the problem by turning off NFC.

Editor’s Pick

Either way, this is yet another reminder that Google’s newest flagship smartphones have been hit with issue after issue. On the flip side, this is also another reminder that Google appears to be listening and addressing as many issues as possible through software updates.

As usual, we’ll keep a close eye on any updates that make their way from Mountain View. In the meantime, let us know in the comments if you have noticed any buzzing noise with your Pixel 2.

Saturday, November 18, 2017

7 Things to Know About the iPhone X iOS 11.1.2 Update

Apple’s new iOS 11.1.2 update is focused on fixing iPhone X problems and those of you who own Apple’s new flagship will probably want to download it before too long.

iPhone X users have been complaining about a variety of issues and Apple’s finally starting to address some of these complaints with software updates. The iOS 11.1.2 update delivers two key bug fixes including one for an issue where the screen would become unresponsive in certain temperatures.

The iPhone X iOS 11.1.2 update is a tiny download if you’re coming from iOS 11.1.1. If you’re coming to iOS 11.1.2 from an older version of iOS 11, your update will be a little bit bigger due to the updates you missed.

The iPhone X iOS 11.1.2 update is treating our device well, but we’re starting to hear about some of the issues plaguing early adopters.

Some iPhone X users are reporting minor bugs, others are noticing frustrating iOS 11.1.2 performance issues. Apple’s next iOS update could be weeks away so you’ll need to proactive if you encounter an iOS 11.1.2 problem on your phone.

Our guide to the iPhone X iOS 11.1.2 update goes over these initial problems and provides some fixes to those in need. It also highlights the changes on board iOS 11.1.2 and provides you with some information about the next major iOS 11 release for the device.

We’ve been using the iOS 11.1.2 update on the iPhone X for a short time and we want to start with some initial impressions of its performance.

Our impressions will take you through our initial thoughts about battery life, app performance, connectivity, and the device’s overall speed.

iPhone X iOS 11.1.2 Impressions

iPhone X iOS 11.1.2 Impressions

When you go to check for a software update in your iPhone X’s settings you’ll be prompted to install iOS 11.1.2. 

Once you fire it up, it should only take a minute or so to download, provided you’re on a high-speed Wi-Fi network. Once the download finishes, the installation process will begin. This took about four minutes to complete on our iPhone X.

Your iPhone X might reboot itself once or twice, but there’s no reason to be concerned. This sometimes happens during the installation process.

Once you get iOS 11.1.2 on board you shouldn’t notice a huge drop in performance though there’s always a chance your device runs into trouble.

So far, our experience on iOS 11.1.2 has been good. We haven’t noticed any weird battery life problems and the iPhone X models in our possession continue to maintain excellent battery life. 

We’ve been able to connect to Wi-Fi, Bluetooth and cellular networks. We haven’t noticed any issues with download or upload speeds.

Apps feel stable on the iPhone X. We’ve run into some stability issues on older iPhones running iOS 11, but we haven’t noticed any crashes on iOS 11.1.2.

Some iPhone X users have noticed lag, but we haven’t experienced any slow down yet. Animations and transitions are crisp. We haven’t seen any random reboots either. 

The iOS 11.1.2 update is performing well and it’s definitely worth a download soon after you open your iPhone X. The emojis and the fix for that autocorrect bug make it worth it.

That said, if you’re feeling leery, you might want to wait for long term iPhone X iOS 11.1.2 feedback to arrive.

For more, take a look at our list of reasons to and not to install the iOS 11.1.2 update on your phone right now. And if you need additional help setting up your iPhone X, take a look at our guide.

Apple's iMac Pro may have hands-free Siri voice control

It’s possible that the A10 chip is always running, which would represent a break from the custom T1 chip driving the Touch Bar in some recent MacBook Pro models. That would line up with leaks which had custom ARM chips handling macOS’ Power Nap feature, which fetches data while the system is sleeping. The iMac Pro wouldn’t have to spool up its power-hungry Xeon processor just to grab your email. And of course, that could be very important for “hey Siri” commands, which could theoretically run even if the Mac is dormant.

The findings don’t necessarily mean that the iMac or macOS will be more restrictive than before. You may not know exactly what the A10 does until the iMac Pro ships, which is expected before the end of 2017. However, this does show that Apple is putting its mobile experience to use in the computer realm, even if it’s just to save power and processing overhead. And the iMac Pro may be a good testbed for this functionality. As Troughton-Smith points out, Apple could gauge how the companion A10 works without the bulk of users “freaking out.” You could get a more refined experience if and when the A10 finds its way to mainstream Macs — particularly MacBooks, where the chip could let Siri and Power Nap run without significantly affecting your battery life.

5 best dialer apps and contacts apps for Android

best dialer apps and contacts apps featured image
Dialer apps and contacts apps are a bit of a niche market. In most cases, the stock dialer and contacts app is more than good enough most of the time. However, there are some cases where it may be necessary. The Note 8 occasionally freezing while using the contacts app is a good example. In any case, there are a bunch of decent options, but only a few really good ones. Also, we considered doing separate lists for contacts apps and dialer apps. However, generally speaking, if you get one, you get the other too. Both lists would pretty much have the same apps. Thus, we’ve consolidated it into a single list here. Here are the best dialer apps and contacts apps for Android.


Price: Free / Up to $3.99


Drupe is one of the most popular dialer apps on mobile. It features a modern, beautiful interface along with a call recorder, smart dialer, call blocker, and methods to deal with duplicate contacts. It can even send GIFs to people when you call them, but both people need to have Drupe installed for that to work. The app covers all of the basics and does many of them better than the stock app. It has the occasional bug, but nothing serious. It’s free to download for the most part. Some features require purchase via in-app purchases.



Price: Free / $3.99


ExDialer is one of the better dialer apps and contacts apps. This one features support for 30 languages, includes a smart dialer (with T9), and boasts a faster, lightweight experience. It also includes a variety of plugins, gesture controls, and little Easter egg commands to make things easier. It rounds out the experience with a simple, easy, Material Design UI. The free version is a five day trial. The full version is a separate unlocker app that coasts $3.99.



Metro Phone Dialer and Contacts

Price: Free


Metro Phone Dialer and Contacts takes a few design cues from Windows’ Metro UI. It features solid colors, a simple UI, and enough features to make it good. That includes a customizable UI, themes, contact searches, and more. It’s a little lighter on features than most. However, that can be desirable if you need something simple that just works. It’s also totally free with no in-app purchases. There are ads, though, and we would’ve liked a pro option to remove them.


Simpler Contacts and Dialer

Price: Free / Up to $9.99


Simpler isn’t as popular as some other dialer apps or contacts apps. It probably should be. Simpler features an improved caller ID, functions to control duplicate contacts, social network support, over 40 themes, and more. It also has call blocking, offline backup, and tools to clean up your contact list a little bit. The app rounds everything up in a simple, good-looking Material Design interface. There really isn’t much wrong with this one aside from a bugs here and there. The app is free to download with an optional pro version available via in-app purchase.


Simpler Contacts and Dialer


Price: Free / $1.99 per month / $17.99 per year


Truecaller is one of the most popular and powerful contacts apps and dialer apps. It even works as an SMS app. It includes a laundry list of features for the dialer, contacts, and SMS portions of the app. That includes an SMS spam filter, call blocking, dual-SIM support, and a lot more. It also boasts the best caller ID out there. The interface uses a basic Material Design. We’re not going to complain about that! The only real downside is the price. This is one of the only dialer apps or contacts apps with a subscription. It’s not necessary to use the basic features, but $17.99 per year is a little steep for our tastes.



If we missed any great dialer apps or contacts apps for Android, tell us about them in the comments! You can also click here to check out our latest Android app and game lists!

Best Android Phones Under $100

These days smartphones are getting more and more expensive, but luckily those $900 phones aren’t your only option. With that in mind, below we’ve round-up a list of some of the best Android phones under $100. Perfect for those on a tight budget that still want a good experience.

In the past, we’ve detailed cheap Android smartphones, but none of them were this cheap. Motorola typically has some of the best phones for budget shoppers. Then, we’ve gathered a few other great options to give potential buyers more choices than ever before.

Read: Best Small Screen Android Phones Worth Buying

Not all buyers need a premium flagship smartphone, want to sign a 2-year contract or fork out $30 a month on a phone. Let alone spend $700-$900. You’ll be happy to know some Android phones come in under $100, and they aren’t terrible Chinese devices either. These are capable phones that will still deliver a well-rounded experience.

Over the past few years, a lot of cheap Android smartphones have arrived. It’s a trend that isn’t going away anytime soon. Motorola leads the pack with some of the best price/performance phones and others have followed their lead. The result is multiple phones for as low as $69 in some cases. Check out our recommendations list, then read on for more details and links to buy one in the slideshow below.

Best Android Phones Under $100

  • Moto E4

  • ZTE ZMax Pro

  • Moto E4 Plus

  • LG Harmony

  • Samsung Galaxy J7

  • ZTE Tempo X

Many budget Android phones sold by select small carriers or unlocked on Amazon (or from China) don’t offer a good experience. They run outdated software or are typically awful devices. And while our list doesn’t guarantee a Galaxy S8 or Google Pixel 2 type experience, it’s more than enough for most. These are newer phones with up-to-date software.

Considering the budget, these smartphones have plenty to offer. They are cheap devices that are actually worth the money. Of course, everyone has different needs, wants, and preferences. Not to mention you might be tied to a certain network, which is why we’ll cover as many options as possible. These are the best phones available that come in at or under $100.

Moto E4

Moto E4

The Moto G is an icon in the budget category and continues to top our lists. However, when you’re looking to spend less than $100, the Moto E4 and E4 Plus are perfect. 

The Moto E4 is an impressive phone for the price. You get a nice 5-inch screen, a fast fingerprint scanner, splash-resistance, and nearly stock Android for only $99. Inside there’s a quad-core Snapdragon processor with 2GB of RAM, 16GB of storage, and a microSD slot for expansion up to 128GB. 

You’ll also enjoy a decent 8MP camera, 2,800 mAh battery with fast charging and just an overall great experience. It’s like a cheaper Moto G5. 

This is technically a $130 phone, but you get it from Amazon with ads on the lockscreen for $99. It’s unlocked so you can take it to any carrier you’d like. 

Buy it Now for $99 at Amazon

Even better, the Moto E4 is available from Verizon for only $69


google analytics

Contact Form


Email *

Message *

Last Hour Hits

Copyright © Tech Visions