Introduce Hilt dependency injection

Uses Hilt to get the database initialization off of the
main thread.

The initial introduction always has a disproportionate
fan-out of boilerplate. In this case, all entry points which
were using UIViewModel needed to be annotated in order to let
the code gen know that they needed to support it.

The PacketRepository is injected into things via the main
thread (e.g., the MeshService) but due to the lazy declaration,
the database isn't hydrated until the DAO is access while on an
IO thread.

app/src/main/java/com/geeksville/mesh/database/DatabaseModule.kt

@@ -0,0 +1,29 @@
+package com.geeksville.mesh.database
+
+import android.app.Application
+import androidx.room.Room
+import com.geeksville.mesh.database.dao.PacketDao
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@InstallIn(SingletonComponent::class)
+@Module
+class DatabaseModule {
+    @Provides
+    fun provideDatabase(application: Application): MeshtasticDatabase {
+        return Room.databaseBuilder(
+            application.applicationContext,
+            MeshtasticDatabase::class.java,
+            "meshtastic_database"
+        )
+            .fallbackToDestructiveMigration()
+            .build()
+    }
+
+    @Provides
+    fun providePacketDao(database: MeshtasticDatabase): PacketDao {
+        return database.packetDao()
+    }
+}

app/src/main/java/com/geeksville/mesh/database/MeshtasticDatabase.kt

@@ -1,8 +1,6 @@
 package com.geeksville.mesh.database
 
-import android.content.Context
 import androidx.room.Database
-import androidx.room.Room
 import androidx.room.RoomDatabase
 import com.geeksville.mesh.database.dao.PacketDao
 import com.geeksville.mesh.database.entity.Packet
@@ -10,27 +8,4 @@ import com.geeksville.mesh.database.entity.Packet
 @Database(entities = [Packet::class], version = 1, exportSchema = false)
 abstract class MeshtasticDatabase : RoomDatabase() {
     abstract fun packetDao(): PacketDao
-
-    companion object {
-        @Volatile
-        private var INSTANCE: MeshtasticDatabase? = null
-
-        fun getDatabase(
-            context: Context
-        ): MeshtasticDatabase {
-            return INSTANCE ?: synchronized(this) {
-                val instance = Room.databaseBuilder(
-                    context.applicationContext,
-                    MeshtasticDatabase::class.java,
-                    "meshtastic_database"
-                )
-                    .fallbackToDestructiveMigration()
-                    .build()
-                INSTANCE = instance
-
-                instance
-            }
-        }
-    }
-
 }

app/src/main/java/com/geeksville/mesh/database/PacketRepository.kt

@@ -1,24 +1,34 @@
 package com.geeksville.mesh.database
 
-import androidx.lifecycle.LiveData
 import com.geeksville.mesh.database.dao.PacketDao
 import com.geeksville.mesh.database.entity.Packet
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
 
-class PacketRepository(private val packetDao : PacketDao) {
-    val allPackets : LiveData<List<Packet>> = packetDao.getAllPacket(MAX_ITEMS)
-    val allPacketsInReceiveOrder : Flow<List<Packet>> = packetDao.getAllPacketsInReceiveOrder(MAX_ITEMS)
+class PacketRepository @Inject constructor(private val packetDaoLazy: dagger.Lazy<PacketDao>) {
+    private val packetDao by lazy {
+        packetDaoLazy.get()
+    }
 
-    suspend fun insert(packet: Packet) {
+    suspend fun getAllPackets(): Flow<List<Packet>> = withContext(Dispatchers.IO) {
+        packetDao.getAllPacket(MAX_ITEMS)
+    }
+
+    suspend fun getAllPacketsInReceiveOrder(): Flow<List<Packet>> = withContext(Dispatchers.IO) {
+        packetDao.getAllPacketsInReceiveOrder(MAX_ITEMS)
+    }
+
+    suspend fun insert(packet: Packet) = withContext(Dispatchers.IO) {
         packetDao.insert(packet)
     }
 
-    suspend fun deleteAll() {
+    suspend fun deleteAll() = withContext(Dispatchers.IO) {
         packetDao.deleteAll()
     }
 
     companion object {
         private const val MAX_ITEMS = 500
     }
-
 }

app/src/main/java/com/geeksville/mesh/database/dao/PacketDao.kt

@@ -1,6 +1,5 @@
 package com.geeksville.mesh.database.dao
 
-import androidx.lifecycle.LiveData
 import androidx.room.Dao
 import androidx.room.Insert
 import androidx.room.Query
@@ -11,7 +10,7 @@ import kotlinx.coroutines.flow.Flow
 interface PacketDao {
 
     @Query("Select * from packet order by received_date desc limit 0,:maxItem")
-    fun getAllPacket(maxItem: Int): LiveData<List<Packet>>
+    fun getAllPacket(maxItem: Int): Flow<List<Packet>>
 
     @Query("Select * from packet order by received_date asc limit 0,:maxItem")
     fun getAllPacketsInReceiveOrder(maxItem: Int): Flow<List<Packet>>