I want to Create An Instance Of Room Data base in Composable But val db = Room.databaseBuilder(applicationContext, UserDatabase::class.java,"users.db").build() is not working here not getting applicationContext

How to create an instance of context in composable

CodePudding user response：

Have you tried getting the context with : val context = LocalContext.current and then adding this to get your applicationContext?

Like this: context.applicationContext or using simply val db = Room.databaseBuilder(context, UserDatabase::class.java,"users.db").build()

CodePudding user response：

Room (and the underlying SQliteOpenHelper) only need the context to open the database (or more correctly to instantiate the underlying SQLiteOpenHelper).

• Room/Android SQLiteOpenHelper uses the context to ascertain the Application's standard (recommended) location (data/data/<the_package_name>/databases). e.g. in the following demo (via Device Explorer):-

• 

• The database, as it is still open includes 3 files (the -wal and -shm are the Write Ahead Logging files that will at sometime be committed/written to the actual database (SQLite handles that)).

• so roughly speaking Room only needs to have the context so that it can ascertain /data/data/a.a.so75008030kotlinroomgetinstancewithoutcontext/databases/testit.db (in the case of the demo).

So if you cannot use the applicationContext method then you can circumvent the need to provide the context, if using a singleton approach AND if after instantiating the singleton.

Perhaps consider this demo:-

First some pretty basic DB Stuff (table (@Entity annotated class), DAO functions and @Database annotated abstract class WITH singleton approach). BUT with some additional functions for accessing the instance without the context.

@Entity
data class TestIt(
    @PrimaryKey
    val testIt_id: Long?=null,
    val testIt_name: String
)
@Dao
interface DAOs {
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(testIt: TestIt): Long
    @Query("SELECT * FROM testit")
    fun getAllTestItRows(): List<TestIt>
}

@Database(entities = [TestIt::class], exportSchema = false, version = 1)
abstract class TestItDatabase: RoomDatabase() {
    abstract fun getDAOs(): DAOs

    companion object {
        private var instance: TestItDatabase?=null

        /* Extra/not typical for without a context (if wanted)*/
        fun isInstanceWithoutContextAvailable() : Boolean {
            return instance != null
        }

        /******************************************************/
        /* Extra/not typical for without a context            */
        /******************************************************/
        fun getInstanceWithoutContext(): TestItDatabase? {
            if (instance != null) {
                return instance as TestItDatabase
            }
            return null
        }

        /* Typically  the only function*/
        fun getInstance(context: Context): TestItDatabase {
            if (instance==null) {
                instance = Room.databaseBuilder(context,TestItDatabase::class.java,"testit.db")
                    .allowMainThreadQueries() /* for convenience/brevity of demo */
                    .build()
            }
            return instance as TestItDatabase
        }
    }
}

And to demonstrate (within an activity for brevity) :-

class MainActivity : AppCompatActivity() {
    lateinit var roomInstance: TestItDatabase
    lateinit var dao: DAOs
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        roomInstance = TestItDatabase.getInstance(this) /* MUST be used  before withoutContext functions but could be elsewhere shown here for brevity */
        dao = roomInstance.getDAOs()
        //dao.insert(TestIt(testIt_name = "New001")) /* Removed to test actually doing the database open with the without context */
        logDataWithoutContext()
        addRowWithoutContext()
        addRowWithApplicationContext()
        logDataWithoutContext()
    }

    private fun logDataWithoutContext() {
        Log.d("${TAG}_LDWC","Room DB Instantiated = ${TestItDatabase.isInstanceWithoutContextAvailable()}")
        for (t in TestItDatabase.getInstanceWithoutContext()!!.getDAOs().getAllTestItRows()) {
            Log.d("${TAG}_LDWC_DATA","TestIt Name is ${t.testIt_name} ID is ${t.testIt_id}")
        }
    }

    private fun addRowWithoutContext() {
        Log.d("${TAG}_LDWC","Room DB Instantiated = ${TestItDatabase.isInstanceWithoutContextAvailable()}")
        if (TestItDatabase.getInstanceWithoutContext()!!.getDAOs()
                .insert(TestIt(System.currentTimeMillis(),"NEW AS PER ID (the time to millis) WITHOUT CONTEXT")) > 0) {
            Log.d("${TAG}_ARWC_OK","Row successfully inserted.")
        } else {
            Log.d("${TAG}_ARWC_OUCH","Row was not successfully inserted (duplicate ID)")
        }
    }

    private fun addRowWithApplicationContext() {
        TestItDatabase.getInstance(applicationContext).getDAOs().insert(TestIt(System.currentTimeMillis() / 1000,"NEW AS PER ID (the time to seconds) WITH CONTEXT"))
    }
}

The result output to the log showing that the database access, either way, worked:-

2023-01-05 12:45:39.020 D/DBINFO_LDWC: Room DB Instantiated = true
2023-01-05 12:45:39.074 D/DBINFO_LDWC: Room DB Instantiated = true
2023-01-05 12:45:39.077 D/DBINFO_ARWC_OK: Row successfully inserted.
2023-01-05 12:45:39.096 D/DBINFO_LDWC: Room DB Instantiated = true
2023-01-05 12:45:39.098 D/DBINFO_LDWC_DATA: TestIt Name is NEW AS PER ID (the time to seconds) WITH CONTEXT ID is 1672883139
2023-01-05 12:45:39.098 D/DBINFO_LDWC_DATA: TestIt Name is NEW AS PER ID (the time to millis) WITHOUT CONTEXT ID is 1672883139075 

• note that the shorter id was the last added but appears first due to it being selected first as it appears earlier in the index that the SQlite Query Optimiser would have used (aka the Primary Key).
  • basically the same date time second wise but the first insert included milliseconds whilst the insert via AddRowWithApplicationContext drops the milliseconds.