Please use the form below to provide your feedback. Because your feedback is valuable to us, the information you submit in this form is recorded in our issue tracking system (JIRA), which is publicly available. You can track the status of your feedback using the ticket number displayed in the dialog once you submit the form.

A newer version of this documentation is available.

View Latest

Kotlin

    March 23, 2025
    + 12

    Description — Couchbase Lite for Android — Kotlin support
    Related Content — Databases | Documents | Indexing |

    Introduction

    Couchbase Lite Android 3.0.15 introduces full idiomatic support for Kotlin apps, out-of-the-box.

    Kotlin developers can now build apps using common Kotlin Patterns, that integrate seamlessly with Couchbase Lite for Android and have full feature parity with the Java API; including some convenient Kotlin Extensions to get you started.

    Key features include:

    • Nullability annotations

    • Named parameters

    • Kotlin Flows, for asynchronous event notifications

    Java support and functionality continues for Android.

    Kotlin Extensions

    In addition to having full co-compatible access to the existing Java API, Kotlin developers can also access a number of Kotlin Extensions.

    The Kotlin Extensions package includes:

    • Configuration Factories for the configuration of important Couchbase Lite objects such as Databases, Replicators and Listeners.

    • Change Flows that monitor key Couchbase Lite objects fpr change using Kotlin features such as, Co-routines and Flows.

    See: Kotlin Extensions for extension API docs

    Configuration Factories

    Couchbase Lite provides a set of ConfigurationFactories and CommonConfigurationFactories, these allow use of named parameters to specify property settings.

    Database

    Use DatabaseConfigurationFactory to create a DatabaseConfiguration object, overriding the receiver’s values with the passed parameters.

    kotlin
    Copy
    database = Database(
  "getting-started",
  DatabaseConfigurationFactory.create(context.filesDir.absolutePath)
  )

    Replication

    Use ReplicatorConfigurationFactory to create a ReplicatorConfiguration object, overriding the receiver’s values with the passed parameters.

    kotlin
    Copy
    val replicator =
  Replicator(
    ReplicatorConfigurationFactory.create(
      database = database,
      target = URLEndpoint(URI("ws://localhost:4984/getting-started-db")),
      type = ReplicatorType.PUSH_AND_PULL,
      authenticator = BasicAuthenticator("sync-gateway", "password".toCharArray())
      )
  )

    Full Text Search

    Use FullTextIndexConfigurationFactory to create a FullTextIndexConfiguration object, overriding the receiver’s values with the passed parameters.

    kotlin
    Copy
    db.createIndex("fts_index",
      FullTextIndexConfigurationFactory.create(expressions = ["name","location"])
    )

    Indexing

    Use ValueIndexConfigurationFactory to create a ValueIndexConfiguration object, overriding the receiver’s values with the passed parameters.

    kotlin
    Copy
    db.createIndex("name_and_location_index",
      ValueIndexConfigurationFactory.create(expressions = ["name","location"])
    )

    Logs

    Use LogFileConfigurationFactory to create a LogFileConfiguration object, overriding the receiver’s values with the passed parameters.

    kotlin
    Copy
    Database.log.file.let {
  it.config = LogFileConfigurationFactory.create(
    context.cacheDir.absolutePath, (1)
    maxSize = 10240, (2)
    maxRotateCount = 5, (3)
    usePlainText = false
    ) (4)
    it.level = LogLevel.INFO (5)

  }

    Flows

    These wrappers use Flowables to monitor for changes.

    Database Change Flow

    Use the databaseChangeFlow(Database,Executor) to monitor database change events.

    kotlin
    Copy
    val updatedDocs = db.databaseChangeFlow()
    .map { it.documentIDs }
    .asLiveData()

    Document Change Flow

    Use documentChangeFlow(Database,String,Executor) to monitor changes to a document.

    kotlin
    Copy
    val docModDate = db.documentChangeFlow("1001", null)
    .map { it.database.getDocument(it.documentID)?.getString("lastModified") }
    .asLiveData()

    Replicator Change Flow

    Use replicatorChangeFlow(Replicator,Executor) to monitor replicator changes.

    kotlin
    Copy
    val replState = repl.replicatorChangesFlow()
    .map { it.status.activityLevel }
    .asLiveData()

    Document Replicator Change Flow

    Use documentReplicationFlow(Replicator,Executor) to monitor document changes during replication.

    kotlin
    Copy
    val replicatedDocs = repl.documentReplicationFlow(testSerialExecutor)
    .map { update -> update.documents }
    .onEach { listView.setUpdated(it) }
    .collect()

    Query Change Flow

    Use queryChangeFlow(Query,Executor) to monitor document changes during replication.

    kotlin
    Copy
    var liveQuery: LiveData<List<Any>?>? = null

@ExperimentalCoroutinesApi
fun watchQuery(query: Query): LiveData<List<Any>?> {
    val queryFlow = query.queryChangeFlow()
        .map {
            val err = it.error
            if (err != null) {
                throw err
            }
            it.results?.allResults()?.flatMap { it.toList() }
        }
        .asLiveData()
    liveQuery = queryFlow
    return queryFlow
}

    Related Content

    How to . . .
    Learn more . . .
    Dive Deeper . . .

    Mobile Forum | Blog | Tutorials