Build and Run

    (1)
    // One-off initialization
    private fun init(context: Context) {
        CouchbaseLite.init(context)
        Log.i(TAG, "CBL Initialized")

    }

    (2)
    // Create a database
    fun createDb(dbName: String) {
        database = Database(dbName)
        Log.i(TAG, "Database created: $dbName")
    }

    (3)
    // Create a new named collection (like a SQL table)
    // in the database's default scope.
    fun createCollection(collName: String) {
        collection = database!!.createCollection(collName)
        Log.i(TAG, "Collection created: $collection")
    }

    (4)
    // Create a new document (i.e. a record)
    // and save it in a collection in the database.
    fun createDoc(): String {
        val mutableDocument = MutableDocument()
            .setFloat("version", 2.0f)
            .setString("language", "Java")
        collection?.save(mutableDocument)
        return mutableDocument.id
    }

    (5)
    // Retrieve immutable document and log the database generated
    // document ID and some document properties
    fun retrieveDoc(docId: String) {
        collection?.getDocument(docId)
            ?.let {
                Log.i(TAG, "Document ID :: ${docId}")
                Log.i(TAG, "Learning :: ${it.getString("language")}")
            }
            ?: Log.i(TAG, "No such document :: $docId")
    }

    (6)
    // Retrieve immutable document and update `language` property
    // document ID and some document properties
    fun updateDoc(docId: String) {
        collection?.getDocument(docId)?.let {
            collection?.save(
                it.toMutable().setString("language", "Kotlin")
            )
        }
    }

    (7)
    // Create a query to fetch documents with language == Kotlin.
    fun queryDocs() {
        val coll = collection ?: return
        val query: Query = QueryBuilder.select(SelectResult.all())
            .from(DataSource.collection(coll))
            .where(Expression.property("language").equalTo(Expression.string("Kotlin")))
        query.execute().use { rs ->
            Log.i(TAG, "Number of rows :: ${rs.allResults().size}")
        }
    }

    (8)
    // OPTIONAL -- if you have Sync Gateway Installed you can try replication too.
    // Create a replicator to push and pull changes to and from the cloud.
    // Be sure to hold a reference to the Replicator to prevent it from being GCed
    fun replicate(uri: String): Flow<ReplicatorChange>? {
        val coll = collection ?: return null

        val collConfig = CollectionConfiguration()
            .setPullFilter { doc, _ -> "Java" == doc.getString("language") }

        val repl = Replicator(
            ReplicatorConfigurationFactory.newConfig(
                target = URLEndpoint(URI(uri)),
                collections = mapOf(setOf(coll) to collConfig),
                type = ReplicatorType.PUSH_AND_PULL,
                authenticator = BasicAuthenticator("sync-gateway", "password".toCharArray())
            )
        )

        // Listen to replicator change events.
        val changes = repl.replicatorChangesFlow()

        // Start replication.
        repl.start()
        replicator = repl

        return changes
    }

    (1)
    // One-off initialization
    private void init() {
        CouchbaseLite.init(GettingStartedApplication.getAppContext());
        Log.i(TAG, "CBL Initialized");
    }

    (2)
    // Create a database
    public void createDb(String dbName) throws CouchbaseLiteException {
        database = new Database(dbName);
        Log.i(TAG, "Database created: " + dbName);
    }

    (3)
    // Create a new named collection (like a SQL table)
    // in the database's default scope.
    public void createCollection(String collName) throws CouchbaseLiteException {
        collection = database.createCollection(collName);
        Log.i(TAG, "Collection created: " + collection);
    }

    (4)
    // Create a new document (i.e. a record)
    // and save it in a collection in the database.
    public String createDoc() throws CouchbaseLiteException {
        MutableDocument mutableDocument = new MutableDocument()
            .setFloat("version", 2.0f)
            .setString("language", "Java");
        collection.save(mutableDocument);
        return mutableDocument.getId();
    }

    (5)
    // Retrieve immutable document and log the database generated
    // document ID and some document properties
    public void retrieveDoc(String docId) throws CouchbaseLiteException {
        Document document = collection.getDocument(docId);
        if (document == null) {
            Log.i(TAG, "No such document :: " + docId);
        }
        else {
            Log.i(TAG, "Document ID :: " + document.getId());
            Log.i(TAG, "Learning :: " + document.getString("language"));
        }
    }

    (6)
    // Retrieve and update a document.
    public void updateDoc(String docId) throws CouchbaseLiteException {
        Document document = collection.getDocument(docId);
        if (document != null) {
            collection.save(
                document.toMutable().setString("language", "Kotlin"));
        }
    }

    (7)
    // Create a query to fetch documents with language == Kotlin.
    public void queryDocs() throws CouchbaseLiteException {
        Query query = QueryBuilder.select(SelectResult.all())
            .from(DataSource.collection(collection))
            .where(Expression.property("language").equalTo(Expression.string("Kotlin")));

        try (ResultSet rs = query.execute()) {
            Log.i(TAG, "Number of rows :: " + rs.allResults().size());
        }
    }

    (8)
    // OPTIONAL -- if you have Sync Gateway Installed you can try replication too.
    // Create a replicator to push and pull changes to and from the cloud.
    // Be sure to hold a reference somewhere to prevent the Replicator from being GCed
    public ListenerToken replicate(String uri, ReplicatorChangeListener listener) throws URISyntaxException {
        CollectionConfiguration collConfig = new CollectionConfiguration()
            .setPullFilter((doc, flags) -> "Java".equals(doc.getString("language")));

        ReplicatorConfiguration replConfig =
            new ReplicatorConfiguration(
                new URLEndpoint(new URI(uri)))
                .addCollection(collection, collConfig)
                .setType(ReplicatorType.PUSH_AND_PULL)
                .setAuthenticator(new BasicAuthenticator("sync-gateway", "password".toCharArray()));

        replicator = new Replicator(replConfig);

        // Listen to replicator change events.
        // Use `token.remove()` to stop the listener

        ListenerToken token = replicator.addChangeListener(listener);

        // Start replication.
        replicator.start();

        return token;
    }