Hey there, let's work through this problem together—building a plug-and-play Android library that integrates a database can hit snags with ObjectBox's single-instance rule, but we've got solid solutions for both ObjectBox and alternative databases.

Option 1: Stick with ObjectBox (Two Approaches) #

Approach A: Reuse the Host App's ObjectBox Instance #

This is the cleanest approach because it avoids multiple database instances entirely. Your library will rely on the host app's already initialized BoxStore instead of creating its own.

1. In your library, create a helper class to hold the shared BoxStore:

object LibraryObjectBoxHelper {
    private lateinit var boxStore: BoxStore

    // Call this from the host app's Application class
    fun init(store: BoxStore) {
        boxStore = store
    }

    // Helper to get boxes for your library's entities
    fun <T> getBox(entityClass: Class<T>): Box<T> {
        check(::boxStore.isInitialized) {
            "LibraryObjectBoxHelper must be initialized first! Call init() from the host app."
        }
        return boxStore.boxFor(entityClass)
    }
}

2. In the host app's Application class, initialize your library after setting up ObjectBox:

class MyHostApp : Application() {
    override fun onCreate() {
        super.onCreate()
        // Initialize ObjectBox for the host app
        val hostBoxStore = MyObjectBox.builder().androidContext(this).build()
        // Pass the instance to your library
        LibraryObjectBoxHelper.init(hostBoxStore)
    }
}

3. Important: Make sure the host app's ObjectBox setup includes your library's entities. In the host app's build.gradle (or build.gradle.kts), add your library's entity package to the ObjectBox configuration:

objectBox {
    entities = ["com.yourlibrary.entities.**"]
}

Approach B: Create a Separate ObjectBox Database for the Library #

If your library needs a completely isolated database (no shared entities with the host), you can configure ObjectBox to use a unique database name and storage directory. This bypasses the single-instance restriction because ObjectBox treats different named/pathed databases as separate instances.

// In your library, initialize the isolated database
fun getLibraryBoxStore(context: Context): BoxStore {
    return MyObjectBox.builder()
        .androidContext(context.applicationContext)
        .name("MyLibrary_Database") // Unique name to avoid conflicts
        .directory(File(context.filesDir, "library_objectbox")) // Separate storage folder
        .build()
}

Just remember to manage this instance as a singleton in your library to avoid accidental multiple initializations.

Option 2: Switch to Room (Better for Plug-and-Play Libraries) #

Room is designed to support multiple independent database instances in a single app, making it ideal for plug-and-play libraries. You can package your library's database entirely within the library, no host app setup required.

1. Define your library's Room database and DAO:

// Entity class in your library
@Entity(tableName = "library_items")
data class LibraryItem(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val data: String
)

// DAO interface
@Dao
interface LibraryItemDao {
    @Insert
    suspend fun insertItem(item: LibraryItem)

    @Query("SELECT * FROM library_items")
    suspend fun getAllItems(): List<LibraryItem>
}

// Database class with singleton instance
@Database(entities = [LibraryItem::class], version = 1)
abstract class LibraryRoomDatabase : RoomDatabase() {
    abstract fun libraryItemDao(): LibraryItemDao

    companion object {
        @Volatile
        private var INSTANCE: LibraryRoomDatabase? = null

        fun getInstance(context: Context): LibraryRoomDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    LibraryRoomDatabase::class.java,
                    "library_room_db" // Unique database name
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

2. Use the database in your library:

// Example usage in a library class
class LibraryDataManager(context: Context) {
    private val dao = LibraryRoomDatabase.getInstance(context).libraryItemDao()

    suspend fun saveData(data: String) {
        dao.insertItem(LibraryItem(data = data))
    }
}

This approach is fully self-contained—host apps don't need to do any extra setup to use your library's database.

Final Recommendations #

• If you need ObjectBox: Use Approach A (reuse host instance) for efficiency and shared state. Use Approach B only if isolation is mandatory.
• If you want zero-fuss plug-and-play: Go with Room. It eliminates the single-instance headache entirely and integrates seamlessly with Android's architecture components.

内容的提问来源于stack exchange，提问作者ArchFever