DEV Community: Pushkar Anand

Experimenting with Dagger Hilt

Pushkar Anand — Sun, 14 Jun 2020 13:53:00 +0000

Dagger recently introduced Hilt, their next take on improving dependency injection in Android. Hilt aims to provide a standard way to incorporate Dagger dependency injection into an Android application.

In the past, I have tried Dagger Android and Koin and eventually settled with Koin as they provide support for ViewModels out of the box.

With the introduction of Hilt and aim to reducing boilerplate code, I decided to try out Hilt.
I would be documenting my findings through this post as I try out Hilt.

With Hilt still being in Alpha stage, I won't migrate any existing app to Hilt but instead, build a basic MVVM app to try Hilt.
We'll build an app that displays a simple list of words.

Let's fire up Android Studio and start a new project with an empty activity.

Now let's add the dependencies for Hilt, Room, LiveData and ViewModel.

After adding all the dependencies, this is how our project-level build.gradle looks:

buildscript {
    ext.hilt_version = "2.28-alpha"
    ...
    dependencies {
        ...
        classpath "com.google.dagger:hilt-android-gradle-plugin:$hilt_version"
    }
}

And app-level build.gradle file:

...
apply plugin: 'kotlin-kapt'
apply plugin: 'dagger.hilt.android.plugin'

android {
    ...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

dependencies {
    def lifecycle_version = "2.2.0"
    def room_version = "2.2.5"

    ...
    // Activity Ktx for by viewModels()
    implementation "androidx.activity:activity-ktx:1.1.0"

    //ViewModel & LiveData
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    // Room
    implementation "androidx.room:room-runtime:$room_version"
    kapt "androidx.room:room-compiler:$room_version"


    //Dagger - Hilt
    implementation "com.google.dagger:hilt-android:$hilt_version"
    kapt "com.google.dagger:hilt-android-compiler:$hilt_version"
    ...

}

Now let's add an entity, a DAO and DB file.

Entity: Word.kt

@Entity
data class Word(

    @PrimaryKey(autoGenerate = true)
    val id: Long,

    var word: String

)

Dao: WordDao.kt

@Dao
interface WordDao {

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insert(word: Word)

    @Query("SELECT * FROM word")
    fun getAllWords(): LiveData<Word>

}

AppDB.kt

@Database(entities = [Word::class], version = 1, exportSchema = false)
abstract class AppDB : RoomDatabase() {
    abstract fun wordDao(): WordDao
}

Now let's set up Hilt.
We need to add an application class annotated with @HiltAndroidApp.

HiltDemo.kt

@HiltAndroidApp
class HiltDemo : Application()

Now, we need to add an activity with a recycler view to display our word list.

item.xml:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/itemParent"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <TextView
        android:id="@+id/wordTV"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:textAlignment="center"
        android:textSize="24sp"
        android:textStyle="bold"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:text="Word" />
</androidx.constraintlayout.widget.ConstraintLayout>

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/mainParent"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".ui.main.MainActivity">

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/wordRV"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginBottom="8dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:itemCount="7"
        tools:listitem="@layout/item" />
</androidx.constraintlayout.widget.ConstraintLayout>

WordHolder.kt:

class WordHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
    private val wordTV: TextView = itemView.wordTV

    fun setData(word: Word) {
        wordTV.text = word.word
    }
}

WordAdapter.kt

class WordAdapter : RecyclerView.Adapter<WordHolder>() {

    private var wordList = emptyList<Word>()

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = WordHolder(
        LayoutInflater.from(parent.context).inflate(R.layout.item, parent, false)
    )


    override fun getItemCount() = wordList.size

    override fun onBindViewHolder(holder: WordHolder, position: Int) {
        val word = wordList[position]
        holder.setData(word)
    }

    fun setWordList(wordList: List<Word>) {
        this.wordList = wordList
        notifyDataSetChanged()
    }
}

MainActivity.kt

class MainActivity : AppCompatActivity() {

    private lateinit var wordAdapter: WordAdapter

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        wordAdapter = WordAdapter()

        wordRV.apply {
            adapter = wordAdapter
            layoutManager = LinearLayoutManager(this@MainActivity)
        }

    }
}

Now first let's add the Repository and ViewModel without Hilt.

DataRepository.kt:

class DataRepository(appDB: AppDB) {

