Mohit Sharma


# Introduction 

### What is Jetpack Compose?

As per [Google](https://developer.android.com/jetpack/compose), *“Jetpack Compose is Android’s modern toolkit for building native UI. It simplifies and accelerates UI development on Android. Quickly bring your app to life with less code, powerful tools, and intuitive Kotlin APIs”.*

In my words, it’s a revolutionary **declarative way** of creating (or should I say composing 😄) UI in Android using Kotlin. Until now, we created layouts using XML and never dared to create via code (except for custom views, no choice) due to its complexity, non-intuitiveness, and maintenance issues.

But now it’s different!

### What is Declarative UI?


>  You know, imperative is like **how** you do something, and declarative is more like **what** you do, or something.

Doesn’t that make sense? It didn’t to me as well in the first go 😄. In my opinion, imperative is more like an algorithm to perform any operation step by step, and declarative is the code that is built using the algorithm, more to do ***what*** works.

In Android, we normally create an XML of a layout and then update (sync) each element every time based on the input received, business rules using findViewById/Kotlin Semantics/View Binding/ Data Binding 😅.

But with **Compose**, we simply write a function that has both elements and rules, which is called whenever information gets updated. In short, a part of the UI is recreated every time **without** **performance** **issues**.

This philosophy or mindset will in turn help you write smaller (Single Responsibility principle) and reusable functions.


### Why is Compose Getting So Popular?

I’m not really sure, but out of the many awesome features, the ones I’ve loved most are:

1. **Faster release cycle**: Bi-weekly, so now there is a real chance that if you get any issue with **composing,** it can be fixed soon. Hopefully!

2. **Interoperable**: Similar to Kotlin, Compose is also interoperable with earlier UI design frameworks.

3. **Jetpack library and material component built-in support**: Reduce developer efforts and time in building beautiful UI with fewer lines of code ❤️.

4. **Declarative UI**: With a new way of building UI, we are now in harmony with all other major frontend development frameworks like SwiftUI, Flutter, and React Native, making it easier for the developer to use concepts/paradigms from other platforms.

### Current state

As of 29th July, the first stable version was [released 1.0](https://android-developers.googleblog.com/2021/07/jetpack-compose-announcement.html), meaning **Compose is production-ready**.


# Get Started with Compose

### For using Compose, we need to set up a few things:


 1. Kotlin v*1.5.10* and above, so let’s update our dependency in the project-level `build.gradle` file.

    ```kotlin
    plugins {
            id 'org.jetbrains.kotlin:android' version '1.5.10'
    } 
    ```

2. Minimum  *API level 21*

    ```kotlin
    android {
         defaultConfig {
             ...
             minSdkVersion 21
        }
    }    
    ```

3. Enable Compose 

    ```kotlin
        android { 

            defaultConfig {
                ...
                minSdkVersion 21
            }

            buildFeatures {
                // Enables Jetpack Compose for this module
                compose true
            }
        }
    ```
    
4. Others like min Java or Kotlin compiler and compose compiler

    ```kotlin
        android {
            defaultConfig {
                ...
                minSdkVersion 21
            }

            buildFeatures {
                // Enables Jetpack Compose for this module
                compose true
            }
            ...

            // Set both the Java and Kotlin compilers to target Java 8.
           compileOptions {
                sourceCompatibility JavaVersion.VERSION_1_8
                targetCompatibility JavaVersion.VERSION_1_8
            }
            kotlinOptions {
                jvmTarget = "1.8"
            }

            composeOptions {
                kotlinCompilerExtensionVersion '1.0.0'
            }
        }
    ```

5. At last compose dependency for build UI

    ```kotlin
        dependencies {

            implementation 'androidx.compose.ui:ui:1.0.0'
            // Tooling support (Previews, etc.)
            implementation 'androidx.compose.ui:ui-tooling:1.0.0'
            // Foundation (Border, Background, Box, Image, Scroll, shapes, animations, etc.)
            implementation 'androidx.compose.foundation:foundation:1.0.0'
            // Material Design
            implementation 'androidx.compose.material:material:1.0.0'
            // Material design icons
            implementation 'androidx.compose.material:material-icons-core:1.0.0'
            implementation 'androidx.compose.material:material-icons-extended:1.0.0'
            // Integration with activities
            implementation 'androidx.activity:activity-compose:1.3.0'
            // Integration with ViewModels
            implementation 'androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha07'
            // Integration with observables
            implementation 'androidx.compose.runtime:runtime-livedata:1.0.0'

        }
    ```


### Mindset 

While composing UI, you need to unlearn various types of layouts and remember just one thing: Everything is a composition of *rows* and *columns*.

![](https://cdn-images-1.medium.com/max/2108/1*VhWkcj7aUWNdE7e3CYJdQw.png)

But what about ConstraintLayout, which makes life so easy and is very useful for building complex UI? We can still use it ❤️, but in a little different way.


### First Compose Project — Tweet Details Screen



For our learning curve experience, I decided to re-create this screen in Compose.

![](https://cdn-images-1.medium.com/max/2000/1*yeFRhDs5R1CP4zaEomCmjQ.png)



So let’s get started. 

Create a new project with Compose project as a template and open MainActivity.

If you don’t see the Compose project, then update Android Studio to the latest version.

```kotlin
    class MainActivity : ComponentActivity() {
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContent {
                ComposeTweetTheme {
               
                    .... 
                }
            }
        }
    }
```

Now to add a view to the UI, we need to create a function with `@Composable` annotation, which makes it a Compose function.

Creating our first layout of the view, toolbar

```kotlin
    @Composable
    fun getAppTopBar() {
        TopAppBar(
            title = {
                Text(text = stringResource(id = R.string.app_name))
            },
            elevation = 0.*dp
        )
    }
```

To preview the UI rendered in Android Studio, we can use `@Preview` annotation.

![](https://cdn-images-1.medium.com/max/4856/1*ukkhEHOGJ2B7WlPpDxHHzg.png)

TopAppBar is an inbuilt material component for adding a topbar to our application.

Let’s create a little more complex view, user profile view

![](https://cdn-images-1.medium.com/max/2000/1*EgdJyqYqrpsl2w67GSrHIw.png)

As discussed earlier, in Compose, we have only rows and columns, so let’s break our UI 👇, where the red border represents columns and green is rows, and complete UI as a row in the screen.

![](https://cdn-images-1.medium.com/max/2000/1*ICvhTxCdsy8RXR8jsMfO3g.png)

So let’s create our compose function for user profile view with our root row.

![](https://cdn-images-1.medium.com/max/3984/1*v-SIoDDh9pQSTtJ6ooSyqQ.png)

You will notice the modifier argument in the Row function. This is the Compose way of adding formatting to the elements, which is uniform across all the elements.

Creating a round imageview is very simple now. No need for any library or XML drawable as an overlay.

```kotlin
Image(
            painter = painterResource(id = R.drawable.ic_profile),
            contentDescription = "Profile Image",
            modifier = Modifier
                .size(36.dp)
                .clip(CircleShape)
                .border(1.dp, Color.Transparent, CircleShape),
            contentScale = ContentScale.Crop
        )
 ```

Again we have a `modifier` for updating our Image (AKA ImageView) with `clip` to make it rounded and `contentScale` to scale the image. 

Similarly, adding a label will be a piece of cake now.

```kotlin
     Text (text = userName, fontSize = 20.sp)
```

Now let’s put it all together in rows and columns to complete the view.

```kotlin
@Composable
fun userProfileView(userName: String, userHandle: String) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .wrapContentHeight()
            .padding(all = 12.dp),
        verticalAlignment = Alignment.CenterVertically
    ) {
        Image(
            painter = painterResource(id = R.drawable.ic_profile),
            contentDescription = "Profile Image",
            modifier = Modifier
                .size(36.dp)
                .clip(CircleShape)
                .border(1.dp, Color.Transparent, CircleShape),
            contentScale = ContentScale.Crop
        )
        Column(
            modifier = Modifier
                .padding(start = 12.dp)
        ) {
            Text(text = userName, fontSize = 20.sp, fontWeight = FontWeight.Bold)
            Text(text = userHandle, fontSize = 14.sp)
        }
    }
}
```


Another great example is to create a Text Label with two styles. We know that traditionally doing that is very painful.

Let’s see the Compose way of doing it.

```kotlin
Text(
            text = buildAnnotatedString {
                withStyle(style = SpanStyle(fontWeight = FontWeight.ExtraBold)) {
                    append("3")
                }
                append(" ")
                withStyle(style = SpanStyle(fontWeight = FontWeight.Normal)) {

                    append(stringResource(id = R.string.retweets))
                }
            },
            modifier = Modifier.padding(end = 8.dp)
        )

```

![](https://cdn-images-1.medium.com/max/2008/1*Sam96dWBFuNELaztMUAf0g.png)

That’s it!! I hope you’ve seen the ease of use and benefit of using Compose for building UI.

![](https://cdn-images-1.medium.com/max/2000/1*eLrryz9etGCak2M3YPi1Ww.png)

Just remember everything in Compose is rows and columns, and the order of attributes matters. You can check out my [Github repo](https://github.com/mongodb-developer/compose-tweets-android) complete example which also demonstrates the rendering of data using `viewModel`.

>If you have questions, please head to our [developer community website](https://www.mongodb.com/community/forums/) where the MongoDB engineers and the MongoDB community will help you build your next big idea with MongoDB.

Learn how to get started with Jetpack Compose on Android

Unboxing Jetpack Compose: My First Compose App

> In this article, we will explore and learn how to build a splash screen with SplashScreen API, which was introduced in Android 12.

<br>

## What is a Splash Screen?

It is the first view that is shown to a user as soon as you tap on the app icon. If you notice a blank white screen (for
a short moment) after tapping on your favourite app, it means it doesn't have a splash screen.

## Why/When Do I Need It?

Often, the splash screen is seen as a differentiator between normal and professional apps. Some use cases where a splash
screen fits perfectly are:

* When we want to download data before users start using the app.
* If we want to promote app branding and display your logo for a longer period of time, or just have a more immersive
  experience that smoothly takes you from the moment you tap on the icon to whatever the app has to offer.

Until now, creating a splash screen was never straightforward and always required some amount of boilerplate code added
to the application, like creating SplashActivity with no view, adding a timer for branding promotion purposes, etc. With
SplashScreen API, all of this is set to go.

## Show Me the Code

### Step 1: Creating a Theme

Even for the new `SplashScreen` API, we need to create a theme but in the `value-v31` folder as a few parameters are
supported only in **Android 12**. Therefore, create a folder named `value-v31` under `res` folder and add `theme.xml`
to it.

And before that, let’s break our splash screen into pieces for simplification.

![Splash Screen placeholder](https://developer.android.com/about/versions/12/images/splash-screen-composition.png)

* Point 1 represents the icon of the screen.
* Point 2 represents the background colour of the splash screen icon.
* Point 3 represents the background colour of the splash screen.
* Point 4 represents the space for branding logo if needed.

Now, let's assign some values to the corresponding keys that describe the different pieces of the splash screen.

```xml

<style name="SplashActivity" parent="Theme.AppCompat.NoActionBar">

    
    <item name="android:windowSplashScreenBackground">#FFFFFF</item>

    
    <item name="android:windowSplashScreenIconBackgroundColor">#000000</item>

    
    <item name="android:windowSplashScreenAnimatedIcon">@drawable/ic_realm_logo_250</item>

    
    <item name="android:windowSplashScreenBrandingImage">@drawable/relam_horizontal</item>
</style>
```

<br/>
In case you want to use an app icon (or don't have a separate icon) as `windowSplashScreenAnimatedIcon`, you ignore this
parameter and by default, it will take your app icon.

> **Tips & Tricks**: If your drawable icon is getting cropped on the splash screen, create an app icon from the image
> and then replace the content of `windowSplashScreenAnimatedIcon` drawable with the `ic_launcher_foreground.xml`.
>
> For `windowSplashScreenBrandingImage`, I couldn't find any alternative. Do share in the comments if you find one.

### Step 2: Add the Theme to Activity

Open AndroidManifest file and add a theme to the activity.

``` xml
<activity
 android:theme="@style/SplashActivity">
</activity>
```

In my view, there is no need for a new `activity` class for the splash screen, which traditionally was required. And now
we are all set for the new **Android 12** splash screen.

<img src="https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screenshot_1632115543_4547ee45af.png" alt="drawing" width="200"/>

Adding animation to the splash screen is also a piece of cake. Just update the icon drawable with
`AnimationDrawable` and `AnimatedVectorDrawable` drawable and custom parameters for the duration of the animation.

```xml

<item name="android:windowSplashScreenAnimationDuration">1000</item>
```

Earlier, I mentioned that the new API helps with the initial app data download use case, so let's see that in action.

In the splash screen activity, we can register for `addOnPreDrawListener` listener which will help to hold off the first
draw on the screen, until data is ready.

``` Kotlin
 private val viewModel: MainViewModel by viewModels()

 override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
     addInitialDataListener()
     loadAppView()
 }

 private fun addInitialDataListener() {
     val content: View = findViewById(android.R.id.content)
     // This would be called until true is not returned from the condition
     content.viewTreeObserver.addOnPreDrawListener {
         return@addOnPreDrawListener viewModel.isAppReady.value ?: false
     }
 }

 private fun loadAppView() {
     binding = ActivityMainBinding.inflate(layoutInflater)
     setContentView(binding.root)
```

<br/>

> **Tips & Tricks**: While developing Splash screen you can return `false` for `addOnPreDrawListener`, so the next screen is not rendered and you can validate the splash screen easily.

### Summary

I really like the new `SplashScreen` API, which is very clean and easy to use, getting rid of SplashScreen activity
altogether. There are a few things I disliked, though.

1. The splash screen background supports only single colour. We're waiting for support of vector drawable backgrounds.
2. There is no design spec available for icon and branding images, which makes for more of a hit and trial game. I still
   couldn't fix the banding image, in my example.
3. Last but not least, SplashScreen UI side feature(`theme.xml`) is only supported from Android 12 and above, so we
   can't get rid of the old code for now.

You can also check out the complete working example from my GitHub repo. Note: Just running code on the device will show
you white. To see the example, close the app recent tray and then click on the app icon again.

[Github Repo link](https://github.com/mongodb-developer/SplashScreen-Android)

Hope this was informative and enjoyed reading it.

In this article, we will explore and learn how to build a splash screen with SplashScreen API, which was introduced in Android 12.

Building Splash Screen Natively, Android 12, Kotlin

## Introduction

Android has been on the edge of evolution for a while recently, with updates to `androidx.activity:activity-ktx` to `1.2.0`. It has deprecated `startActivityForResult` in favour of `registerForActivityResult`.

It was one of the first fundamentals that any Android developer has learned, and the backbone of Android's way of communicating between two components. API design was simple enough to get started quickly but had its cons, like how it’s hard to find the caller in real-world applications (except for cmd+F in the project 😂), getting results on the fragment, results missed if the component is recreated, conflicts with the same request code, etc.

Let’s try to understand how to use the new API with a few examples.

## Example 1: Activity A calls Activity B for the result

Old School:

```kotlin
// Caller 
val intent = Intent(context, Activity1::class.java)
startActivityForResult(intent, REQUEST_CODE)

// Receiver 
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (resultCode == Activity.RESULT_OK && requestCode == REQUEST_CODE) {
        val value = data?.getStringExtra("input")
    }
}
```

New Way:

```kotlin

// Caller 
val intent = Intent(context, Activity1::class.java)
getResult.launch(intent)

// Receiver 
private val getResult =
    registerForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) {
        if (it.resultCode == Activity.RESULT_OK) {
            val value = it.data?.getStringExtra("input")
        }
    }
```

As you would have noticed, `registerForActivityResult` takes two parameters. The first defines the type of action/interaction needed (`ActivityResultContracts`) and the second is a callback function where we receive the result.

Nothing much has changed, right? Let’s check another example.

## Example 2: Start external component like the camera to get the image:

```kotlin
//Caller
getPreviewImage.launch(null)

//Receiver 
private val getPreviewImage = registerForActivityResult(ActivityResultContracts.TakePicture { bitmap ->
    // we get bitmap as result directly
})
```

The above snippet is the complete code getting a preview image from the camera. No need for permission request code, as this is taken care of automatically for us!

Another benefit of using the new API is that it forces developers to use the right contract. For example, with `ActivityResultContracts.TakePicture()` — which returns the full image — you need to pass a `URI` as a parameter to `launch`, which reduces the development time and chance of errors.

Other default contracts available can be found [here](https://developer.android.com/reference/androidx/activity/result/contract/package-summary).

---

## Example 3: Fragment A calls Activity B for the result

This has been another issue with the old system, with no clean implementation available, but the new API works consistently across activities and fragments. Therefore, we refer and add the snippet from example 1 to our fragments.

---

## Example 4: Receive the result in a non-Android class

Old Way: 😄

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/giphy_f99f638e0c.webp)

With the new API, this is possible using `ActivityResultRegistry` directly.

```kotlin
class MyLifecycleObserver(private val registry: ActivityResultRegistry) : DefaultLifecycleObserver {

    lateinit var getContent: ActivityResultLauncher<String>

    override fun onCreate(owner: LifecycleOwner) {
        getContent = registry.register("key", owner, GetContent()) { uri ->
            // Handle the returned Uri
        }
    }

    fun selectImage() {
        getContent.launch("image/*")
    }
}

class MyFragment : Fragment() {
    lateinit var observer: MyLifecycleObserver

    override fun onCreate(savedInstanceState: Bundle?) {
        // ...

        observer = MyLifecycleObserver(requireActivity().activityResultRegistry)
        lifecycle.addObserver(observer)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        val selectButton = view.findViewById<Button>(R.id.select_button)

        selectButton.setOnClickListener {
            // Open the activity to select an image
            observer.selectImage()
        }
    }
}
```

## Summary

I have found the registerForActivityResult useful and clean. Some of the pros, in my opinion, are:

1. Improve the code readability, no need to remember to jump to `onActivityResult()` after `startActivityForResult`.

2. `ActivityResultLauncher` returned from `registerForActivityResult` used to launch components, clearly defining the input parameter for desired results.

3. Removed the boilerplate code for requesting permission from the user. 

Hope this was informative and enjoyed reading it.


Learn the benefits and usage of registerForActivityResult for Android in Kotlin.

StartActivityForResult is Deprecated!

Christian Melchior

In this blogpost we are announcing v0.4.1 of the Realm Kotlin Multiplatform SDK. This release contains a significant architectural departure from previous releases of Realm Kotlin as well as other Realm SDK’s, making it much more compatible with modern reactive frameworks like [Kotlin Flows](https://kotlinlang.org/docs/flow.html). We believe this change will hugely benefit users in the Kotlin ecosystem.

## **Some background**
The Realm Java and Kotlin SDK’s have historically exposed a model of interacting with data we call Live Objects. Its primary design revolves around database objects acting as Live Views into the underlying database. 

This was a pretty novel approach when Realm Java was first released 7 years ago. It had excellent performance characteristics and made it possible to avoid a wide range of nasty bugs normally found in concurrent systems.

However, it came with one noticeable drawback: Thread Confinement.

Thread-confinement was not just an annoying restriction. This was what guaranteed that users of the API would always see a consistent view of the data, even across decoupled queries. Which was also the reason that Kotlin Native adopted a [similar memory model](https://kotlinlang.org/docs/native-concurrency.html)

But it also meant that you manually had to open and close realms on each thread where you needed data, and it was impossible to pass objects between threads [without additional boilerplate](https://docs.mongodb.com/realm/sdk/android/advanced-guides/threading/#communication-across-threads). 

Both of which put a huge burden on developers.

More importantly, this approach conflicts with another model for working with concurrent systems, namely [Functional Reactive Programming (FRP)](https://en.wikipedia.org/wiki/Functional_reactive_programming). In the Android ecosystem this was popularized by the [RxJava framework](https://github.com/ReactiveX/RxJava) and also underpins Kotlin Flows.

In this mode, you see changes to data as immutable events in a stream, allowing complex mapping and transformations. Consistency is then guaranteed by the semantics of the stream; each operation is carried out in sequence so no two threads operate on the same object at the same time. 

In this model, however, it isn’t uncommon for different operations to happen on different threads, breaking the thread-confinement restrictions of Realm. 

Looking at the plethora of frameworks that support this model (React JS, RxJava, Java Streams, Apple Combine Framework and Kotlin Flows) It becomes clear that this way of reasoning about concurrency is here to stay.

For that reason we decided to change our API to work much better in this context.

## The new API

So today we are introducing a new architecture, which we internally have called the Frozen Architecture. It looks similar to the old API, but works in a fundamentally different way.

Realm instances are now thread-safe, meaning that you can use the same instance across the entire application, making it easier to pass around with e.g. dependency injection.

All query results and objects from the database are frozen or immutable by default. They can now be passed freely between threads. This also means that they no longer automatically are kept up to date. Instead you must register change listeners in order to be notified about any change.

All modifications to data must happen by using a special instance of a `MutableRealm`, which is only available inside write transactions. Objects inside a write transaction are still live.

## Opening a Realm

Opening a realm now only needs to happen once. It can either be stored in a global variable or made available via dependency injection.

```
// Global App variable
class MyApp: Application() {
   companion object {
       private val config = RealmConfiguration(schema = setOf(Person::class))
       public val REALM = Realm(config)
   }
}



// Using dependency injection
val koinModule = module {
   single { RealmConfiguration(schema = setOf(Person::class)) }
   single { Realm(get()) }
}

// Realms are now thread safe
val realm = Realm(config)
val t1 = Thread {
   realm.writeBlocking { /* ... */ }
}
val t2 = Thread {
   val queryResult = realm.objects(Person::class)
}

```

You can now safely keep your realm instance open for the lifetime of the application. You only need to close your realm when interacting with the realm file itself, such as when deleting the file or compacting it.

```
// Close Realm to free native resources
realm.close()
```

## Creating Data
You can only write within write closures, called `write` and `writeBlocking`. Writes happen through a [MutableRealm](https://docs.mongodb.com/realm-sdks/kotlin/latest/-realm%20-kotlin%20-multiplatform%20-s-d-k/io.realm/-mutable-realm/index.html) which is a [receiver](https://stackoverflow.com/questions/45875491/what-is-a-receiver-in-kotlin) of the  `writeBlocking` and `write` lambdas. 

Blocking:

```
val jane = realm.writeBlocking { 
   val unmanaged = Person("Jane")
   copyToRealm(unmanaged)
}
```

Or run as a suspend function. Realm automatically dispatch writes to a write dispatcher backed by a background thread, so launching this from a scope on the UI thread like [`viewModelScope`](https://developer.android.com/topic/libraries/architecture/coroutines#viewmodelscope
) is safe:

```
CoroutineScope(Dispatchers.Main).launch {

   // Write automatically happens on a background dispatcher
   val jane = realm.write {
       val unmanaged = Person("Jane")
       // Add unmanaged objects
       copyToRealm(unmanaged)
   }

   // Objects returned from writes are automatically frozen
   jane.isFrozen() // == true

   // Access any property.
   // All properties are still lazy-loaded.
   jane.name // == "Jane"
}
```

## **Updating data**

Since everything is frozen by default, you need to retrieve a live version of the object that you want to update, then write to that live object to update the underlying data in the realm.

```
CoroutineScope(Dispatchers.Main).launch {
   // Create initial object   
   val jane = realm.write {
       copyToRealm(Person("Jane"))
   }
  
   realm.write {
       // Find latest version and update it
       // Note, this always involves a null-check
       // as another thread might have deleted the
       // object.
       // This also works on objects without
       // primary keys.
       findLatest(jane)?.apply {
           name = "Jane Doe"
       }
   }
}
```

## Observing Changes

Changes to all Realm classes are supported through Flows. Standard change listener API support is coming in a future release. 

```
val jane = getJane()
CoroutineScope(Dispatchers.Main).launch {
   // Updates are observed using Kotlin Flow
   val flow: Flow<Person> = jane.observe()
   flow.collect {
       // Listen to changes to the object
       println(it.name)
   }
}
```

As all Realm objects are now frozen by default, it is now possible to pass objects between different dispatcher threads without any additional boilerplate:

```
val jane = getJane()
CoroutineScope(Dispatchers.Main).launch {

   // Run mapping/transform logic in the background
   val flow: Flow<String> = jane.observe()
       .filter { it.name.startsWith("Jane") }
       .flowOn(Dispatchers.Unconfined)

   // Before collecting on the UI thread
   flow.collect {
       println(it.name)
   }
}
```

## Pitfalls

With the change to frozen architecture, there are some new pitfalls to be aware of:

Unrelated queries are no longer guaranteed to run on the same version.

```
// A write can now happen between two queries
val results1: RealmResults<Person> = realm.objects(Person::class)
val results2: RealmResults<Person> = realm.objects(Person::class)

// Resulting in subsequent queries not returning the same result
results1.version() != results2.version()
results1.size != results2.size

```
We will introduce API’s in the future that can guarantee that all operations within a certain scope are guaranteed to run on the same version. Making it easier to combine the results of multiple queries.

Depending on the schema, it is also possible to navigate the entire object graph for a single object. It is only unrelated queries that risk this behaviour. 

Storing objects for extended periods of time can lead to [Version Pinning](https://docs.mongodb.com/realm/sdk/android/fundamentals/realms/#realm-file-size). This results in an increased realm file size. It is thus not advisable to store Realm Objects in global variables unless they are unmanaged. 

```
// BAD: Store a global managed object
MyApp.GLOBAL_OBJECT = realm.objects(Person::class).first()

// BETTER: Copy data out into an unmanaged object
val person = realm.objects(Person::class).first()
MyApp.GLOBAL_OBJECT = Person(person.name)

```

We will monitor how big an issue this is in practise and will introduce future API’s that can work around this if needed. It is currently possible to detect this happening by setting `RealmConfiguration.Builder.maxNumberOfActiveVersions()`
 
Ultimately we believe that these drawbacks are acceptable given the advantages we otherwise get from this architecture, but we’ll keep a close eye on these as the API develops further.

## Conclusion 
We are really excited about this change as we believe it will fundamentally make it a lot easier to use Realm Kotlin in Android and will also enable you to use Realm in Kotlin Multilplatform projects.

You can read more about how to get started at https://docs.mongodb.com/realm/sdk/kotlin-multiplatform/. We encourage you to try out this new version and leave any feedback at https://github.com/realm/realm-kotlin/issues/new. Sample projects can be found [here](https://github.com/realm/realm-kotlin-samples).

The SDK is still in alpha and as such none of the API’s are considered stable, but it is possible to follow our progress at https://github.com/realm/realm-kotlin. 

If you are interested about learning more about how this works under the hood, you can also read more [here](https://docs.google.com/document/d/1bGfjbKLD6DSBpTiVwyorSBcMqkUQWedAmmS_VAhL8QU/edit)

Happy hacking!

In this blogpost we are announcing v0.4.1 of the Realm Kotlin Multiplatform SDK. This release contains a significant architectural departure from previous releases of Realm Kotlin as well as other Realm SDK’s, making it much more compatible with modern reactive frameworks like Kotlin Flows. We believe this change will hugely benefit users in the Kotlin ecosystem.


Realm Kotlin 0.4.1 Announcement

Nabil Hachicha

![](https://miro.medium.com/max/1400/1*MS0GvkkuVA8XszTdEnOhaw.jpeg)  
  
Realm Kotlin 0.6.0  
==================  
  
We just released v0.6.0 of [Realm Kotlin](https://github.com/realm/realm-kotlin/). It contains support for Kotlin/JVM, indexed fields as well as a number of bug fixes.  
  
Kotlin/JVM support  
==================  
  
The new Realm Kotlin SDK was designed from its inception to support Multiplatform. So far, we’ve been focusing on [KMM](https://kotlinlang.org/docs/kmm-overview.html) targets i.e Android and iOS but there was a push from the community to add JVM support, this is now possible using 0.6.0 by enabling the following DSL into your project:  
  
```  
kotlin { jvm() // other targets …}  

```  
  
Now your app can target:  
  
Android, iOS, macOS and JVM (Linux _since Centos 7_, macOS _x86\_64_ and Windows _8.1 64_).  
  
What to build with Kotlin/JVM?  
==============================  
  
*   You can build desktop applications using Compose Desktop (see examples: [MultiplatformDemo](https://github.com/realm/realm-kotlin-samples/tree/main/MultiplatformDemo) and [FantasyPremierLeague](https://github.com/joreilly/FantasyPremierLeague)).  
*   You can build a classic Java console application (see [JVMConsole](https://github.com/realm/realm-kotlin-samples/tree/main/JVMConsole)).  
*   You can run your Android tests on JVM (note there’s a current issue on IntelliJ where the execution of Android tests from the common source-set is not possible, see/upvote :) [https://youtrack.jetbrains.com/issue/KTIJ-15152](https://youtrack.jetbrains.com/issue/KTIJ-15152), alternatively you can still run them as a Gradle task).  
  
Where is it installed?  
======================  
  
The native library dependency is extracted from the [cinterop-jar](https://repo1.maven.org/maven2/io/realm/kotlin/cinterop-jvm/0.6.0/) and installed into a default location on your machine:  
  
*   _Linux_:  
  
```  
$HOME/.cache/io.realm.kotlin/  

```  
  
*   _macOS:_  
  
```  
$HOME/Library/Caches/io.realm.kotlin/  

```  
  
*   _Windows:_  
  
```  
%localappdata%\io-realm-kotlin\  

```  
  
Support Indexed fields  
======================  
  
To index a field, use the _@Index_ annotation. Like primary keys, this makes writes slightly slower, but makes reads faster. It’s best to only add indexes when you’re optimizing the read performance for specific situations.  
  
Abstracted public API into interfaces  
=====================================  
  
If you tried out the previous version, you will notice that we did an internal refactoring of the project in order to make public APIs consumable via interfaces instead of classes (ex: [Realm](https://docs.mongodb.com/realm-sdks/kotlin/0.6.0/-realm%20-kotlin%20-multiplatform%20-s-d-k/io.realm/-realm/index.html) and [RealmConfiguration](https://docs.mongodb.com/realm-sdks/kotlin/0.6.0/-realm%20-kotlin%20-multiplatform%20-s-d-k/io.realm/-realm-configuration/index.html)), this should increase decoupling and make mocking and testability easier for developers.  
  
🎉 Thanks for reading. Now go forth and build amazing apps with Realm! As always, we’re around on [GitHub](https://github.com/realm/realm-kotlin), [Twitter](https://twitter.com/realm) and [#realm](https://kotlinlang.slack.com/archives/C6J79CSDP) channel on the official [Kotlin Slack](https://kotlinlang.slack.com/).  
  
See the full [changelog](https://github.com/realm/realm-kotlin/blob/master/CHANGELOG.md#060-2021-10-15) for all the details.

We just released v0.6.0 of Realm Kotlin. It contains support for Kotlin/JVM, indexed fields as well as a number of bug fixes.

Realm Kotlin 0.6.0.

* * *
> Atlas App Services (Formerly Realm )
> 
> Atlas Device Sync (Formerly Realm Sync)
> 
* * *
Welcome back! We really appreciate you coming back and showing your interest in Atlas App Services. This is a follow-up article to [Introduction to Realm Java SDK for Android](/how-to/introduction-realm-sdk-android).  If you haven't read that yet, we recommend you go through it first.

This is a beginner-level article, where we introduce you to Atlas Device Sync. As always, we demonstrate its usage by building an Android app using the MVVM architecture.

## Prerequisites

>
>
>You have created at least one app using Android Studio.
>
>

## What Are We Trying to Solve?

In the [previous article](/how-to/introduction-realm-sdk-android), we learned that the [Realm Java SDK](https://docs.mongodb.com/realm/sdk/android/) is easy to use when working with a local database. But in the world of the internet we want to share our data, so how do we do that with the Realm Mobile Database?

>
>
>**MongoDB Atlas Device Sync**
>
>Atlas Device Sync is the solution to our problem. It's one of the many features provided by [MongoDB Atlas App Services](https://docs.mongodb.com/realm/). It synchronizes the data between client-side Realms and the server-side cloud, [MongoDB Atlas](https://www.mongodb.com/cloud/atlas), without worrying about conflict resolution and error handling.
>
>

The illustration below demonstrates how [MongoDB Atlas Sync](https://docs.mongodb.com/realm/) has simplified the complex architecture:

![Atlas Device Sync has simplified the complex architecture](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/realm_sync_arch_ffbde178d5.gif)

To demonstrate how to use [MongoDB Atlas App Services](https://docs.mongodb.com/realm/) Device Sync, we will extend our previous application, which tracks app views, to use Atlas Device Sync.

## Step 1: Get the Base Code

Clone the original [repo](https://github.com/mongodb-developer/get-started-realm-android-crud-app.git) and rename it "HelloRealmSync."

## Step 2: Enable Atlas Device Sync

Update the `syncEnabled` state as shown below in the Gradle file (at the module level):

``` kotlin
android {
// few other things

  realm {
    syncEnabled = true
  }
}
```

Also, add the `buildConfigField` to `buildTypes` in the same file:

``` kotlin
buildTypes {

   debug {
      buildConfigField "String", "RealmAppId", "\"App Key\""
   }

   release {
     buildConfigField "String", "RealmAppId", "\"App Key\""
   }
}
```

You can ignore the value of `App Key` for now, as it will be covered in a later step.

## Step 3: [Set Up Your Free MongoDB Atlas Cloud Database](https://account.mongodb.com/account/login)

![MongoDB cloud setup](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/realm_sync_android_setup_mongodb_cloud_f4c98b67d2.gif)

Once this is done, we have a cloud database where all our mobile app data can be saved, i.e., [MongoDB Atlas](https://www.mongodb.com/cloud/atlas). Now we are left with linking our cloud database (in Atlas) with the mobile app.

## Step 4: Create a App Services App

![MongoDB Atlas App setup](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/realm_app_setup_5257ea3e24.gif)

In layman's terms, App Services apps on the MongoDB cloud are just links between the data flowing between the mobile apps ([Realm Java SDK](https://docs.mongodb.com/realm/sdk/android/)) and Atlas.

## Step 5: Add the App Services App ID to the Android Project

Copy the  App ID and use it to replace `App Key` in the `build.gradle` file, which we added in **Step 2**.

With this done, [MongoDB Realm](https://docs.mongodb.com/realm/) and your Android App are connected.

## Step 6: Enable Atlas Device Sync and Authentication

[MongoDB Atlas App Services](https://docs.mongodb.com/realm/) is a very powerful tool and has a bunch of cool features from data security to its manipulation.  This is more than sufficient for one application. Let's enable authentication and sync.

### But Why Authentication?

[MongoDB Atlas App Services](https://docs.mongodb.com/realm/) is designed to make apps secure by default, by not allowing an unknown user to access data.

We don't have to force a user to sign up for them to become a known user. We can enable anonymous authentication, which is a win-win for everyone.

So let's enable both of them:

![Enabling anonymous authentication through the MongoDB Atlas UI](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/realm_auth_enable_35ad60836b.gif)

![Enabling  Atlas Device Sync using the MongoDB Atlas UI](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/realm_syn_enable_85e1a14d53.gif)

Let's quickly recap what we have done so far.

In the Android app:
-   Added App Services App ID to the Gradle file.
-   Enabled Atlas Device Sync.

In [MongoDB Atlas](https://docs.mongodb.com/realm/):
-   Set up account.
-   Created a free cluster for [MongoDB Atlas](https://www.mongodb.com/cloud/atlas).
-   Created a App Services app.
-   Enabled anonymous authentication.
-   Enabled sync.

Now, the final piece is to make the necessary modifications to our Android app.

## Step 7: Update the Android App Code

The only code change is to get an instance of the Realm mobile database from the App Services app instance.

1.  Get a App Services app instance from which the Realm instance can be derived:

    ``` kotlin
    val realmSync by lazy {
      App(AppConfiguration.Builder(BuildConfig.RealmAppId).build())
    }
    ```

2.  Update the creation of the View Model:

    ``` kotlin
    private val homeViewModel: HomeViewModel by navGraphViewModels(
    R.id.mobile_navigation,
    factoryProducer = {
      object : ViewModelProvider.Factory {
        @Suppress("UNCHECKED_CAST")
        override fun <T : ViewModel?> create(modelClass: Class<T>): T {
          val realmApp = (requireActivity().application as HelloRealmSyncApp).realmSync
          return HomeViewModel(realmApp) as T
        }
      }
    })
    ```

3.  Update the View Model constructor to accept the App Services app instance:

    ``` kotlin
    class HomeViewModel(private val realmApp: App) : ViewModel() {

    }
    ```

4.  Update the `updateData` method in `HomeViewModel`:

    ``` kotlin
    private fun updateData() {
      _isLoading.postValue(true)

      fun onUserSuccess(user: User) {
        val config = SyncConfiguration.Builder(user, user.id).build()

        Realm.getInstanceAsync(config, object : Realm.Callback() {
           override fun onSuccess(realm: Realm) {
               realm.executeTransactionAsync {
                   var visitInfo = it.where(VisitInfo::class.java).findFirst()
                   visitInfo = visitInfo?.updateCount() ?: VisitInfo().apply {
                       partition = user.id
                       visitCount++
                   }
                   _visitInfo.postValue(it.copyFromRealm(visitInfo))
                   it.copyToRealmOrUpdate(visitInfo)
                   _isLoading.postValue(false)
               }
           }

          override fun onError(exception: Throwable) {
            super.onError(exception)
            //TODO: Implementation pending
            _isLoading.postValue(false)
          }
        })
      }

      realmApp.loginAsync(Credentials.anonymous()) {
        if (it.isSuccess) {
          onUserSuccess(it.get())
        } else {
          _isLoading.postValue(false)
        }
      }
    }
    ```

In the above snippet, we are doing two primary things:

1.  Getting a user instance by signing in anonymously.
2.  Getting a Realm instance using `SyncConfiguration.Builder`.

``` kotlin
SyncConfiguration.Builder(user, user.id).build()
```

Where `user.id` is the partition key we defined in our [MongoDB Atlas](https://docs.mongodb.com/realm/) Sync configuration (Step 6). In simple terms, partition key is an identifier that helps you to get the exact data as per client needs. For more details, please refer to the article on [Atlas Device Sync Partitioning Strategies](/how-to/realm-partitioning-strategies/).

## Step 8: View Your Results in [MongoDB Atlas](https://www.mongodb.com/cloud/atlas)

![Viewing the results in Atlas using the MongoDB Atlas UI](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongo_cluster_result_005cbea69e.gif)

Thank you for reading. You can find the complete working code in our [GitHub repo](https://github.com/mongodb-developer/get-started-realm-sync-android-app.git).

>
>
>If you have questions, please head to our [developer community website](https://community.mongodb.com/) where the MongoDB engineers and the MongoDB community will help you build your next big idea with MongoDB.
>
>


Learn how to use Atlas Device Sync with Android.

Introduction to Atlas Device Sync for Android

This is a beginner article where we introduce you to the [Realm Android SDK](https://docs.mongodb.com/realm/sdk/android/), dive through its features, and illustrate development of the process with a demo application to get you started quickly.

In this article, you will learn how to set up an Android application with the Realm Android SDK, write basic queries to manipulate data, and you'll receive an introduction to Realm Studio, a tool designed to view the local Realm database.

>
>
>Pre-Requisites: You have created at least one app using Android Studio.
>
>

>
>
>**What is Realm?**
>
>Realm is an object database that is simple to embed in your mobile app.  Realm is a developer-friendly alternative to mobile databases such as SQLite and CoreData.
>
>

Before we start, create an Android application. Feel free to skip the step if you already have one.

**Step 0**: Open Android Studio and then select Create New Project. For more information, you can visit the official [Android website](https://developer.android.com/training/basics/firstapp/creating-project).

Now, let's get started on how to add the Realm SDK to your application.

**Step 1**: Add the gradle dependency to the **project** level **build.gradle** file:

``` kotlin
dependencies {
   classpath "com.android.tools.build:gradle:$gradle_version"
   classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   classpath "io.realm:realm-gradle-plugin:10.4.0" // add this line
}
```

Also, add **mavenCentral** as our dependency, which was previously **jCenter** for Realm 10.3.x and below.

``` kotlin
repositories {
   google()
   mavenCentral() // add this line
}
```

``` kotlin
allprojects {
    repositories {
        google()
        mavenCentral() // add this line
    }
}
```

**Step 2**: Add the Realm plugin to the **app** level **build.gradle** file:

``` kotlin
plugins {
   id 'com.android.application'
   id 'kotlin-android'
   id 'kotlin-kapt' // add this line
   id 'realm-android' // add this line
}
```

Keep in mind that order matters. You should add the **realm-android** plugin after **kotlin-kapt**.

We have completed setting up Realm in the project. Sync Gradle so that we can move to the next step.

**Step 3**: Initialize and create our first database:

The Realm SDK needs to be initialized before use. This can be done anywhere (application class, activity, or fragment) but to keep it simple, we recommend doing it in the application class.

``` kotlin
// Ready our SDK
Realm.init(this)
// Creating our db with custom properties
val config = RealmConfiguration.Builder()
   .name("test.db")
   .schemaVersion(1)
   .build()
Realm.setDefaultConfiguration(config)
```

Now that we have the Realm SDK added to our project, let's explore basic CRUD (Create, Read, Update, Delete) operations. To do this, we'll create a small application, building on MVVM design principles.

The application counts the number of times the app has been opened, which has been manipulated to give an illustration of CRUD operation.

1.  Create app view object when opened the first time — **C** R U D
2.  Read app viewed counts—C **R** U D
3.  Update app viewed counts—C R **U** D
4.  Delete app viewed counts— C R U **D**

<figure align="center">
    <img
        style="border-radius: 10px; width: 50%"
        src="https://www.mongodb.com/developer/images/how-to/intro-realm-android/realm-android-app.gif"
        alt="Realm Android App"
    />
</figure>

Once you have a good understanding of the basic operations, then it is fairly simple to apply this to complex data transformation as, in the end, they are nothing but collections of CRUD operations.

Before we get down to the actual task, it's nice to have background knowledge on how Realm works. Realm is built to help developers avoid common pitfalls, like heavy lifting on the main thread, and follow best practices, like reactive programming.

The default configuration of the Realm allows programmers to read data on any thread and write only on the background thread. This configuration can be overwritten with:

``` kotlin
Realm.init(this)
val config = RealmConfiguration.Builder()
   .name("test.db")
   .allowQueriesOnUiThread(false)
   .schemaVersion(1)
   .deleteRealmIfMigrationNeeded()
   .build()
Realm.setDefaultConfiguration(config)
```

In this example, we keep `allowQueriesOnUiThread(true)` which is the default configuration.

Let's get started and create our object class `VisitInfo` which holds the visit count:

``` kotlin
open class VisitInfo : RealmObject() {

   @PrimaryKey
   var id = UUID.randomUUID().toString()

   var visitCount: Int = 0

}
```

In the above snippet, you will notice that we have extended the class with `RealmObject`, which allows us to directly save the object into the Realm.

We can insert it into the Realm like this:

``` kotlin
val db = Realm.getDefaultInstance()
db.executeTransactionAsync {
   val info = VisitInfo().apply {
       visitCount = count
   }
   it.insert(info)
}
```

To read the object, we write our query as:

``` kotlin
val db = Realm.getDefaultInstance()
val visitInfo = db.where(VisitInfo::class.java).findFirst()
```

To update the object, we use:

``` kotlin
val db = Realm.getDefaultInstance()
val visitInfo = db.where(VisitInfo::class.java).findFirst()

db.beginTransaction()
visitInfo.apply {
   visitCount += count
}

db.commitTransaction()
```

And finally, to delete the object:

``` kotlin
val visitInfo = db.where(VisitInfo::class.java).findFirst()
visitInfo?.deleteFromRealm()
```

So now, you will have figured out that it's very easy to perform any operation with Realm. You can also check out the [Github repo](https://github.com/mongodb-developer/get-started-realm-android-crud-app) for the complete application.

The next logical step is how to view data in the database. For that, let's introduce [Realm Studio](https://docs.mongodb.com/realm/studio/).

*Realm Studio is a developer tool for desktop operating systems that allows you to manage Realm database instances.*

Realm Studio is a very straightforward tool that helps you view your local Realm database file. You can install Realm Studio on any platform from <https://docs.mongodb.com/realm/studio/>.

Let's grab our database file from our emulator or real device.

![Animation showing how to get the database file from emulator or real device. The process is explained in the following paragraphs.](https://www.mongodb.com/developer/images/how-to/intro-realm-android/android-studio.gif)

Detailed steps are as follows:

**Step 1**: Go to Android Studio, open "Device File Explorer" from the right-side panel, and then select your emulator.

<figure align="center">
    <img
        style="border-radius: 10px"
        src="https://www.mongodb.com/developer/images/how-to/intro-realm-android/android-studio-data.png"
        alt="Android Studio Data"
    />
</figure>

**Step 2**: Get the Realm file for our app. For this, open the folder named **data** as highlighted above, and then go to the **data** folder again. Next, look for the folder with your package name. Inside the **files** folder, look for the file named after the database you set up through the Realm SDK. In my case, it is **test.db**.

![Android Studio screenshot](https://www.mongodb.com/developer/images/how-to/intro-realm-android/realm-data.png)

**Step 3**: To export, right-click on the file and select "Save As," and
then open the file in Realm Studio.

![Realm Studio screenshot](https://www.mongodb.com/developer/images/how-to/intro-realm-android/realm-studio.png)

Notice the visit count in the `VisitInfo` class (AKA table) which is equivalent to the visit count of the application. That's all, folks.  Hope it helps to solve the last piece of the puzzle.

If you're an iOS developer, please check out [Accessing Realm Data on iOS Using Realm Studio](/how-to/realm-ios-database-access-using-realm-studio/).

>
>
>If you have questions, please head to our [developer community website](https://community.mongodb.com/) where the MongoDB engineers and the MongoDB community will help you build your next big idea with MongoDB.
>
>


Learn how to use the Realm SDK with Android.

Introduction to the Realm SDK for Android


> This article is targeted to existing Realm developers who want to understand how to migrate to Realm Kotlin SDK.

## Introduction

Android has changed a lot in recent years notably after the Kotlin language became a first-class 
citizen, so does the Realm SDK. Realm has recently moved its much-awaited Kotlin SDK to beta 
enabling developers to use Realm more fluently with Kotlin and opening doors to the world of Kotlin 
Multiplatform.

Let's understand the changes required when you migrate from Java to Kotlin SDK starting from setup
till its usage.

## Changes in setup

The new Realm Kotlin SDK is based on Kotlin Multiplatform architecture which enables you to have one
common module for all your data needs for all platforms. But this doesn't mean to use the new SDK
you would have to convert your existing Android app to KMM app right away, you can do that later.

Let's understand the changes needed in the gradle file to use Realm Kotlin SDK, by comparing the
previous implementation with the new one.

In project level `build.gradle`

Earlier with Java SDK

```kotlin
    buildscript {

    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath "com.android.tools.build:gradle:4.1.3"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.31"

        // Realm Plugin 
        classpath "io.realm:realm-gradle-plugin:10.10.1"

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}
```

With Kotlin SDK, we can **delete the Realm plugin** from `dependencies`

```kotlin
    buildscript {

    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath "com.android.tools.build:gradle:4.1.3"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.31"

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}
```

In the module-level `build.gradle`

With Java SDK, we 

1. Enabled Realm Plugin
2. Enabled Sync, if applicable

```groovy

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'kotlin-kapt'
    id 'realm-android'
}
```

```groovy
    android {

    ... ....

    realm {
        syncEnabled = true
    }
}
```

With Kotlin SDK,

1. Replace ``id 'realm-android'`` with  ``id("io.realm.kotlin") version "0.10.0"``

```groovy
    plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'kotlin-kapt'
    id("io.realm.kotlin") version "0.10.0"
}
```

2. Remove the Realm block under android tag

```groovy
    android {
    ... ....

    }
```

3. Add Realm dependency under `dependencies` tag

```groovy
    dependencies {

        implementation("io.realm.kotlin:library-sync:0.10.0")

    }
```

> If you are using only Realm local SDK, then you can add
> ```groovy
> dependencies {
>    implementation("io.realm.kotlin:library-base:0.10.0")
> }
>```

With these changes, our Android app is ready to use Kotlin SDK.

## Changes in implementation

### Realm Initialization

Traditionally before using Realm for querying information in our project, we had to initialize and
set up few basic properties like name, version with sync config for database, let's update them 
as well.

Steps with JAVA SDK :

1. Call `Realm.init()`
2. Setup Realm DB properties like name, version, migration rules etc using `RealmConfiguration`.
3. Setup logging
4. Configure Realm Sync

With Kotlin SDK :

1. <s>Call `Realm.init()`</s> _Is not needed anymore_.
2. Setup Realm DB properties like db name, version, migration rules etc. using `RealmConfiguration`-
   _This remains the same apart from a few minor changes_.
3. Setup logging - _This is moved to `RealmConfiguration`_
4. Configure Realm Sync - _No changes_

### Changes to Models

No changes are required in model classes, except you might have to remove a few currently 
unsupported annotations like `@RealmClass` which is used for the embedded object.

> Note: You can remove `Open` keyword against `class` which was mandatory for using Java SDK in
> Kotlin.

### Changes to querying

The most exciting part starts from here 😎(IMO).

Traditionally Realm SDK has been on the top of the latest programming trends like Reactive
programming (Rx), LiveData and many more but with the technological shift in Android programming
language from Java to Kotlin, developers were not able to fully utilize the power of the language 
with Realm as underlying SDK was still in Java, few of the notable were support for the Coroutines, 
Kotlin Flow, etc.

But with the Kotlin SDK that all has changed and further led to the reduction of boiler code. 
Let's understand these by examples.

Example 1: As a user, I would like to register my visit as soon as I open the app or screen.

Steps to complete this operation would be

1. Authenticate with Realm SDK.
2. Based on the user information, create a sync config with the partition key.
3. Open Realm instance.
4. Start a Realm Transaction.
5. Query for current user visit count and based on that add/update count.

With JAVA SDK:

```kotlin
private fun updateData() {
    _isLoading.postValue(true)

    fun onUserSuccess(user: User) {
        val config = SyncConfiguration.Builder(user, user.id).build()

        Realm.getInstanceAsync(config, object : Realm.Callback() {
            override fun onSuccess(realm: Realm) {
                realm.executeTransactionAsync {
                    var visitInfo = it.where(VisitInfo::class.java).findFirst()
                    visitInfo = visitInfo?.updateCount() ?: VisitInfo().apply {
                        partition = user.id
                    }.updateCount()

                    it.copyToRealmOrUpdate(visitInfo).apply {
                        _visitInfo.postValue(it.copyFromRealm(this))
                    }
                    _isLoading.postValue(false)
                }
            }

            override fun onError(exception: Throwable) {
                super.onError(exception)
                // some error handling 
                _isLoading.postValue(false)
            }
        })
    }

    realmApp.loginAsync(Credentials.anonymous()) {
        if (it.isSuccess) {
            onUserSuccess(it.get())
        } else {
            _isLoading.postValue(false)
        }
    }
}
```

With Kotlin SDK:

```kotlin
private fun updateData() {
    viewModelScope.launch(Dispatchers.IO) {
        _isLoading.postValue(true)
        val user = realmApp.login(Credentials.anonymous())
        val config = SyncConfiguration.Builder(
            user = user,
            partitionValue = user.identity,
            schema = setOf(VisitInfo::class)
        ).build()

        val realm = Realm.open(configuration = config)
        realm.write {
            val visitInfo = this.query<VisitInfo>().first().find()
            copyToRealm(visitInfo?.updateCount()
                ?: VisitInfo().apply {
                    partition = user.identity
                    visitCount = 1
                })
        }
        _isLoading.postValue(false)
    }
}
```

Upon quick comparing, you would notice that lines of code have decreased by 30%, and we are using
coroutines for doing the async call, which is the natural way of doing asynchronous programming in
Kotlin. Let's check this with one more example.

Example 2: As user, I should be notified immediately about any change in user visit info. This is
more like observing the change to visit count.

With Java SDK:

```kotlin
 fun onRefreshCount() {
    _isLoading.postValue(true)

    fun getUpdatedCount(realm: Realm) {
        val visitInfo = realm.where(VisitInfo::class.java).findFirst()
        visitInfo?.let {
            _visitInfo.value = it
            _isLoading.postValue(false)
        }
    }

    fun onUserSuccess(user: User) {
        val config = SyncConfiguration.Builder(user, user.id).build()

        Realm.getInstanceAsync(config, object : Realm.Callback() {
            override fun onSuccess(realm: Realm) {
                getUpdatedCount(realm)
            }

            override fun onError(exception: Throwable) {
                super.onError(exception)
                //TODO: Implementation pending
                _isLoading.postValue(false)
            }
        })
    }

    realmApp.loginAsync(Credentials.anonymous()) {
        if (it.isSuccess) {
            onUserSuccess(it.get())
        } else {
            _isLoading.postValue(false)
        }
    }
}
```

With Kotlin SDK :

```kotlin

fun onRefreshCount(): Flow<VisitInfo?> {

    val user = runBlocking { realmApp.login(Credentials.anonymous()) }
    val config = SyncConfiguration.Builder(
        user = user,
        partitionValue = user.identity,
        schema = setOf(VisitInfo::class)
    ).build()

    val realm = Realm.open(config)
    return realm.query<VisitInfo>().first().asFlow()
}

```

Again upon quick comparing you would notice that lines of code have decreased drastically, by more
than **60%**, and apart coroutines for doing async call, we are using _Kotlin Flow_ to observe the
value changes.

With this, as mentioned earlier, we are further able to reduce our boilerplate code,
no [callback hell](http://callbackhell.com) and writing code is more natural now.

## Other major changes

Apart from Realm Kotlin SDK being written in Kotlin language, it is fundamentally little different 
from the JAVA SDK in a few ways:

- **Frozen by default**: All objects are now frozen. Unlike live objects, frozen objects do not
  automatically update after the database writes. You can still access live objects within a write
  transaction, but passing a live object out of a write transaction freezes the object.
- **Thread-safety**: All realm instances, objects, query results, and collections can now be
  transferred across threads.
- **Singleton**: You now only need one instance of each realm.

## Should you migrate now?

There is no straight answer to question, it really depends on usage, complexity of the app and time.
But I think so this the perfect time to evaluate the efforts and changes required to migrate as 
Realm Kotlin SDK would be the future.


This article is targeted to existing Realm developers who want to understand how to migrate to Realm Kotlin SDK.

How to migrate from Realm Java SDK to Realm Kotlin SDK

Henna Singh



<div class="introduction">

Hello, everyone. I am Henna. I started with Mobile Application back in 2017 when I was a lucky recipient of the Udacity Scholarship. I had always used SQLite when it came to using databases in my mobile apps. Using SQLite was definitely a lot of boilerplate code, but using it with Room library did make it easier.

I had heard about Realm before but I got so comfortable using Room with SQLite that I never thought of exploring the option.

At the time, I was not aware that Realm had multiple offerings, from being used as a local database on mobile, to offering Sync features to be able to sync your app data to multiple devices.

I will pen down my experiments with MongoDB Realm as a series of articles. This is the first article in the series and it is divided into two parts.

**Part A** will explain how to create a MongoDB Realm back end for your mobile app.

**Part B** will explain how to implement Google Authentication in the
app.

>Pre-Requisites: You have created at least one app using Android Studio.

![Laptop and Coffee](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/laptopandcoffee_180302bf7d.jpeg)
Photo by [Emily Finch](https://unsplash.com/@emilydafinchy?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com/?utm_source=medium&utm_medium=referral)

Let's get some coffee and get the ball rolling. :)

## Part A: 

### Step 1. How to Create an Account on MongoDB Cloud

MongoDB Realm is a back end as a service. When you want to use MongoDB Realm Sync functionality, you need to create a MongoDB Realm account and it is free :D :D

> MongoDB’s Atlas offering of the database as a service is what makes this database so amazing. For mobile applications, we use Realm DB locally on the mobile device, and the local data gets synced to MongoDB Atlas on the cloud.

An account on MongoDB Cloud can be easily created by visiting
<https://account.mongodb.com/account/login>.

Once you sign-in to your account, you will be asked to create an Organization

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/ccount_setup_b18587e46f.png)

Once you click on the Create button, you will be asked to enter organization name and select MongoDB Atlas as a Cloud Service as shown below and click Next.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/create_Organisation_ca92f8f450.png)

Add members and permissions as desired and click on Create Organization. Since I am working on my own I added only myself as Project Owner.

Next you will be asked to create a project, name it and add members and permissions. Each permission is described on the right side. Be cautious of whom you give read/write access of your database.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/addmemberspermissions_cabf7b478e.png)

Once you create a project, you will be asked to deploy your database as shown below
![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/createdatabase_63fbccabae.png)

Depending on your use-case, you can select from given options. For this article, I will choose shared and Free service :)

Next select advance configuration options and you will be asked to select a Cloud Provider and Region

A cluster is a group of MongoDB Servers that store your data on the cloud. Depending on your app requirement, you choose one. I opted for a free cluster option for this app.
![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/createcluster_0fd9d1fb7f.png)

> Be mindful of the Cloud Provider and the Location you choose. Realm App is currently available only with AWS and it is recommended to have Realm App region closer to the cluster region and same Cloud Provider. So I choose the settings as shown.
> 
Give a name to your cluster. Please note this cannot be changed later.

And with this, you are all set with Step 1.

### Step 2. Security Quickstart
Once you have created your cluster, you will be asked to create a user to access data stored in Atlas. This used to be a manual step earlier but now you get the option to add details as and when you create a cluster.

These credentials can be used to connect to your cluster via MongoDB Compass or Mongo Shell but we will come to that later.

You can click on “Add My Current IP Address” to whitelist your IP address and follow as instructed.
![Add Network Security details](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/securityquickstart_257fef4eeb.png)

If you need to change your settings at a later time, use Datasbase Access and Network Access from Security section that will appear on left panel.

With this Step 2 is done.
### Step 3. How to Create a Realm App on the Cloud
We have set up our cluster, so the next step is to create a Realm app and link it to it. Click on the Realm tab as shown.
![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/realmtab_f9c6a49588.png)

You will be shown a template window that you can choose from. For this article, I will select “Build your own App”
![Start with a template](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/realmappcreation_5bcb4bb73f.png)


Next you will be asked to fill details as shown. Your Data Source is the Atlas Cluster you created in Step1. If you have multiple clusters, select the one you want to link your app with.

Please note, Realm app names should have fewer than 64 characters.
![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/realmapp_c079d404e1.png)

For better performance, It is recommended to have local deployment and region the same or closer to your cluster region.

Check the Global Deployment section in MongoDB's official documentation for more details.

You will be shown a section of guides once you click on “Create a Realm Application”. You can choose to follow the guides if you know what you are doing, but for brevity of this article, I will close guides and this will bring you to your Realm Dashboard as shown

Please keep a note of the “App Id”. This will be needed when you create the Android Studio project.
![Realm Dashboard](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/realmappid_3537ee0eae.png)

There are plethora of cloud services that comes with MongoDB Realm. You can use functions, triggers, graphQL, and other features depending on your app use cases. For this article, you will be using Authentication.

With this, you are finished with Part A. Yayyy!! :D



## Part B: 

### Step 1. Creating an Android Studio Project

I presume you all have experience creating mobile applications using Android Studio. In this step, you would "Start a new Android Project." You can enter any name of your choice and select Kotlin as the language and min API 21.

Once you create the project, you need to add dependencies for the Realm Database and Google Authentication.

**For Realm**, add this line of code in the project-level `build.gradle` file. This is the latest version at the time of writing this article.

**Edit 01:** Plugin is updated to current (may change again in future).

``` java
classpath "io.realm:realm-gradle-plugin:10.9.0"
```

After adding this, the dependencies block would look like this.

``` java
dependencies {
    classpath "com.android.tools.build:gradle:4.0.0"
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    
    classpath "io.realm:realm-gradle-plugin:10.9.0"

    // NOTE: Do not place your application dependencies here; they belong
    // in the individual module build.gradle files
}
```

Now we add Realm plugin and Google Authentication in the app-level `build.gradle` file. Add this code at the top of the file but below the `kotlin-kapt` extension. If you are using Java, then this would come after the Android plugin.

``` java
apply plugin: 'kotlin-kapt'
apply plugin: 'realm-android'
```

In the same file, we would also add the below code to enable the Realm sync in the application. You can add it anywhere inside the Android block.

``` java
android {
...
...
realm {
    syncEnabled = true
  }
...
}
```

For Google Auth, add the following dependency in the app-level gradle file. Please note, the versions may change since the time of this article.

**Edit 02:** gms version is updated to current.

``` java
dependencies{
...
...
//Google OAuth
implementation 'com.google.android.gms:play-services-auth:20.0.1'
...
}
```

With this, we are finished with Step 1. Let's move onto the next step to implement Google Authentication in the project.

### Step 2. Adding Google Authentication to the Application

Now, I will not get into too much detail on implementing Google Authentication to the app since that will deviate from our main topic. I have listed below the set of steps I took and links I followed to implement Google Authentication in my app.

1.  [Configure a Google API Console project](https://developers.google.com/identity/sign-in/android/start-integrating#configure_a_project). (Create credentials for Android Application and Web Application). Your credential screen should have 2 oAuth Client IDs.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/oauthcliendids_2da4d84855.png)

2.  [Configure Google Sign-in and the GoogleSignInClient object](https://developers.google.com/identity/sign-in/android/sign-in#configure_google_sign-in_and_the_googlesigninclient_object) (in the Activity's onCreate method).
3.  [Add the Google Sign-in button to the layout file](https://developers.google.com/identity/sign-in/android/sign-in#add_the_google_sign-in_button_to_your_app).
4.  [Implement Sign-in flow](https://developers.google.com/identity/sign-in/android/sign-in#start_the_sign-in_flow).

This is what the activity will look like at the end of the four steps.

>**Please note**: This is only a guideline. Your variable names and views can be different. The String server_client_id here is the web client-id you created in Google Console when you created Google Auth credentials in the Google Console Project.

``` java
class MainActivity : AppCompatActivity() {

    private lateinit var client: GoogleSignInClient

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val googleSignInOptions = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestEmail()
            .requestServerAuthCode(getString(R.string.server_client_id))
            .build()

        client = GoogleSignIn.getClient(this, googleSignInOptions)

        findViewById(R.id.sign_in_button).setOnClickListener{
            signIn()
        }
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if(requestCode == 100){
            val task = GoogleSignIn.getSignedInAccountFromIntent(data)
            val account = task.getResult(ApiException::class.java)
            handleSignInResult(account)
        }
    }

    private fun handleSignInResult(account: GoogleSignInAccount?) {
            try{
                Log.d("MainActivity", "${account?.serverAuthCode}")
                //1
                val idToken = account?.serverAuthCode

                //signed in successfully, forward credentials to MongoDB realm
                //2
                val googleCredentials = Credentials.google(idToken)
                //3
                app.loginAsync(googleCredentials){
                    if(it.isSuccess){
                        Log.d("MainActivity", "Successfully authenticated using Google OAuth")
                        //4
                        startActivity(Intent(this, SampleResult::class.java))
                    } else {
                        Log.d("MainActivity", "Failed to Log in to MongoDB Realm: ${it.error.errorMessage}")
                    }
                }
            } catch(exception: ApiException){
                Log.d("MainActivity",  exception.printStackTrace().toString())
            }
    }

    private fun signIn() {
        val signIntent = client.signInIntent
        startActivityForResult(signIntent, 100)
    }
}
```

When you run your app, your app should ask you to sign in with your Google account, and when successful, it should open SampleResult Activity. I displayed a random text to show that it works. :D

Now, we will move onto the next step and configure the Google Auth provider on the MongoDB Realm cloud account.

### Step 3. Configure Google Auth Provider on MongoRealm UI

Return to the MongoDB Realm account where you created your Realm app. On the left panel, click on the Authentication tab and you will see the list of auth providers that MongoDB Realm supports.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/authproviders_55d5b34661.png)
Click on the *edit* icon corresponding to Google Authentication provider and you will be led to a page as shown below.

**Edit 03:** Updated Screenshot as there is now a new option OpenID connect.
![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Open_ID_Connect_5b3ce6b5a8.png)

Toggle the **Provider Enabled** switch to **On** and enter the **Web-Client ID** and **Web Client Secret** from the Google Console Project you created above.

You can choose the Metadata Fields as per your app use case and click Save.

> Keeping old UI here as OpenID Connect is not used.
> 
![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/authproviders2_bdd33e8aa7.png)
With this, we are finished with Step 3. 

### Step 4. Implementing Google Auth Sync Credentials to the Project

This is the last step of Part 2. We will use the Google Auth token received upon signing in with our Google Account in the previous step to authenticate to our MongoDB Realm account.

We already added dependencies for Realm in Step 3 and we created a Realm app on the back end in Step 2. Now, we initialize Realm and use the appId (Remember I asked you to make a note of the app Id? Check Step 2. ;)) to connect back end with our mobile app.

Create a new Kotlin class that extends the application class and write the following code onto it.

``` java
val appId ="realmsignin-abyof" // Enter your own App Id here
lateinit var app: App

class RealmApp: Application() {

    override fun onCreate() {
        super.onCreate()
        Realm.init(this)

        app = App(AppConfiguration.Builder(appId).build())

    }
}
```

An "App" is the main client-side entry point for interacting with the MongoDB Realm app and all its features, so we configure it in the application subclass for getting global access to the variable.

This is the simplest way to configure it. After configuring the "App", you can add authentication, manage users, open synchronized realms, and all other functionalities that MongoDB Realm offers.

To add more details when configuring, check the [MongoDB Realm Java doc](https://docs.mongodb.com/realm-sdks/java/10.0.0-BETA.8/io/realm/mongodb/App.html).

Don't forget to add the RealmApp class or whatever name you chose to the manifest file.

``` java
<application
   ..
    android:theme="@style/AppTheme"
    android:name=".RealmApp">
    ....
    ....
    <activity android:name=".MainActivity">
        ...
        ...
    </activity>
</application>
```

Now come back to the `handleSignInResult()` method call in the MainActivity, and add the following code to that method.

``` java
private fun handleSignInResult(account: GoogleSignInAccount?) {
        try{
            Log.d("MainActivity", "${account?.serverAuthCode}")

            // Here, you get the serverAuthCode after signing in with your Google account.
            val idToken = account?.serverAuthCode

            // signed in successfully, forward credentials to MongoDB realm
            // In this statement, you pass the token received to ``Credentials.google()`` method to pass it to MongoDB Realm.
            val googleCredentials = Credentials.google(idToken)

            // Here, you login asynchronously by passing Google credentials to the method.
            app.loginAsync(googleCredentials){
                if(it.isSuccess){
                    Log.d("MainActivity", "Successfully authenticated using Google OAuth")

            // If successful, you navigate to another activity. This may give a red mark because you have not created SampleResult activity. Create an empty activity and name it SampleResult.
             startActivity(Intent(this, SampleResult::class.java))
                } else {
                    Log.d("MainActivity", "Failed to Log in to MongoDB Realm: ${it.error.errorMessage}")
                }
            }
        } catch(exception: ApiException){
            Log.d("MainActivity",  exception.printStackTrace().toString())
        }
}
```

Add a TextView with a Successful Login message to the SampleResult layout file.

Now, when you run your app, log in with your Google account and your SampleResult Activity with Successful Login message should be shown.

When you check the App Users section in your MongoDB Realm account, you should notice one user created.
![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/appusers_8775b437e2.png)

## Wrapping Up

You can get the code for this tutorial from [this GitHub repo](https://github.com/hennasingh/RealmWithGoogle).

Well done, everyone. We are finished with implementing Google Auth with MongoDB Realm, and I would love to know if you have any feedback for me.❤

You can post questions on [MongoDB Community Forums](https://developer.mongodb.com/community/forums/) or if you are struggling with any topic, please feel free to reach out.

In the next article, I talk about how to implement Realm Sync in your Android Application.


Getting Started with MongoDB Realm and Implementing Google Authentication in Your Android App

Start Implementing Google Auth With MongoDB Realm in Your Android App

Ian Ward

The Realm team is happy to announce the beta release of our Realm Kotlin SDK—with support for both Kotlin for Android and Kotlin Multiplatform apps. With this release, you can deploy and maintain a data layer across iOS, Android, and desktop platforms from a single Kotlin codebase.

:youtube[]{vid=6vL5h8pbt5g}

Realm is a super fast local data store that makes storing, querying, and syncing data simple for modern applications. With Realm, working with your data is as simple as interacting with objects from your data model. Any updates to the underlying data store will automatically update your objects, enabling you to refresh the UI with first-class support for Kotlin’s programming primitives such as Coroutines, Channels, and Flows. 

## Introduction

Our goal with Realm has always been to provide developers with the tools they need to easily build data-driven, reactive mobile applications. Back in 2014, this meant providing Android developers with a first-class Java SDK. But the Android community is changing. With the growing importance of Kotlin, our team had two options: refactor the existing Realm Java SDK to make it Kotlin-friendly or use this as an opportunity to build a new SDK from the ground up that is specifically tailored to the needs of the Kotlin community. After collecting seven years of feedback from Android developers, we chose to build a new Kotlin-first SDK that pursued the following directives:

* Expose Realm APIs that are idiomatic and directly integrate with Kotlin design patterns such as Coroutines and Flows, eliminating the need to write glue code between the data layer and the UI.
* Remove Realm Java’s thread confinement for Realms and instead emit data objects as immutable structs, conforming to the prevalent design pattern on Android and other platforms.
* Expose a single Realm singleton instance that integrates into Android’s lifecycle management automatically, removing the custom code needed to spin up and tear down Realm instances on a per-activity or fragment basis.

## What is Realm?

Realm is a fast, easy-to-use alternative to SQLite + Room with built-in cloud capabilities, including a real-time edge-to-cloud sync solution. Written from the ground up in C++, it is not a wrapper around SQLite or any other relational data store. Designed with the mobile environment in mind, it is lightweight and optimizes for constraints like compute, memory, bandwidth, and battery that do not exist on the server side. Realm uses lazy loading and memory mapping with each object reference pointing directly to the location on disk where the state is stored. This exponentially increases lookup and query speed as it eliminates the loading of state pages of disk space into memory to perform calculations. It also reduces the amount of memory pressure on the device while working with the data layer. Simply put, Realm makes it easy to store, query, and sync your mobile data across devices and the back end.

## Realm for Kotlin developers

Realm is an object database, so your schema is defined in the same way you define your object classes. Under the hood, Realm uses a Kotlin compiler plugin to generate the necessary getters, setters, and schema for your database, freeing Android developers from the monotony of Room’s DAOs and the pain of investigating inaccurate SQL query responses from SQLite. 

Realm also brings true relationships to your object class definitions, enabling you to have one-to-one, one-to-many, many-to-many, and even inverse relationships. And because Realm objects are memory-mapped, traversing the object graph across relationships is done in the blink of an eye. 

Additionally, Realm delivers a simple and intuitive query system that will feel natural to Kotlin developers. No more context switching to SQL to instantiate your schema or looking behind the curtain when an ORM fails to translate your calls into SQL. 

```kotlin
// Define your schema - Notice Project has a one-to-many relationship to Task
class Project : RealmObject {
    var name: String = ""
    var tasks: RealmList<Task> = realmListOf()
}

class Task : RealmObject {
    var name: String = ""
    var status: String = "Open"
    var owner: String = ""
}

// Set the config and open the realm instance
val easyConfig = RealmConfiguration.with(schema = setOf(Task::class, Project::class))

val realm: Realm = Realm.open(easyConfig)

// Write asynchronously using suspend functions
realm.write { // this: MutableRealm
    val project = Project().apply {
        name = "Kotlin Beta"
    }
    val task = Task().apply {
        name = "Ship It"
        status = "InProgress"
        owner = "Christian"
    }
    project.tasks = task
    copyToRealm(project)
}

// Get a reference to the Project object
val currentProject: Project =
    realm.query<Project>(
        "name == $0", "Kotlin Beta"
    ).first().find()!!

// Or query multiple objects
vall allTasks: RealmResults<Project> = 
    realm.query<Project>().find()

// Get notified when data changes using Flows
currentProject.tasks.asFlow().collect { change: ListChange<Task> ->
    when (change) {
        is InitialList<Task> -> {
            // Display initial data on UI
            updateUI(change.list)
        }
        is UpdatedList<Task> -> {
            // Get information about changes compared
            // to last version.
            Log.debug("Changes: ${change.changeRanges}")
            Log.debug("Insertions: ${change.insertionRanges}")
            Log.debug("Deletions: ${change.deletionRanges}")
            updateUI(change.list)
        }
        is DeletedList<Task> -> {
            updateUI(change.list) // Empty list
        }
    }
}

// Write synchronously - this blocks execution on the caller thread 
// until the transaction is complete
realm.writeBlocking { // this: MutableRealm
    val newTask = Task().apply {
        name = "Write Blog"
        status = "InProgress"
        owner = "Ian"
    }

    findLatest(currentProject)?.apply {
        tasks.add(newTask)
    }
}

// The UI will now automatically display two tasks because 
// of the above defined Flow on currentProject
```
Finally, one of Realm’s main benefits is its out-of-the-box data synchronization solution with MongoDB Atlas. Realm Sync makes it easy for developers to build reactive mobile apps that stay up to date in real-time.

## Looking ahead

The Realm Kotlin SDK is a free and open source database available for you to get started building applications with today! With this beta release, we believe that all of the critical components for building a production-grade data layer in an application are in place. In the future, we will look to add embedded objects; data types such as Maps, Sets, and the Mixed type; ancillary sync APIs as well as support for [Flexible Sync](https://docs.mongodb.com/realm/sdk/java/examples/flexible-sync/); and finally, some highly optimized write and query helper APIs with the eventual goal of going GA later this year.

Give it a try today and [let us know what you think](http://forums.realm.io)! Check out our [samples](https://github.com/realm/realm-kotlin-samples), read our [docs](https://docs.mongodb.com/realm/sdk/kotlin/), and follow our [repo](https://github.com/realm/realm-kotlin).

>For users already familiar with Realm Java, check out the video at the top of this article if you haven't already, or our migration blog post and [documentation](https://docs.mongodb.com/realm/sdk/kotlin/migrate-from-java-sdk-to-kotlin-sdk/) to see what is needed to port over your existing implementation.



Announcing the Realm Kotlin Beta—making it easy to store, query, and sync data in your Kotlin for Android and Kotlin Multiplatform apps.

Announcing the Realm Kotlin Beta: A Database for Multiplatform Apps

Jorge D. Ortiz-Fuentes

## Introduction

So, it's here! The engineering team has [released a major milestone of the Kotlin
SDK](https://www.mongodb.com/developer/article/announcing-realm-kotlin-beta/). The beta is [available to
you](https://github.com/realm/realm-kotlin) to try it and make comments and suggestions.

Until now, if you were using Realm in Android, you were using the Java version of the SDK.  The purpose of the Realm
Kotlin SDK is to be the evolution of the Java one and eventually replace it.  So, you might be wondering if and when you
should migrate to it.  But even more important for your team and your app is what it provides that the Java SDK
doesn't.  The Kotlin SDK has been written from scratch to combine what the engineering team has learned through years of
SDK development, with the expressivity and fluency of the Kotlin language.  They have been successful at that and the
resulting SDK provides a first-class experience that I would summarize in the following points:

- The Kotlin SDK allows you to use expressions that are Kotlin idiomatic&mdash;i.e., more natural to the language.
- It uses Kotlin coroutines and flows to make concurrency easier and more efficient.
- It has been designed and developed with Kotlin Multiplatform in mind.
- It has removed the thread-confinement restriction on Java and it directly integrates with the Android lifecycle hooks
  so the developer doesn't have to spin up and tear down a realm instance on every activity lifecycle.
- It's the way forward.  MongoDB is not discontinuing the Java SDK anytime soon, but Kotlin provides the engineering
  team more resources to implement cooler things going forward. A few of them have been implemented already.  Why wouldn't
  you want to benefit from them?

Are you on board?  I hope you are, because through the rest of this article, I'm going to tell you how to upgrade your
projects to use the Realm Kotlin SDK and take advantage of those benefits that I have just mentioned and some more.  You
can also find a complete code example in this [repo](https://github.com/mongodb-developer/ExpenseManagerToKotlinSDK).


## Gradle build files

First things first.  You need to make some changes to your `build.gradle` files to get access to the Realm Kotlin SDK
within your project, instead of the Realm Java SDK that you were using. The Realm Kotlin SDK uses a gradle plugin that
has been published in the [Gradle Plugin Portal](https://plugins.gradle.org/plugin/io.realm.kotlin), so the prefered way
to add it to your project is using the plugins section of the build configuration of the module &mdash;i.e.,
`app/build.gradle`&mdash; instead of the legacy method of declaring the dependency in the `buildscript` block of the
project `build.gradle`.

After replacing the plugin in the module configuration with the Kotlin SDK one, you need to add an implementation
dependency to your module.  If you want to use [Sync](https://www.mongodb.com/realm/mobile/sync) with your MongoDB
cluster, then you should use `'io.realm.kotlin:library-sync'`, but if you just want to have local persistence, then
`'io.realm.kotlin:library-base'` should be enough.  Also, it's no longer needed to have a `realm` dsl section in the
`android` block to enable sync.


### `build.gradle` Comparison

#### Java SDK

```kotlin
buildscript {
	// ...
    dependencies {
        classpath "com.android.tools.build:gradle:$agp_version"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

        // Realm Plugin
        classpath "io.realm:realm-gradle-plugin:10.10.1"
    }
}
```

#### Kotlin SDK

```kotlin
buildscript {
	// ...
    dependencies {
        classpath "com.android.tools.build:gradle:$agp_version"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}
```

### `app/build.gradle` Comparison

#### Java SDK

```kotlin
plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'kotlin-kapt'
    id 'realm-android'
}
android {
	// ...
    realm {
        syncEnabled = true
    }
}
dependencies {
	// ...
}
```

#### Kotlin SDK

```kotlin
plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'kotlin-kapt'
    id 'io.realm.kotlin' version '0.10.0'
}
android {
	// ...
}
dependencies {
	// ...
    implementation("io.realm.kotlin:library-base:0.10.0")
}
```


If you have more than one module in your project and want to pin the version number of the plugin for all of them, you
can define the plugin in the project `build.gradle` with the desired version and the attribute `apply false`.  Then, the
`build.gradle` files of the modules should use the same plugin id, but without the version attribute.

### Multimodule Configuration

#### Project build.gradle

```kotlin
plugins {
	// ...
    id 'io.realm.kotlin' version '0.10.0' apply false
}
```

#### Modules build.gradle

```kotlin
plugins {
	// ...
    id 'io.realm.kotlin'
}
```


## Model classes

Kotlin scope functions (i.e., `apply`, `run`, `with`, `let`, and `also`) make object creation and manipulation easier.
That was already available when using the Java SDK from kotlin, because they are provided by the Kotlin language itself.

Defining a model class is even easier with the Realm Kotlin SDK.  You are not required to make the model class `open`
anymore.  The Java SDK was using the Kotlin Annotation Processing Tool to derive proxy classes that took care of
interacting with the persistence.  Instead, the Kotlin SDK uses the `RealmObject` interface as a marker for the plugin.
In the construction process, the plugin identifies the objects that are implementing the marker interface and injects the
required functionality to interact with the persistence.  So, that's another change that you have to put in place:
instead of making your model classes extend &mdash;i.e., inherit&mdash; from `RealmObject`, you just have to implement the interface
with the same name.  In practical terms, this means using `RealmObject` in the class declaration without parentheses.

### Model Class Definition

#### Java SDK

```kotlin
open class ExpenseInfo : RealmObject() {
    @PrimaryKey
    var expenseId: String = UUID.randomUUID().toString()
    var expenseName: String = ""
    var expenseValue: Int = 0
}
```

#### Kotlin SDK

```kotlin
class ExpenseInfo : RealmObject {
    @PrimaryKey
    var expenseId: String = UUID.randomUUID().toString()
    var expenseName: String = ""
    var expenseValue: Int = 0
}
```

There are also changes in terms of the type system.  `RealmList` that was used in the Java SDK to model one-to-many
relationships is extended in the Kotlin SDK to benefit from the typesystem and allow expressing nullables in those
relationships.  So, now you can go beyond `RealmList<String>` and use `RealmList<String?>`.  You will get all the
benefits of the syntax sugar to mean that the strings the object is related to, might be null.  You can check this and
the rest of the supported types in the [documentation](https://docs.mongodb.com) of the Realm Kotlin SDK.


## Opening (and closing) the realm

Using Realm is even easier now.  The explicit initialization of the library that was required by the Realm Java SDK is
not needed for the Realm Kotlin SDK.  You did that invoking `Realm.init()` explicitly.  And in order to ensure that you
did that once and at the beginning of the execution of your app, you normally put that line of code in the `onCreate()`
method of the `Application` subclass.  You can forget about that chore for good.

The configuration of the Realm in the Kotlin SDK requires passing the list of object model classes that conform the
schema, so the `builder()` static method has that as the argument.  The Realm Kotlin SDK also allows setting the logging
level per configuration, should you use more than one.  The rest of the configuration options remain the same.

It's also different the way you get an instance of a Realm when you have defined the configuration that you want to
use.  With the Java SDK, you had to get access to a thread singleton using one of the static methods
`Realm.getInstance()` or `Realm.getDefaultInstance()` (the latter when a default configuration was being set and used).
In most cases, that instance was used and released, by invoking its `close()` method, at the end of the
Activity/Fragment lifecycle.  The Kotlin SDK allows you to use the static method `open()` to get a single instance of a
Realm per configuration.  Then you can inject it and use it everywhere you need it.  This change takes the burden of
Realm lifecycle management off from the shoulders of the developer.  That is huge!  Lifecycle management is often
painful and sometimes difficult to get right.

### Realm SDK Initialization

#### Java SDK

```kotlin
class ExpenseApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        Realm.init(this)

        val config = RealmConfiguration.Builder()
            .name("expenseDB.db")
            .schemaVersion(1)
            .deleteRealmIfMigrationNeeded()
            .build()

        Realm.setDefaultConfiguration(config)
        // Realms can now be obtained with Realm.getDefaultInstance()
    }
}
```

#### Kotlin SDK

```kotlin
class ExpenseApplication : Application() {
    lateinit var realm: Realm

    override fun onCreate() {
        super.onCreate()

        val config = RealmConfiguration
            .Builder(schema = setOf(ExpenseInfo::class))
            .name("expenseDB.db")
            .schemaVersion(1)
            .deleteRealmIfMigrationNeeded()
            .log(LogLevel.ALL)
            .build()

        realm = Realm.open(configuration = config)
        // This realm can now be injected everywhere
    }
}
```

Objects in the Realm Kotlin SDK are now frozen to directly integrate seamlessly into Kotlin coroutine and flows.  That
means that they are not live as they used to be in the Realm Java SDK and don't update themselves when they get changed
in some other part of the application or even in the cloud.  Instead, you have to modify them within a write
transaction, i.e., within a `write` or `writeBlocking` block.  When the scope of the block ends, the objects are frozen
again.

Even better, the realms aren't confined to a thread.  No more thread singletons.  Instead, realms are thread-safe, so
they can safely be shared between threads.  That means that you don't need to be opening and closing realms for the
purpose of using them within a thread.  Get your Realm and use it everywhere in your app.  Say goodbye to all those
lifecycle management operations for the realms!

Finally, if you are injecting dependencies of your application, with the Realm Kotlin SDK, you can have a singleton for
the Realm and let the dependency injection framework do its magic and inject it in every view-model.  That's much easier
and more efficient than having to create one each time &mdash;using a factory, for example&mdash; and ensuring that the
close method was called wherever it was injected.


## Writing data

It took a while, but Kotlin brought coroutines to Android and we have learned to use them and enjoy how much easier
they make doing asynchronous things.  Now, it seems that coroutines are _the way_ to do those things and we would like
to use them to deal with operations that might affect the performance of our apps, such as dealing with the persistence
of our data.

Support for coroutines and flows is built-in in the Realm Kotlin SDK as a first-class citizen of the API.  You no longer
need to insert write operations in suspending functions to benefit from coroutines.  The `write {}` method of a realm is
a suspending method itself and can only be invoked from within a coroutine context.  No worries here, since the compiler
will complain if you try to do it outside of a context.  But with no extra effort on your side, you will be performing
all those expensive IO operations asynchronously. Ain't that nice?

You can still use the `writeBlocking {}` of a realm, if you need to perform a synchronous operation.  But, beware that,
as the name states, the operation will block the current thread.  Android might not be very forgiving if you block the
main thread for a few seconds, and it'll present the user with the undesirable "Application Not Responding" dialog.  Please,
be mindful and use this **only when you know it is safe**.

Another additional advantage of the Realm Kotlin SDK is that, thanks to having the objects frozen in the realm, we can
make asynchronous transactions easier.  In the Java SDK, we had to find again the object we wanted to modify inside of
the transaction block, so it was obtained from the realm that we were using on that thread.  The Kotlin SDK makes that
much simpler by using `findLatest()` with that object to get its instance in the mutable realm and then apply the
changes to it.


### Asynchronous Transaction Comparison

#### Java SDK

```kotlin
realm.executeTransactionAsync { bgRealm ->
    val result = bgRealm.where(ExpenseInfo::class.java)
        .equalTo("expenseId", expenseInfo.expenseId)
        .findFirst()

    result?.let {
        result.deleteFromRealm()
    }
}
```

#### Kotlin SDK

```kotlin
viewModelScope.launch(Dispatchers.IO) {
    realm.write {
        findLatest(expenseInfo)?.also {
            delete(it)
        }
    }
}
```


## Queries and listening to updates

One thing where Realm shines is when you have to retrieve information from it.  Data is obtained concatenating three
operations:

1. Creating a RealmQuery for the object class that you are interested in.
2. Optionally adding constraints to that query, like expected values or acceptable ranges for some attributes.
3. Executing the query to get the results from the realm.  Those results can be actual objects from the realm, or
   aggregations of them, like the number of matches in the realm that you get when you use `count()`.

The Realm Kotlin SDK offers you a new query system where each of those steps has been simplified.


The queries in the Realm Java SDK used filters on the collections returned by the `where` method.  The Kotlin SDK offers
the `query` method instead.  This method takes a type parameter using generics, instead of the explicit type parameter
taken as an argument of `where` method.  That is easier to read and to write.

The constraints that allow you to narrow down the query to the results you care about are implemented using a predicate
as the optional argument of the `query()` method.  That predicate can have multiple constraints concatenated with
logical operators like `AND` or `OR` and even subqueries that are a mayor superpower that will boost your ability to
query the data.

Finally, you will execute the query to get the data.  In most cases, you will want that to happen in the background so
you are not blocking the main thread.  If you also want to be aware of changes on the results of the query, not just the
initial results, it's better to get a flow.  That required two steps in the Java SDK.  First, you had to use
`findAllAsync()` on the query, to get it to work in the background, and then convert the results into a flow with the
`toFlow()` method.  The new system simplifies things greatly, providing you with the `asFlow()` method that is a
suspending function of the query.  There is no other step.  Coroutines and flows are built-in from the beginning in the
new query system.

### Query Comparison

#### Java SDK

```kotlin
private fun getAllExpense(): Flow<List<ExpenseInfo>> =
    realm.where(ExpenseInfo::class.java).greaterThan("expenseValue", 0).findAllAsync().toFlow()
```

#### Kotlin SDK

```kotlin
private fun getAllExpense(): Flow<ResultsChange<ExpenseInfo>> =
    realm.query<ExpenseInfo>("expenseValue > 0").asFlow()
```

As it was the case when writing to the Realm, you can also use blocking operations when you need them, invoking `find()`
on the query.  And also in this case, use it **only when you know it is safe**.


## Conclusion

You're probably not reading this, because if I were you, I would be creating a branch in my project and trying the
Realm Kotlin SDK already and benefiting from all these wonderful changes.  But just in case you are, let me summarize the
most relevant changes that the Realm Kotlin SDK provides you with:

- The configuration of your project to use the Realm Kotlin SDK is easier, uses more up-to-date mechanisms, and is more
  explicit.
- Model classes are simpler to define and more idiomatic.
- Working with the realm is much simpler because it requires less ceremonial steps that you have to worry about and
  plays better with coroutines.
- Working with the objects is easier even when doing things asynchronously, because they're frozen, and that helps you
  to do things safely.
- Querying is enhanced with simpler syntax, predicates, and suspending functions and even flows.

Time to code!


This is a guide to help you migrate you apps that are using the Realm Java SDK to the newer Realm Kotlin SDK. It covers the most important changes that you need to put in place to use the Kotlin SDK.

Migrating Android Apps from Realm Java SDK to Kotlin SDK

A cross-platform programming language initially designed for the JVM (Java Virtual Machine) and Android.

Kotlin

Featured

How to migrate from Realm Java SDK to Realm Kotlin SDK

Migrating Android Apps from Realm Java SDK to Kotlin SDK

Announcing the Realm Kotlin Beta: A Database for Multiplatform Apps

All Kotlin Content