When you start a brand new app in Android Studio, you're dropped into a bare-bones project that likely just has a single, empty Activity.
If you're trying to build out a project beyond "Hello World!
", especially if you plan to follow some architectural best practices like using MVVM, you'll quickly run into some limitations with the basic Android libraries included in every project.
After creating a few basic starter applications, I thought I'd share what I think are the best "first step" dependencies to add to your Android project.
TL;DR - app/build.gradle
Before I go into more detail, here's the basic dependencies
list I put together for my last starter app.
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.3.31"
implementation 'androidx.appcompat:appcompat:1.0.2'
implementation 'androidx.core:core-ktx:1.0.2'
implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
// enable ViewModelProviders
implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"
// enable TextInputLayout
implementation 'com.google.android.material:material:1.0.0'
testImplementation 'junit:junit:4.12'
// enable Mocking with Mockito
testImplementation 'org.mockito:mockito-core:2.19.0'
// enable InstantTaskExecutorRule
testImplementation 'androidx.arch.core:core-testing:2.0.1'
androidTestImplementation 'androidx.test:runner:1.2.0'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
// non-deprecated AndroidJUnit4
androidTestImplementation 'androidx.test.ext:junit:1.1.1'
}
The lines I commented are the ones I added to what was included with the basic Android blank-Activity starter app in Android Studio 3.4.
Let's take a closer look at what these libraries are and why we need them.
Prod Code
The implementation
keyword specifies dependencies in your actual, running, production code.
Lifecycle Extensions
Enable some handy extensions for Android Lifecycle components. Namely, the ability to use ViewModelProviders
.
implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"
Any Android project needs an architectural pattern to follow. Google recommends using MVVM with the Android ViewModel. ViewModelProviders
enables you to quickly setup ViewModel
s in your Activities and Fragments in a Google-approved way.
Material
You can get by without many of the Material Design components, but it's easier to use them. They support some very useful UI elements that Android users are used to seeing.
implementation 'com.google.android.material:material:1.0.0'
For me, this library allowed me to use TextInputLayout
for my text fields. This enables built in error fields, animated hints, and a Material-first design that I wanted in my app.
Unit Tests
Using testImplementation
specifies dependencies for your Unit Tests. JUnit is included by default.
Mockito
The included ExampleUnitTest
in any Android beginner project doesn't use Mockito to test. However, as projects grow, you'll quickly realize the benefits of a full-fledged mocking library.
testImplementation 'org.mockito:mockito-core:2.19.0'
Mockito enables you to use the MockitoJUnitRunner
and to mock data and function calls in your test. It really helps to reduce boiler plate and focus on the right functionality in your unit tests.
Lifecycle Testing
If you're doing the right thing and following MVVM with the Android Architecture Components, then you'll probably want to test your ViewModel
s and LiveData
.
testImplementation 'androidx.arch.core:core-testing:2.0.1'
The core-testing library enables you to test LiveData
in your JUnit tests using the InstrumentationTestRegistry
rule.
/**
* Enables Architecture Components testing in JUnit tests.
* (Include this at the top of your Unit Test class body.)
*/
@get:Rule
var task = InstantTaskExecutorRule()
UI Testing
The androidTestImplementation
keyword refers to UI/Instrumentation test dependencies.
Android JUnit
While you don't need this to use AndroidJUnit4
, this dependency includes the latest, non-deprecated version.
androidTestImplementation 'androidx.test.ext:junit:1.1.1'
What's next?
Hopefully this guide has helped you identify some foundational dependencies you'll need for almost any Android project.
It's impossible to be prescriptive about what dependencies you'll need to explore the infinite possibilities available to you in your next Android project. What's next is up to you.
This article is republished from my blog, AJ.dev - read it there.
Top comments (0)