KMP के लिए Room डेटाबेस सेट अप करना

रूम परसिस्टेंस लाइब्रेरी, SQLite को लेकर एक ऐब्स्ट्रैक्शन लेयर उपलब्ध कराती है, ताकि डेटाबेस को ज़्यादा अच्छे से ऐक्सेस किया जा सके. साथ ही, SQLite की सभी सुविधाओं का इस्तेमाल किया जा सके. इस पेज पर, Kotlin Multiplatform (केएमपी) प्रोजेक्ट में रूम का इस्तेमाल करने के बारे में बताया गया है. रूम का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, रूम का इस्तेमाल करके, डेटा को किसी स्थानीय डेटाबेस में सेव करना लेख पढ़ें या हमारे आधिकारिक सैंपल देखें.

डिपेंडेंसी सेट अप करना

अपने केएमपी प्रोजेक्ट में रूम सेट अप करने के लिए, अपने केएमपी मॉड्यूल की build.gradle.kts फ़ाइल में आर्टफ़ैक्ट के लिए डिपेंडेंसी जोड़ें.

libs.versions.toml फ़ाइल में डिपेंडेंसी तय करें:

[versions]
room = "2.8.4"
sqlite = "2.6.2"
ksp = "<kotlinCompatibleKspVersion>"

[libraries]
androidx-sqlite-bundled = { module = "androidx.sqlite:sqlite-bundled", version.ref = "sqlite" }
androidx-room-runtime = { module = "androidx.room:room-runtime", version.ref = "room" }
androidx-room-compiler = { module = "androidx.room:room-compiler", version.ref = "room" }

# Optional SQLite Wrapper available in version 2.8.0 and higher
androidx-room-sqlite-wrapper = { module = "androidx.room:room-sqlite-wrapper", version.ref = "room" }

[plugins]
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
androidx-room = { id = "androidx.room", version.ref = "room" }

रूम स्कीमा और KSP प्लगिन को कॉन्फ़िगर करने के लिए, रूम Gradle प्लगिन जोड़ें.

plugins {
  alias(libs.plugins.ksp)
  alias(libs.plugins.androidx.room)
}

रूम रनटाइम डिपेंडेंसी और बंडल की गई SQLite लाइब्रेरी जोड़ें:

commonMain.dependencies {
  implementation(libs.androidx.room.runtime)
  implementation(libs.androidx.sqlite.bundled)
}

// Optional when using Room SQLite Wrapper
androidMain.dependencies {
  implementation(libs.androidx.room.sqlite.wrapper)
}

केएसपी डिपेंडेंसी को रूट dependencies ब्लॉक में जोड़ें. ध्यान दें कि आपको अपने ऐप्लिकेशन के इस्तेमाल किए जाने वाले सभी टारगेट जोड़ने होंगे. ज़्यादा जानने के लिए, Kotlin Multiplatform के साथ केएसपी देखें.

dependencies {
    add("kspAndroid", libs.androidx.room.compiler)
    add("kspIosSimulatorArm64", libs.androidx.room.compiler)
    add("kspIosX64", libs.androidx.room.compiler)
    add("kspIosArm64", libs.androidx.room.compiler)
    // Add any other platform target you use in your project, for example kspDesktop
}

रूम स्कीमा डायरेक्ट्री तय करें. ज़्यादा जानकारी के लिए, स्कीमा की जगह रूम Gradle प्लगिन का इस्तेमाल करके सेट करना देखें.

room {
    schemaDirectory("$projectDir/schemas")
}

डेटाबेस क्लास तय करना

आपको अपने शेयर किए गए केएमपी मॉड्यूल के सामान्य सोर्स सेट में, डीएओ और एंटिटी के साथ @Database एनोटेशन वाली डेटाबेस क्लास बनानी होगी. इन क्लास को सामान्य सोर्स में रखने से, इन्हें सभी टारगेट प्लैटफ़ॉर्म पर शेयर किया जा सकेगा.

// shared/src/commonMain/kotlin/Database.kt

@Database(entities = [TodoEntity::class], version = 1)
@ConstructedBy(AppDatabaseConstructor::class)
abstract class AppDatabase : RoomDatabase() {
  abstract fun getDao(): TodoDao
}

// The Room compiler generates the `actual` implementations.
@Suppress("KotlinNoActualForExpect")
expect object AppDatabaseConstructor : RoomDatabaseConstructor<AppDatabase> {
    override fun initialize(): AppDatabase
}