    private val wordDao = appDB.wordDao()

    private val executor = Executors.newSingleThreadExecutor()

    fun insert(word: Word) {
        executor.execute {
            wordDao.insert(word)
        }
    }

    fun getAllWords() = wordDao.getAllWords()

}

MainViewModel.kt:

class MainViewModel(repository: DataRepository) : ViewModel() {
    val wordListLiveData = repository.getAllWords()
}

Now let's use Hilt to inject all the required dependencies for us.

First, we need to inject AppDB in Data repository. We'll use the @Inject annotation in the Data Repository. The @Inject is used to annotate the constructor that Hilt should use to create instances of a class.

DataRepository.kt

class DataRepository @Inject constructor( appDB: AppDB) { ... }

At this point, Hilt doesn't know how to create an instance of AppDB.
So let's tell Hilt how to create an instance of AppDB. We'll use @Module annotation to create a DB module for Hilt. The module along with @Provides annotation will tell Hilt how to create an instance of AppDB.

DBModule.kt

@Module
@InstallIn(ApplicationComponent::class)
object DBModule {

    @Provides
    fun provideDatabase(
        @ApplicationContext appContext: Context
    ): AppDB {
        return Room.databaseBuilder(
            appContext,
            AppDB::class.java,
            "demo.db"
        ).fallbackToDestructiveMigration().build()
    }

}

Notice the @InstallIn & @ApplicationContext annotation? The @InstallIn annotation will tell Hilt which component each module will be used or installed in. The @ApplicationContext annotation will tell Hilt to inject application context.

Now, we need to inject the DataRepository in our MainViewModel. To do so we need Hilt ViewModel library first. Find the library here.

Let's add the libraries in our app-level build.gradle.

dependencies {
    ...
    def hilt_jetpack = "1.0.0-alpha01"
    ...

    //Dagger - Hilt
    ...
    implementation "androidx.hilt:hilt-lifecycle-viewmodel:$hilt_jetpack"
    kapt "androidx.hilt:hilt-compiler:$hilt_jetpack"
    ...
}

At this point, Hilt knows how to create an instance of data repository. So we'll just use the @ViewModelInject annotation.
The @ViewModelInject annotations will tell Hilt to inject the DataRepository in the ViewModel.


class MainViewModel @ViewModelInject constructor(repository: DataRepository) : ViewModel() { ... }

Now all these hard work annotating our classes will only pay off when we inject the ViewModel into our MainActivity.

To inject anything into activities, fragments, views, services and broadcast receivers we need to annotate the class with @AndroidEntryPoint, and then annotate all the variable we want to inject with the @Inject annotation. The variables should be a lateinit var or should be delegated.
The variables would be available to use after the super calls in the overridden functions. For example super.onCreate() call in an Activity.

One important thing to note here is that the activities you want to inject in must be a ComponentActivity. Since the AppCompatActivity class extends from this class, this isn't an issue.

So now, let's inject our view model in MainActivity.
Wait, we don't need to, The Hilt Jetpack docs states that

An activity or a fragment that is annotated with @AndroidEntryPoint can get the ViewModel instance as normal >using ViewModelProvider or the by viewModels() KTX extensions.

So let's just annotate our activity and initiate the view model.

MainActivity.kt:

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

    ...
    private val mainViewModel: MainViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        mainViewModel.wordListLiveData.observe(this, Observer {
            wordAdapter.setWordList(it)
        })

    }
}

Now let's run and see our app.
If your app crashed, it's probably because you forgot to add the applications class in the Manifest like me.

Umm.. the activity is empty. We should have pre-populated the database to test the app. No problem let's do it now. We'll need to modify our DBModule to do so.

DBModule.kt:

@Module
@InstallIn(ApplicationComponent::class)
object DBModule {

    lateinit var appDB: AppDB

    private val executor = Executors.newSingleThreadExecutor()

    @Provides
    fun provideDatabase(
        @ApplicationContext appContext: Context
    ): AppDB {
        appDB = Room.databaseBuilder(
            appContext,
            AppDB::class.java,
            "demo.db"
        ).fallbackToDestructiveMigration()
            .addCallback(object : RoomDatabase.Callback() {
                override fun onCreate(db: SupportSQLiteDatabase) {
                    super.onCreate(db)
                    val dao = appDB.wordDao()

                    executor.execute {
                        var word = Word(0, "Hey")
                        dao.insert(word)

                        word = Word(0, "the")
                        dao.insert(word)

                        word = Word(0, "app")
                        dao.insert(word)

                        word = Word(0, "worked")
                        dao.insert(word)
                    }
                }
            })
            .build()

        return appDB
    }

}

