✅ Sign-up for a free cluster at → <a href="https://mdb.link/free-0SjuYcdGEgQ" target="_blank" rel="noreferrer">https://mdb.link/free-0SjuYcdGEgQ</a>
✅ Get help on our Community Forums → <a href="https://mdb.link/community-0SjuYcdGEgQ" target="_blank" rel="noreferrer">https://mdb.link/community-0SjuYcdGEgQ</a>

Learn how to build an iOS app using SwiftUI and the Atlas Device SDK (formerly Realm) for local persistence. You can find the code and step by step instructions in the online Lab: <a href="https://mdb.link/swiftui-atlas-sdk" target="_blank" rel="noreferrer">https://mdb.link/swiftui-atlas-sdk</a>

Subscribe to MongoDB YouTube → <a href="https://mdb.link/subscribe" target="_blank" rel="noreferrer">https://mdb.link/subscribe</a>

Swift

Sync your iOS SwiftUI App with MongoDB Atlas using Atlas Device Sync | Part 2

✅ Sign-up for a free cluster at → <a href="https://mdb.link/free-wFEO_tfjRHs" target="_blank" rel="noreferrer">https://mdb.link/free-wFEO_tfjRHs</a>
✅ Get help on our Community Forums → <a href="https://mdb.link/community-wFEO_tfjRHs" target="_blank" rel="noreferrer">https://mdb.link/community-wFEO_tfjRHs</a>

Learn how to build an iOS app using SwiftUI and the Atlas Device SDK (formerly Realm) for local persistence. You can find the code and step by step instructions in the online Lab: <a href="https://mdb.link/swiftui-atlas-sdk" target="_blank" rel="noreferrer">https://mdb.link/swiftui-atlas-sdk</a>

Subscribe to MongoDB YouTube → <a href="https://mdb.link/subscribe" target="_blank" rel="noreferrer">https://mdb.link/subscribe</a>

Sync your iOS SwiftUI App with MongoDB Atlas using Atlas Device Sync | Part 1

Luce Carter