RoomDatabaseConstructor इंटरफ़ेस के साथ expect ऑब्जेक्ट का एलान करने पर, रूम कंपाइलर actual लागू करने की प्रोसेस जनरेट करता है. Android Studio, यह चेतावनी दिखा सकता है. इसे @Suppress("KotlinNoActualForExpect") के साथ दबाया जा सकता है:

Expected object 'AppDatabaseConstructor' has no actual declaration in module`

इसके बाद, नया डीएओ इंटरफ़ेस तय करें या किसी मौजूदा इंटरफ़ेस को commonMain में ले जाएं:

// shared/src/commonMain/kotlin/TodoDao.kt

@Dao
interface TodoDao {
  @Insert
  suspend fun insert(item: TodoEntity)

  @Query("SELECT count(*) FROM TodoEntity")
  suspend fun count(): Int

  @Query("SELECT * FROM TodoEntity")
  fun getAllAsFlow(): Flow<List<TodoEntity>>
}

अपनी एंटिटी को commonMain में तय करें या ले जाएं:

// shared/src/commonMain/kotlin/TodoEntity.kt

@Entity
data class TodoEntity(
  @PrimaryKey(autoGenerate = true) val id: Long = 0,
  val title: String,
  val content: String
)

प्लैटफ़ॉर्म के हिसाब से डेटाबेस बिल्डर बनाना

हर प्लैटफ़ॉर्म पर रूम को इंस्टैंशिएट करने के लिए, आपको डेटाबेस बिल्डर तय करना होगा. एपीआई का यह हिस्सा, प्लैटफ़ॉर्म के हिसाब से सोर्स सेट में होना ज़रूरी है. इसकी वजह यह है कि फ़ाइल सिस्टम एपीआई में अंतर होता है.

Android

Android पर, डेटाबेस की जगह आम तौर पर Context.getDatabasePath() एपीआई से मिलती है. डेटाबेस इंस्टेंस बनाने के लिए, डेटाबेस पाथ के साथ Context तय करें.

// shared/src/androidMain/kotlin/Database.android.kt

fun getDatabaseBuilder(context: Context): RoomDatabase.Builder<AppDatabase> {
  val appContext = context.applicationContext
  val dbFile = appContext.getDatabasePath("my_room.db")
  return Room.databaseBuilder<AppDatabase>(
    context = appContext,
    name = dbFile.absolutePath
  )
}

iOS

iOS पर डेटाबेस इंस्टेंस बनाने के लिए, NSFileManager का इस्तेमाल करके डेटाबेस पाथ उपलब्ध कराएं. यह आम तौर पर NSDocumentDirectory में मौजूद होता है.

// shared/src/iosMain/kotlin/Database.ios.kt

fun getDatabaseBuilder(): RoomDatabase.Builder<AppDatabase> {
    val dbFilePath = documentDirectory() + "/my_room.db"
    return Room.databaseBuilder<AppDatabase>(
        name = dbFilePath,
    )
}

private fun documentDirectory(): String {
  val documentDirectory = NSFileManager.defaultManager.URLForDirectory(
    directory = NSDocumentDirectory,
    inDomain = NSUserDomainMask,
    appropriateForURL = null,
    create = false,
    error = null,
  )
  return requireNotNull(documentDirectory?.path)
}

जेवीएम (डेस्कटॉप)

डेटाबेस इंस्टेंस बनाने के लिए, Java या Kotlin एपीआई का इस्तेमाल करके डेटाबेस पाथ उपलब्ध कराएं.

// shared/src/jvmMain/kotlin/Database.desktop.kt

fun getDatabaseBuilder(): RoomDatabase.Builder<AppDatabase> {
    val dbFile = File(System.getProperty("java.io.tmpdir"), "my_room.db")
    return Room.databaseBuilder<AppDatabase>(
        name = dbFile.absolutePath,
    )
}

डेटाबेस को इंस्टैंशिएट करना

प्लैटफ़ॉर्म के हिसाब से बनाए गए किसी कंस्ट्रक्टर से RoomDatabase.Builder पाने के बाद, सामान्य कोड में रूम डेटाबेस के बाकी हिस्से को कॉन्फ़िगर किया जा सकता है. साथ ही, डेटाबेस को इंस्टैंशिएट भी किया जा सकता है.

// shared/src/commonMain/kotlin/Database.kt

fun getRoomDatabase(
    builder: RoomDatabase.Builder<AppDatabase>
): AppDatabase {
  return builder
      .setDriver(BundledSQLiteDriver())
      .setQueryCoroutineContext(Dispatchers.IO)
      .build()
}

SQLite ड्राइवर चुनना

कोड के पिछले स्निपेट में, setDriver बिल्डर फ़ंक्शन को कॉल किया गया है, ताकि यह तय किया जा सके कि रूम डेटाबेस को किस SQLite ड्राइवर का इस्तेमाल करना चाहिए. ये ड्राइवर, टारगेट प्लैटफ़ॉर्म के हिसाब से अलग-अलग होते हैं. कोड के पिछले स्निपेट में, BundledSQLiteDriver का इस्तेमाल किया गया है. यह सुझाया गया ड्राइवर है. इसमें सोर्स से कंपाइल किया गया SQLite शामिल होता है. इससे सभी प्लैटफ़ॉर्म पर SQLite का सबसे सही और अप-टू-डेट वर्शन मिलता है.

अगर आपको ओएस से मिले SQLite का इस्तेमाल करना है, तो प्लैटफ़ॉर्म के हिसाब से सोर्स सेट में setDriver एपीआई का इस्तेमाल करें. इससे प्लैटफ़ॉर्म के हिसाब से ड्राइवर तय किया जाता है. उपलब्ध ड्राइवर लागू करने के बारे में जानने के लिए, ड्राइवर लागू करने की प्रोसेस देखें. इनमें से कोई भी तरीका इस्तेमाल किया जा सकता है:

• androidMain में AndroidSQLiteDriver
• NativeSQLiteDriver में iosMain

NativeSQLiteDriver का इस्तेमाल करने के लिए, आपको -lsqlite3 लिंकर विकल्प देना होगा, ताकि iOS ऐप्लिकेशन, सिस्टम SQLite से डाइनैमिक तरीके से लिंक हो सके.

// shared/build.gradle.kts

kotlin {
    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach { iosTarget ->
        iosTarget.binaries.framework {
            baseName = "TodoApp"
            isStatic = true
            // Required when using NativeSQLiteDriver
            linkerOpts.add("-lsqlite3")
        }
    }
}

कोरूटीन कॉन्टेक्स्ट सेट करना (ज़रूरी नहीं)

Android पर मौजूद RoomDatabase ऑब्जेक्ट को, डेटाबेस की कार्रवाइयां करने के लिए, RoomDatabase.Builder.setQueryExecutor() का इस्तेमाल करके, शेयर किए गए ऐप्लिकेशन एक्ज़ीक्यूटर के साथ कॉन्फ़िगर किया जा सकता है. हालांकि, यह ज़रूरी नहीं है.

एक्ज़ीक्यूटर, केएमपी के साथ काम नहीं करते. इसलिए, रूम का setQueryExecutor() एपीआई, commonMain में उपलब्ध नहीं है. इसके बजाय, RoomDatabase ऑब्जेक्ट को CoroutineContext के साथ कॉन्फ़िगर करना होगा. इसे RoomDatabase.Builder.setCoroutineContext() का इस्तेमाल करके सेट किया जा सकता है. अगर कोई कॉन्टेक्स्ट सेट नहीं किया जाता है, तो RoomDatabase ऑब्जेक्ट डिफ़ॉल्ट रूप से Dispatchers.IO का इस्तेमाल करेगा.

कोड को छोटा करना और धुंधला करना

अगर प्रोजेक्ट को छोटा किया गया है या धुंधला किया गया है, तो आपको ProGuard का यह नियम शामिल करना होगा, ताकि रूम, डेटाबेस की परिभाषा के जनरेट किए गए लागू करने की प्रोसेस को ढूंढ सके:

-keep class * extends androidx.room.RoomDatabase { <init>(); }

Kotlin Multiplatform पर माइग्रेट करना

रूम को मूल रूप से Android लाइब्रेरी के तौर पर डेवलप किया गया था. बाद में इसे केएमपी पर माइग्रेट किया गया. इस दौरान, एपीआई की कंपैटिबिलिटी पर फ़ोकस किया गया. रूम का केएमपी वर्शन, प्लैटफ़ॉर्म के हिसाब से और Android के लिए बने वर्शन से थोड़ा अलग होता है. इन अंतरों के बारे में यहां बताया गया है.

Support SQLite से SQLite ड्राइवर पर माइग्रेट करना

SupportSQLiteDatabase और androidx.sqlite.db में अन्य एपीआई के सभी इस्तेमाल को SQLite ड्राइवर एपीआई के साथ रीफ़ैक्टर करना होगा, इसकी वजह यह है कि androidx.sqlite.db में मौजूद एपीआई, सिर्फ़ Android के लिए हैं. ध्यान दें कि केएमपी पैकेज से अलग पैकेज है.

बैकवर्ड कंपैटिबिलिटी के लिए और जब तक RoomDatabase को SupportSQLiteOpenHelper.Factory के साथ कॉन्फ़िगर किया जाता है (उदाहरण के लिए, कोई SQLiteDriver सेट नहीं किया जाता), तब तक रूम 'कंपैटिबिलिटी मोड' में काम करता है. इस मोड में, Support SQLite और SQLite ड्राइवर एपीआई, दोनों उम्मीद के मुताबिक काम करते हैं. इससे इंक्रीमेंटल माइग्रेशन की सुविधा मिलती है. इसलिए, आपको एक ही बदलाव में, Support SQLite के सभी इस्तेमाल को SQLite ड्राइवर में बदलने की ज़रूरत नहीं होती.

रूम SQLite रैपर का इस्तेमाल करना (ज़रूरी नहीं)

androidx.room:room-sqlite-wrapper आर्टफ़ैक्ट, माइग्रेशन के दौरान SQLiteDriver और SupportSQLiteDatabase के बीच ब्रिज करने के लिए एपीआई उपलब्ध कराता है.

SQLiteDriver के साथ कॉन्फ़िगर किए गए RoomDatabase से SupportSQLiteDatabase पाने के लिए, नए एक्सटेंशन फ़ंक्शन RoomDatabase.getSupportWrapper() का इस्तेमाल करें. यह कंपैटिबिलिटी रैपर, SQLiteDriver को अपनाने के दौरान, SupportSQLiteDatabase के मौजूदा इस्तेमाल को बनाए रखने में मदद करता है. इसे अक्सर RoomDatabase.openHelper.writableDatabase से पाया जाता है. खास तौर पर, उन कोडबेस के लिए जिनमें SupportSQLite एपीआई का बड़े पैमाने पर इस्तेमाल किया जाता है और जो BundledSQLiteDriver का इस्तेमाल करना चाहते हैं.

माइग्रेशन सबक्लास को बदलना

माइग्रेशन सबक्लास को SQLite ड्राइवर के काउंटरपार्ट पर माइग्रेट करना होगा:

object Migration_1_2 : Migration(1, 2) {
  override fun migrate(connection: SQLiteConnection) {
    // …
  }
}

class AutoMigrationSpec_1_2 : AutoMigrationSpec {
  override fun onPostMigrate(connection: SQLiteConnection) {
    // …
  }
}

object Migration_1_2 : Migration(1, 2) {
  override fun migrate(db: SupportSQLiteDatabase) {
    // …
  }
}

class AutoMigrationSpec_1_2 : AutoMigrationSpec {
  override fun onPostMigrate(db: SupportSQLiteDatabase) {
    // …
  }
}

डेटाबेस कॉलबैक को बदलना

डेटाबेस कॉलबैक को SQLite ड्राइवर के काउंटरपार्ट पर माइग्रेट करना होगा:

object MyRoomCallback : RoomDatabase.Callback() {
  override fun onCreate(connection: SQLiteConnection) {
    // …
  }

  override fun onDestructiveMigration(connection: SQLiteConnection) {
    // …
  }

  override fun onOpen(connection: SQLiteConnection) {
    // …
  }
}

object MyRoomCallback : RoomDatabase.Callback() {
  override fun onCreate(db: SupportSQLiteDatabase) {
    // …
  }

  override fun onDestructiveMigration(db: SupportSQLiteDatabase) {
    // …
  }

  override fun onOpen(db: SupportSQLiteDatabase) {
    // …
  }
}

@RawQuery डीएओ फ़ंक्शन को बदलना

@RawQuery के साथ एनोटेट किए गए ऐसे फ़ंक्शन जिन्हें Android के अलावा अन्य प्लैटफ़ॉर्म के लिए कंपाइल किया जाता है, उन्हें SupportSQLiteQuery के बजाय RoomRawQuery टाइप का पैरामीटर तय करना होगा.

@Dao
interface TodoDao {
  @RawQuery
  suspend fun getTodos(query: RoomRawQuery): List<TodoEntity>
}

suspend fun AppDatabase.getTodosWithLowercaseTitle(title: String): List<TodoEntity> {
    val query = RoomRawQuery(
        sql = "SELECT * FROM TodoEntity WHERE title = ?",
        onBindStatement = {
            it.bindText(1, title.lowercase())
        }
    )

    return todoDao().getTodos(query)
}

@Dao
interface TodoDao {
  @RawQuery
  suspend fun getTodos(query: SupportSQLiteQuery): List<TodoEntity>
}

suspend fun AndroidOnlyDao.getTodosWithLowercaseTitle(title: String): List<TodoEntity> {
  val query = SimpleSQLiteQuery(
      query = "SELECT * FROM TodoEntity WHERE title = ?",
      bindArgs = arrayOf(title.lowercase())
  )
  return getTodos(query)
}

ब्लॉक करने वाले डीएओ फ़ंक्शन को बदलना

रूम को, एसिंक्रोनस kotlinx.coroutines लाइब्रेरी से फ़ायदा मिलता है. यह लाइब्रेरी, Kotlin की ओर से कई प्लैटफ़ॉर्म के लिए उपलब्ध कराई जाती है. बेहतर तरीके से काम करने के लिए, केएमपी प्रोजेक्ट में कंपाइल किए गए डीएओ के लिए, suspend फ़ंक्शन लागू किए जाते हैं. हालांकि, मौजूदा कोडबेस के साथ बैकवर्ड कंपैटिबिलिटी बनाए रखने के लिए, androidMain में लागू किए गए डीएओ के लिए यह ज़रूरी नहीं है. केएमपी के लिए रूम का इस्तेमाल करते समय, Android के अलावा अन्य प्लैटफ़ॉर्म के लिए कंपाइल किए गए सभी डीएओ फ़ंक्शन, suspend फ़ंक्शन होने चाहिए.

@Query("SELECT * FROM Todo")
suspend fun getAllTodos(): List<Todo>

@Transaction
suspend fun transaction() { … }

@Query("SELECT * FROM Todo")
fun getAllTodos(): List<Todo>

@Transaction
fun blockingTransaction() { … }

रिएक्टिव टाइप को फ़्लो में बदलना

सभी डीएओ फ़ंक्शन को सस्पेंड फ़ंक्शन होना ज़रूरी नहीं है. LiveData या RxJava के Flowable जैसे रिएक्टिव टाइप दिखाने वाले डीएओ फ़ंक्शन को सस्पेंड फ़ंक्शन में नहीं बदला जाना चाहिए. हालांकि, LiveData जैसे कुछ टाइप, केएमपी के साथ काम नहीं करते. रिएक्टिव रिटर्न टाइप वाले डीएओ फ़ंक्शन को कोरूटीन फ़्लो पर माइग्रेट करना होगा.

@Query("SELECT * FROM Todo")
fun getTodosFlow(): Flow<List<Todo>>

@Query("SELECT * FROM Todo")
fun getTodosLiveData(): LiveData<List<Todo>>

ट्रांज़ैक्शन एपीआई को बदलना

रूम केएमपी के लिए डेटाबेस ट्रांज़ैक्शन एपीआई, लिखने (useWriterConnection) और पढ़ने (useReaderConnection) के ट्रांज़ैक्शन के बीच अंतर कर सकते हैं.

val database: RoomDatabase = …
database.useWriterConnection { transactor ->
  transactor.immediateTransaction {
    // perform database operations in transaction
  }
}

val database: RoomDatabase = …
database.withTransaction {
  // perform database operations in transaction
}

लिखने के ट्रांज़ैक्शन

लिखने के ट्रांज़ैक्शन का इस्तेमाल करके, पक्का करें कि कई क्वेरी, डेटा को एटॉमिक तरीके से लिखें, ताकि रीडर लगातार डेटा को ऐक्सेस कर सकें. इसके लिए, useWriterConnection का इस्तेमाल, ट्रांज़ैक्शन के इन तीन टाइप के साथ किया जा सकता है:

• immediateTransaction: राइट-अहेड लॉगिंग (WAL) मोड (डिफ़ॉल्ट) में, इस तरह का ट्रांज़ैक्शन शुरू होने पर लॉक हासिल करता है. हालांकि, रीडर पढ़ना जारी रख सकते हैं. ज़्यादातर मामलों में, यह सबसे अच्छा विकल्प है.

• deferredTransaction: ट्रांज़ैक्शन, पहले राइट स्टेटमेंट तक लॉक हासिल नहीं करेगा. इस तरह के ट्रांज़ैक्शन का इस्तेमाल, ऑप्टिमाइज़ेशन के तौर पर तब करें, जब आपको पक्का न हो कि ट्रांज़ैक्शन के दौरान, राइट ऑपरेशन की ज़रूरत होगी या नहीं. उदाहरण के लिए, अगर आपने किसी प्लेलिस्ट से गाने मिटाने के लिए ट्रांज़ैक्शन शुरू किया है. इसके लिए, सिर्फ़ प्लेलिस्ट का नाम दिया गया है और वह प्लेलिस्ट मौजूद नहीं है, तो राइट (मिटाने) ऑपरेशन की ज़रूरत नहीं होगी.

• exclusiveTransaction: यह मोड, WAL मोड में immediateTransaction की तरह ही काम करता है. अन्य जर्नल मोड में, यह ट्रांज़ैक्शन के दौरान, अन्य डेटाबेस कनेक्शन को डेटाबेस पढ़ने से रोकता है.

पढ़ने के ट्रांज़ैक्शन

डेटाबेस से लगातार कई बार पढ़ने के लिए, पढ़ने के ट्रांज़ैक्शन का इस्तेमाल करें. उदाहरण के लिए, जब आपके पास दो या उससे ज़्यादा अलग-अलग क्वेरी हों और आपने JOIN क्लॉज़ का इस्तेमाल न किया हो. रीडर कनेक्शन में, सिर्फ़ डिफ़र्ड ट्रांज़ैक्शन की अनुमति होती है. रीडर कनेक्शन में, immediate या exclusive ट्रांज़ैक्शन शुरू करने की कोशिश करने पर, गड़बड़ी आएगी. इसकी वजह यह है कि इन्हें 'लिखने' के ऑपरेशन माना जाता है.

val database: RoomDatabase = …
database.useReaderConnection { transactor ->
  transactor.deferredTransaction {
      // perform database operations in transaction
  }
}

Kotlin Multiplatform में उपलब्ध नहीं है

Android के लिए उपलब्ध कुछ एपीआई, Kotlin Multiplatform में उपलब्ध नहीं हैं.

क्वेरी कॉलबैक

क्वेरी कॉलबैक को कॉन्फ़िगर करने के लिए, ये एपीआई सामान्य में उपलब्ध नहीं हैं. इसलिए, ये Android के अलावा अन्य प्लैटफ़ॉर्म पर उपलब्ध नहीं हैं.

• RoomDatabase.Builder.setQueryCallback
• RoomDatabase.QueryCallback

हम आने वाले समय में, रूम के किसी वर्शन में क्वेरी कॉलबैक की सुविधा जोड़ने की योजना बना रहे हैं.

क्वेरी कॉलबैक RoomDatabase.Builder.setQueryCallback के साथ RoomDatabase को कॉन्फ़िगर करने वाला एपीआई, कॉलबैक इंटरफ़ेस RoomDatabase.QueryCallback के साथ सामान्य में उपलब्ध नहीं है. इसलिए, यह Android के अलावा अन्य प्लैटफ़ॉर्म पर उपलब्ध नहीं है .

डेटाबेस का अपने-आप बंद होना

टाइम आउट के बाद, अपने-आप बंद होने की सुविधा चालू करने वाला एपीआई, RoomDatabase.Builder.setAutoCloseTimeout सिर्फ़ Android पर उपलब्ध है. यह अन्य प्लैटफ़ॉर्म पर उपलब्ध नहीं है.

पहले से पैकेज किया गया डेटाबेस

मौजूदा डेटाबेस (यानी, पहले से पैकेज किया गया डेटाबेस) का इस्तेमाल करके RoomDatabase बनाने के लिए, ये एपीआई सामान्य में उपलब्ध नहीं हैं. इसलिए, ये Android के अलावा अन्य प्लैटफ़ॉर्म पर उपलब्ध नहीं हैं. ये एपीआई हैं:

• RoomDatabase.Builder.createFromAsset
• RoomDatabase.Builder.createFromFile
• RoomDatabase.Builder.createFromInputStream
• RoomDatabase.PrepackagedDatabaseCallback

हम आने वाले समय में, रूम के किसी वर्शन में पहले से पैकेज किए गए डेटाबेस की सुविधा जोड़ने की योजना बना रहे हैं.

एक से ज़्यादा इंस्टेंस इनवैलिडेशन

एक से ज़्यादा इंस्टेंस इनवैलिडेशन की सुविधा चालू करने वाला एपीआई, RoomDatabase.Builder.enableMultiInstanceInvalidation सिर्फ़ Android पर उपलब्ध है. यह सामान्य या अन्य प्लैटफ़ॉर्म पर उपलब्ध नहीं है.