Now run the app again, make sure to uninstall the previous installation first.

Ahh!! it works. So we built a basic MVVM with Hilt. We were able to build this app with very little boilerplate requirements as compared to Dagger Android. A lot of the work is handled for us by Hilt.

Checkout the project built while working on this post.

pushkar-anand / hilt-demo

Demo android application for Hilt with MVVM

If you are interested to learn mode about Hilt, check out the following resources:

Upgrading to PHP 7.4

Pushkar Anand — Thu, 28 Nov 2019 15:37:18 +0000

The awaited latest version of the PHP 7.4 was released on 28th Nov, 2019. It comes with a lot of new features such as

Typed Properties
Arrow Functions
Limited Return Type Covariance and Argument Type Contravariance
Unpacking Inside Arrays
Numeric Literal Separator
Weak References
Allow Exceptions from __toString()
Opcache Preloading
Several Deprecations
Extensions Removed from the Core

PHP 7.1 approaches EOL & 7.2 will become security only on 1st December.

Let's see how to upgrade your PHP installation to 7.4.

1. Add the `ondrej/php` PPA

Ubuntu:

sudo add-apt-repository ppa:ondrej/php # Press enter to confirm.
sudo apt-get update

Debian:

sudo apt install apt-transport-https lsb-release
sudo wget -O /etc/apt/trusted.gpg.d/php.gpg https://packages.sury.org/php/apt.gpg # Download the signing key
sudo sh -c 'echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/php.list' # Add Ondrej's repo to sources list.
sudo apt update

2. Install PHP 7.4 and required extensions

To install PHP 7.4 core

sudo apt install php7.4 php7.4-common php7.4-cli

Install required extensions

Simply prefix php7.4- with an extension that you need to install.
For example to get the php-curl extension use php7.4-curl

sudo apt install php7.4-curl php7.4-json php7.4-gd php7.4-mbstring php7.4-intl php7.4-bcmath php7.4-bz2 php7.4-readline php7.4-zip

3. PHP 7.4 for web:

To integrate PHP with your web server, If you are using Nginx, or Apache with mod_event, you will need to install php7.4-fpm package. If you are using PHP as an embedded Apache module, you will need the package libapache2-mod-php7.4. For Apache, you can use apachectl -V to see your current MPM, whether it’s prefork or event.

Nginx or Apache with event MPM:

sudo apt install php7.4-fpm

Apache with prefork MPM:

sudo apt install libapache2-mod-php7.4
sudo a2enmod php7.4

4. Uninstall old PHP versions:

sudo apt purge php7.3 libapache2-mod-php7.3 # For removing PHP 7.3
sudo apt purge php7.2 libapache2-mod-php7.2 # For removing PHP 7.2
sudo apt purge php7.1 libapache2-mod-php7.1 # For removing PHP 7.1
sudo apt purge php7.0 libapache2-mod-php7.0 # For removing PHP 7.0

5. Verify PHP 7.4 installation:

To verify the installation of PHP 7.4

From CLI:

php -v

From web server:

Create a file info.php. It must be saved to a very specific directory, which is called the “web root”. In Ubuntu and Debian this is located at /var/www/html/.

sudo nano /var/www/html/info.php

Type the following in the editor.

<?php
    phpinfo();
?>

When you are finished, save and close the file.

Now visit this script in your browser. http://your_server_IP_address/info.php
You should see something similar to this.

So now you have PHP 7.4 up and running. See the migration guide for PHP 7.4 at https://www.php.net/migration74

Navigation library in Android

Pushkar Anand — Wed, 27 Nov 2019 13:24:03 +0000

At Google I/O 2018, Android introduced a bunch of new components to the Android Jetpack libraries. One such library is Navigation component, designed to reduce the effort in building apps with consistent navigation flow and to reduce errors and making it easier to work fragments. Recently the Navigation Component moved from beta to stable.

With the navigation component, it's very easy to build consistent navigation in your apps. Not only this with the navigation component you can do a lot more:

Fragment transaction can be done with just a single method call.
Handling Up and Back actions correctly by default.
Safely pass data between destination with SafeArgs.
Native support for deep-linking.
Building navigation drawers & bottom navigation bars with minimal code.

So now let's learn how we can use this component in our apps.

1. Add the dependencies

In your app-level build.gradle file include the following dependencies

implementation "androidx.navigation:navigation-fragment:2.1.0"
implementation "androidx.navigation:navigation-ui:2.1.0"

If you are using kotlin append -ktx to the above libraries

implementation "androidx.navigation:navigation-fragment-ktx:2.1.0"
implementation "androidx.navigation:navigation-ui-ktx:2.1.0"

To add support for SafeArgs, add a classpath in your project-level ```build.gradle``` file.

buildscript {
    repositories {
        google()
    }
    dependencies {
        //.....
        classpath "androidx.navigation:navigation-safe-args-gradle-plugin:2.1.0"
    }
}

Now add the following line to your app-level ```build.gradle``` file.

apply plugin: "androidx.navigation.safeargs"

2. Add Activity

Create a BaseActivity to contain the fragments. This activity will contain the Host fragment.

Java:

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

public class BaseActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_base);
    }
}

Kotlin:

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

class BaseActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_base)
    }
}

Now add a layout file activity_base.xml that contains a fragment. This fragment will be our NavHost fragment i.e, An empty container to display our destination fragments.


<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".ui.BaseActivity">

    <fragment
        android:id="@+id/base_fragment"
        android:name="androidx.navigation.fragment.NavHostFragment"
        android:layout_width="0dp"
        android:layout_height="0dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:defaultNavHost="true" />

</androidx.constraintlayout.widget.ConstraintLayout>

android:name signifies that this fragment is a host for our destination and app:defaultNavHost when set to true tells that this is the default host for all the destination in our app.

3. Add the Navigation Graph

Navigation graph is an XML resource file that contains all the navigation-related information in a single file. It contains all the information about destinations and paths. It can be visually edited from Android Studio 3.3 onwards.

To add the navigation graph: Right-click on the resource(res) folder in the Project menu> select New > select Android Resource File.

Select navigation from the Resource type dropdown and add the filename nav_graph.xml

A visual editor opens up to edit the navigation graph file.

Now add this graph file to the NavHost fragment we just created above as app:navGraph="@navigation/nav_graph"

   <fragment
        android:id="@+id/base_fragment"
        android:name="androidx.navigation.fragment.NavHostFragment"
        android:layout_width="0dp"
        android:layout_height="0dp"
        app:defaultNavHost="true"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:navGraph="@navigation/nav_graph"
        />

4. Create Destinations

On the navigation graph editor find the add destination button and then click on 'Create new Destination'.

The first icon with a plus sign is the add destination.

Now a fragment creation window opens up. Let's name our fragment HomeFragment.

Set the HomeFragment as our start destination by using the home icon in the toolbar.

Now let's add another destination and name it DestFragment. Now our navigation graph looks like below.

After creating two destinations.

Click on the homeFragment destination and drag a path from homeFragment to destFragment destination.

Drag a path from home to dest.

Let's add a button to our HomeFragment. When clicking the button the DestFragment should open.

Go to fragment_home.xml & Add a button

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".HomeFragment">

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Open DEST"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.5"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Now in HomeFragment.kt or HomeFragment.java file override the onViewCreated method and set a listener for the button we just added. Then use the navigate method of NavController object to switch to destFragment destination.

Java

import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.navigation.NavController;
import androidx.navigation.Navigation;

public class HomeFragment extends Fragment {


    public HomeFragment() {
        // Required empty public constructor
    }


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_home, container, false);
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);

        final NavController navController =
                Navigation.findNavController(requireActivity(), R.id.base_fragment);

        Button button = getActivity().findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                navController.navigate(R.id.destFragment);
            }
        });
    }
}

Kotlin

import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.navigation.fragment.findNavController
import kotlinx.android.synthetic.main.fragment_home.*

class HomeFragment : Fragment() {

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_home, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        button.setOnClickListener { 
            findNavController().navigate(R.id.destFragment)
        }
    }
}

This is it. See how easy it is to switch fragments. I'll write about using navigation graph with BottomNavigationBar in my next post in the series.

You can find the sample code used in this article here.

Originally published at A coder’s words.