As technology and styles of work evolve, the need for apps to support mobile is as important as ever. In 2023, [Android had around 70% market share](https://explodingtopics.com/blog/iphone-android-users), so the need for developers to understand how to develop apps for Android is vital.

In this tutorial, you will learn the basics of getting started with your first Android app, using the programming language Kotlin. Although historically, native Android apps have been written in Java, Kotlin was upgraded to the official language for Android by Google in 2019.

## Prerequisites
In order to follow along with this tutorial, you will need to have downloaded and installed Android Studio. This is the official IDE for Android development and comes with all the tools you will need to get started. Windows, MacOS, and Linux support it, as well.

> You won’t need an Android device to run your apps, thanks to the use of the Android Emulator, which comes with Android Studio. You will be guided through setup when you first open up Android Studio.

## Creating the project
The first step is to create the application. You can do this from the “Welcome to Android Studio” page that appears when you open Android Studio for the first time.

> If you have opened it before and don’t see this window but instead a list of recent projects, you can create a new project from the **File** menu.

 1. Click **New Project**, which starts a wizard to guide you through
    creating a new project.
2. In the **Templates** window, make sure the **Phone and Tablet** option is selected on the left. Select Empty Activity and then click
    Next.

![New Project template selection wizard](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltf63dab0201972cbb/65ae8dcb14eace4eeca5bd77/Template_Selection.png)
3. Give your project a name. I chose "Hello Android".    

For Package name, this can be left as the default, if you want. In the future, you might update it to reflect your company name, making sure to leave the app name on the end. I know the backward nature of the Package name can seem confusing but it is just something to note, if you update it.

Minimum SDK: If you make an app in the future intended for users, you might choose an earlier version of Android to support more devices, but this isn’t necessary for this tutorial, so update it to a newer version. I went with API 33, aka “Tiramisu.” Android gives all their operating system (OS) versions names shared with sweet things, all in alphabetical order.

> Fun fact: I created my first ever Android app back when the OS version was nicknamed Jelly Bean!

You can leave the other values as default, although you may choose to update the **Save** location. Once done, press the **Finish** button.


![New project details wizard to select name](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4f650cbee69ed423/65ae8e598c124a35f515ae77/Empty_Activity_Wizard.png)

It will then open your new application inside the main Android Studio window. It can take a minute or two to index and build everything, so if you don’t see much straight away, don’t worry. Once completed, you will see the ```MainActivity.kt``` file open in the editor and the project structure on the left.

![Android Studio window showing Main Activity Kotlin file open](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt73d8499e8065763e/65ae91811e1aed939ffd5494/Screenshot_2024-01-16_160139.png)

## Running the app for the first time
Although we haven’t made any code changes yet, the Empty Activity template comes with a basic UI already. So let’s run our app and see what it looks like out of the box.

 1. Select the **Run** button that looks like a play button at the top of the Android Studio window. Or you can select the hamburger menu in the top left and go to **Run -> Run ‘app’**.
 2. Once it has been built and deployed, you will see it running in the Running Devices area to the right of the editor window. Out of the box, it just says “Hello Android.”
![Android app running with white background and black text at the top that says Hello Android](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt687055a1d7e0383a/65ae922ed7d856526db4fcb2/Screenshot_2024-01-17_094400.png)

Congratulations! You have your first running native Android app!

## Updating the UI
Now your app is running, let’s take a look at how to make some changes to the UI.
Android supports two types of UI: XML-based layouts and [Jetpack Compose](https://mdb.link/android-jetpack-compose), known as Compose. Compose is now the recommended solution for Android, and this is what our new app is using, so we will continue to use it.

Compose uses composable functions to define UI components. You can see this in action in the I’m code inside ```MainActivity.kt``` where there is a function called ```Greeting``` with the attribute ```@Composable```. It takes in a string for a name and modifier and uses those inside a text element.

We are going to update the greeting function to now include a way to enter some text and a button to click that will update the label to say “Hello” to the name you enter in the text box.

Replace the existing code from ```class MainActivity : ComponentActivity() {``` onward with the following:
```kotlin
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            HelloAndroidTheme {
                // A surface container using the 'background' color from the theme
                Surface(
                    modifier = Modifier.fillMaxSize(),
                    color = MaterialTheme.colorScheme.background
                ) {
                    Greeting()
                }
            }
        }
    }
}

@Composable
fun Greeting() {

    var message by remember { mutableStateOf("")}
    var greeting by remember { mutableStateOf("") }

    Column (Modifier.padding(16.dp)) {
        TextField(
            value = message,
            onValueChange = { message = it },
            label = {Text("Enter your name..")}
        )
        Button(onClick = { greeting = "Hello, $message" }) {
            Text("Say Hello")
        }
       Text(greeting)
    }

}


@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    HelloAndroidTheme {
        Greeting()
    }
}

```

Let’s now take a look at what has changed.
### OnCreate

We have removed the passing of a hardcoded name value here as a parameter to the Greeting function, as we will now get that from the text box.

### Greeting
 We have added two function-scoped variables here for holding the values we want to update dynamically. 

We then start defining our components. Now we have multiple components visible, we want to apply some layout and styling to them, so we have created a column so the three sub-components appear vertically. Inside the column definition, we also pass padding of 16dp.

Our column layout contains a TextField for entering text. The value property is linked to our message variable. The onValueChanged property says that when the value of the box is changed, assign it to the message variable so it is always up to date. It also has a label property, which acts as a placeholder hint to the user.

Next is the button. This has an onClick property where we define what happens when the button is clicked. In this case, it sets the value of the greeting variable to be “Hello,” plus the message.

Lastly, we have a text component to display the greeting. Each time the button is clicked and the greeting variable is updated, that text field will update on the screen.

### GreetingPreview

This is a function that allows you to preview your UI without running it on a device or emulator. It is very similar to the OnCreate function above where it specifies the default HelloAndroidTheme and then our Greeting component.

If you want to view the preview of your code, you can click the button in the top right corner of the editor window, to the left of the **Running Devices** area that shows a hamburger icon with a rectangle with rounded corners next to it. This is the split view button. It splits the view between your code and the preview.

![Split screen button highlighted by green box](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt3657e87c0a1ee672/65ae9a6bc7bb16e0caa2a0c2/View_Preview.png)

### Imports
If Android Studio is giving you error messages in the code, it might be because you are missing some import statements at the top of the file.

Expand the imports section at the top and replace it with the following:

```kotlin
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.input.TextFieldValue
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import com.mongodb.helloandroid.ui.theme.HelloAndroidTheme
```
You will need to update the last import statement to make sure that your package name matches as it may not be com.mongodb.helloandroid, for example.

## Testing the app

Now that we have updated the UI, let’s run it and see our shiny new UI. Click the **Run** button again and wait for it to deploy to the emulator or your device, if you have one connected.

Try playing around with what you enter and pressing the button to see the result of your great work!

![Android app running with Enter your name text box with Reader typed in, a button that says Say Hello and the text Hello, Reader underneath the button](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4168e27ceb7fed71/65ae9a1d1e1aed5059fd54e0/Screenshot_2024-01-17_110558.png)

## Summary
There you have it, your first Android app written in Kotlin using Android Studio, just like that! Compose makes it super easy to create UIs in no time at all.

If you want to take it further, you might want to add the ability to store information that persists between app sessions. MongoDB has an amazing product, called [Atlas Device Sync](https://www.mongodb.com/docs/atlas/app-services/sync/), that allows you to store data on the device for your app and have it sync to MongoDB Atlas. You can read more about this and how to get started in our [Kotlin Docs](https://mdb.link/atlas-device-sync-docs).


In this tutorial, you will learn the basics of getting started with your first Android app, using the programming language Kotlin. 

Building an Android App

MongoDB

Timothy Marland

Enterprises around the world are looking to modernize their existing applications. They need a streamlined way to synchronize data from devices at the Edge into their cloud data stores. Whether their goals are business growth or fending off the competition, application modernization is the primary vehicle that will help them get there. 

Often the first step in this process is to move data from an existing relational database repository (like Oracle, SQL Server, DB2, or Postgres, for example) into a JSON-based flexible database in the cloud (like MongoDB, Aerospike, Couchbase, Cassandra, or DocumentDB). Sounds simple, right? I mean, really, if JSON (NoSQL) is so simple and flexible, why would data migration be hard? There must be a bunch of automated tools to facilitate this data migration, right? 

Unfortunately, the answers are “Not really,” “Because data synchronization is rarely simple,” and “The available tools are often DIY-based and don’t provide nearly the level of automation required to facilitate an ongoing, large-scale, production-quality, conflict-resolved data synchronization.”

## Why is this so complex?

### Data modeling

One of the first challenges is data modeling. To effectively leverage the benefits inherent in a JSON-based schema, you need to include data modeling as part of your migration strategy. Simply flattening or de-normalizing a relational schema into nested JSON structures, or worse yet, simply moving from relational to JSON without any data modeling consideration, results in a JSON data repository that is slow, inefficient, and difficult to query. You need an intelligent data modeling platform that automatically creates the most effective JSON structures based on your application needs and the target JSON repository without requiring specialized resources like data scientists and data engineers. 

### Building and monitoring pipelines

Once you’ve mapped the data, you need tools that allow you to build reliable, scalable data pipelines to move the data from the source to the target repository. Sadly, most of the tools available today are primarily DIY scripting tools that require both custom (often complex) coding to transform the data to the new schema properly and custom (often complex) monitoring to ensure that the new data pipelines are working reliably. You need a data pipeline automation and monitoring platform to move the data and ensure its quality. 

### DIY is hard

This process of data synchronization, pipeline automation, and monitoring is where most application modernization projects get bogged down and/or ultimately fail. These failed projects often consume significant resources before they fail, as well as affect the overall business functionality and outcomes, and lead to missed objectives. 

## CDC: MongoDB Atlas, Atlas Device Sync, and Dataworkz

Synchronizing data between edge devices and various databases can be complex. Simplifying this is our goal, and we will demonstrate how to achieve bi-directional synchronization between mobile devices at MySQL in the cloud using MongoDB Atlas Device Sync and Dataworkz.

Let's dive in.

## Prerequisites 

- Accounts with [MongoDB Atlas](https://www.mongodb.com/cloud/atlas/register) (this can be tested on free tiers), [Dataworkz](http://dataworkz.com/), and Google Cloud
- Kafka
- Debezium

## Step 1: prepare your mobile application with Atlas Device Sync

Set up a template app for this test by following the [steps outlined in the docs](https://www.mongodb.com/docs/atlas/app-services/get-started/#tutorials). Once that step is complete, you will have a mobile application running locally, with automated synchronization back to MongoDB Atlas using the Atlas Device Sync SDK. 

## Step 2: set up a source database and target MongoDB Atlas Collection

We used GCP in us-west1-a and Cloud MySQL for this example. Be sure to include [sample data](https://www.mongodb.com/docs/guides/atlas/sample-data/).

### Check if BinLog replication is already enabled

![Check if BinLog Replication is Enabled][1]

1. Access your Google Cloud MySQL instance.
2. In the left navigation pane, under **Databases**, select **Backups**.
3. Access your Google Cloud MySQL instance.
4. In **Settings**, check the status of **Automated backups**.
5. If the status is *Disabled*, follow the steps below.

### Enable BinLog replication

These steps are necessary to set up some of the background processes which enable ongoing two-way synchronization.

1. In **Backups**, **Settings**, click **+ CREATE BACKUP**.
2. In the **Edit backup settings** dialog:
    - Select the **Automate backups** and **Enable point-in-time recovery** check boxes.
    - Click **SAVE** to activate the changes.

![Enable Automated Backups][2]

3. Check the status of **Automated backups** again under **Settings**. It should appear as shown below. This step is important because the metadata created in the backup process is used by the tools to help enable bi-directional synchronization.

![GCP Backup Settings][3]

### Step 3: configure connector for MySQL 

The connector for MySQL needs to be defined in Dataworkz.

![Configure Dataworkz for MySQL][4]

- Log in to the Dataworkz application. 
- Go to **Configuration** -> **Databases** -> **MySQL**. 
- Click the + icon in the above image to add the configuration. 
- It will open the MySQL configuration screen. 

![Connect to MySQL in Dataworkz][5]

- Provide the following details in the configuration screen: 
    - MySQL connector name 
    - Host server and port 
    - User name 
    - Password 
    - Select Deployment Type 
    - Select TLS/SSL option as appropriate 
- Click **Save** to add the MySQL configuration. 

### Step 4: configure connector for MongoDB 

The connector for MongoDB Atlas needs to be defined in Dataworkz. 

![MongoDB Atlas definition in Dataworkz][6]

- Log in to the Dataworkz application. 
- Go to **Configuration** -> **Databases** -> **MongoDB.**
- Click the + icon in the above image to add the configuration. 
- It will open the MongoDB configuration screen. 

![MongoDB configuration screen in Dataworkz][7]

- Provide the following details in the configuration screen (these can be accessed by clicking on the **Connect** button displayed below).
    - MongoDB Connector Name 
    - Host server 
    - User name 
    - Password 

![MongoDB Atlas Connect button display on overview screen][8]

- Click **Save** to add the MongoDB configuration. 

### Step 5: set up Kafka

The connector for Kafka needs to be defined in Dataworkz.

![Kafka connection configuration in Dataworkz][9]

- Log in to the Dataworkz application.
- Go to **Configuration** -> **Streaming Systems** -> **Kafka**. 
- Click the + icon in the above image to add the configuration. 
- It will open the Kafka configuration screen. 

![Kafka connection configuration details in Dataworkz][10]

- Provide the following details in the configuration screen: 
    - Kafka Connector Name 
    - Bootstrap server name and port (as per the format in the image below) 
    - Zookeeper (optional)
- Click **Save** to add the Kafka configuration. 

### Step 6: configure CDC for MySQL 

Configure CDC for MySQL in Dataworkz by following these steps:

![MySQL CDC configuration in Dataworkz][11]

- Log in to the Dataworkz application. 
- Go to **Configuration** -> **Change Data Capture** -> **MySQL**. 
- Click the + icon in the above image to add the configuration. 
- It will open the CDC configuration screen. 

![Dataworkz CDC configuration screen][12]

- Provide the details in the configuration detail screen: 
    - Choose the Workspace. 
    - Choose Kafka (which was configured in the previous step).
    - Add the Debezium server name. 
    - Choose the MYSQL Storage that was previously configured. 
- Select the appropriate database from the list. 
- Choose the Database table for Sync.

![Dataworkz CDC configuration screen][13]

You can see the configured MySQL CDC in the list of configurations. 

![Dataworkz MySQL CDC configuration showing up in list][14]

### Step 7: data preparation — JSON modeling 

This step enables the modeling of the results of RDBMS in JSON structure. To do this, select **Data Prep** -> **JSON Modeller** inside the Dataworkz settings.

![Dataworkz settings JSON modeling setup][15]

![Dataworkz settings JSON modeling detail screen][16]

- Click on **Select root dataset for json modeling** (above image).

![Workspace selection screen for CDC][17]

- Select the Workspace in which MySQL CDC was configured. 
- Select cdc_kafka as the Source Collection. 
- Choose root/base table/dataset. 
- Click on the **Enable Bi-directional sync** checkbox. 
- Select a sync field from the list of the columns that will be used to determine the last updated time for a row. 
- Select columns for the target dataset. 
- Click **Update** and you will see the below screen. 

![JSON modeling screen in Dataworkz][18]

- Choose the desired mapping with the base table by right-clicking. 
    - If the table has one-to-many mapping, choose **Create array document**. 
    - If the table has one-to-one mapping, choose **Create field in child document** 
- Selecting **create array document** would require selecting a child table relationship (for creation of an array document).
- Choose **Child Table** in the screen that pops up. 

![Dataworkz array document child table screen][19]

- Choose **join key** in the **Relationship mapping** section. 
- In the **Unique Key** section, choose the unique key for the child table (used for update or delete events). 
- Select a sync field from the list of the columns that will be used to determine the last updated time for a row. 
- Click **update**. 
- A one-to-many relationship shows up. 

![Dataworkz JSON model detail screen][20]

- Click on **Save** and choose the target destination (MongoDB Collection, in this case).

![Dataworkz JSON Upsert and key settings][21]

- Choose **Transfer Mode** as Upsert and select the unique key for the base table in the pop-up box. 

![Dataworkz custom mapping settings screen][22]

- Choose the desired job name and select the job frequency as **Recurring**. Set this job as **Continuous** from the **Choose Frequency** section. 

![Dataworkz job frequency setitngs screen][23]

### Step 8: monitoring/maintaining the sync job 

The sync job that was scheduled in the previous step can be viewed under **Jobs** -> **Continuous Job**” in the Dataworkz portal. It provides the following: 

- job status (running/deleted/paused) 
- ability to pause a running job 
- ability to resume a paused job 
- ability to delete a continuous job

![Dataworkz sync job summary screen][24]

## Conclusion

MongoDB Atlas Device Sync streamlines and automates the challenges of mobile data synchronization with Atlas. By integrating with Dataworkz, that same data can now be automatically and bi-directionally synchronized with MySQL, Oracle and other databases.

Set up your account at [cloud.mongodb.com](https://www.mongodb.com/products/platform/cloud) and [dataworkz.com](https://www.dataworkz.com/) to create accounts and begin your automated bi-directional data synchronization journey.


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt85b18bd98135559d/65c54454245ed9597d91062b/1.jpg
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt0f313395e6bb7e0a/65c5447cf0270544bcea8b0f/2.jpg
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt42fc95f74b034c2c/65c54497ab9c0fe8aab945fc/3.jpg
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt0bf05ceea39406ef/65c544b068e9235c39e585bc/4.png
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt852256fbd6c92a1d/65c544cf245ed9f5af910634/5.png
  [6]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt6f7a22db7bfeb113/65c544f78b3a0d12277c6c70/6.png
  [7]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt732e20dad37e46e1/65c54515fb34d04d731b1a80/7.png
  [8]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltc1f83c67ed8bf7e5/65c5453625aa94148c3513c5/8.png
  [9]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltcfe7cf5ed073b181/65c5454a49edef40e16a355a/9.png
  [10]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt99688601bdbef64a/65c5455d211bae4eaea55ad0/10.png
  [11]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt7317f754880d41ba/65c545780acbc5455311135a/11.png
  [12]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt690ff6f3783cb06f/65c5458b68e92372a8e585d2/12.png
  [13]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt0810a0d139692e45/65c545a5ab9c0fdc87b9460a/13.png
  [14]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt39b298970485dc92/65c545ba4cd37037ee70ec51/14.png
  [15]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt6596816400af6c46/65c545d4eed32eadf6ac449d/15.png
  [16]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4eaf0f6c5b0ca4a5/65c545e3ff4e591910ad0ed6/16.png
  [17]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt9ffa8c37f5e26e5f/65c545fa4cd3709a7870ec56/17.png
  [18]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt1678582be8e8cc07/65c5461225aa943f393513cd/18.png
  [19]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltd4b2f6a8e389884a/65c5462625aa94d9b93513d1/19.png
  [20]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltbd4a6e31ba6103f6/65c5463fd4db5559ac6efc99/20.png
  [21]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt6e3be8f5f7f0e0f1/65c546547998dae7b86b5e4b/21.png
  [22]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltd2fccad909850d63/65c54669d2c66186e28430d5/22.png
  [23]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blted07a5674eae79e0/65c5467d8b3a0d226c7c6c7f/23.png
  [24]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt8b8b5ce479b8fc7b/65c5469125aa94964c3513d5/24.png

Learn how to set up automated, automated, bi-directional synchronization of data from mobile devices to MongoDB Atlas  and Google Cloud MySQL.

Synchronize Your Mobile Application With MongoDB Atlas and Google Cloud MySQL

Andrew Morgan

Staff Developer Advocate

How to incorporate Realm into your iOS App. Building a chat app with SwiftUI and Realm-Cocoa

Building a Mobile Chat App Using Realm – Integrating Realm into Your App

Aniket Kadam

Developer Advocate

Dive into: Compose architecture A globally synced Emoji garden Reactivity like you've never seen before!

Mobile

Featured

Synchronize Your Mobile Application With MongoDB Atlas and Google Cloud MySQL

Building an Android App

Sync your iOS SwiftUI App with MongoDB Atlas using Atlas Device Sync | Part 2

All Mobile Content