connectivity

Running on a device or emulator

Open the project in Android Studio and execute the imported android run configuration.

Building an application bundle

To build a debug APK, run the following Gradle command:

./gradlew :composeApp:assembleDebug

The resulting .apk file can be found at: composeApp/build/outputs/apk/debug/composeApp-debug.apk

For a Kotlin Multiplatform project targeting both Android and Apple devices, add connectivity-core and connectivity-device to your commonMain source set. For Compose support, add connectivity-compose-device.

kotlin {
    sourceSets {
        commonMain.dependencies {
          implementation(libs.connectivity.core)
          implementation(libs.connectivity.device)

          // For compose support
          implementation(libs.connectivity.compose.device)
        }
    }
}

If your project needs to support both Device-based monitoring (for mobile) and HTTP-based monitoring (for other platforms), use the expect/actual pattern to provide the correct Connectivity implementation for each target.

1. Define an expect function in commonMain.
2. Implement actual for mobile targets using connectivity-device.
3. Implement actual for other targets using connectivity-http.

// commonMain/Platform.kt
expect fun createConnectivity(): Connectivity

// deviceMain/Platform.device.kt
actual fun createConnectivity(): Connectivity {
  return Connectivity {
    autoStart = true
  }
}

// httpMain/Platform.http.kt
actual fun createConnectivity(): Connectivity {
  return Connectivity {
    autoStart = true
    urls("cloudflare.com", "my-own-domain.com")
    port = 80
    pollingIntervalMs = 10.minutes
    timeoutMs = 5.seconds
  }
}

Open the project in Android Studio and allow the project to sync. Once synced, you can select one of the following configurations from the configuration dropdown to run:

• demo.android
• demo.desktop
• demo.ios
• demo.browser

You can run the iOS application using one of two methods:

1. Xcode: Open iosApp/iosApp.xcworkspace in Xcode and run a standard configuration.
2. Android Studio: Use the Kotlin Multiplatform Mobile plugin to run the iOS target directly from Android Studio.

Before running the Connectivity Demo, ensure your development environment meets the following requirements:

• Run KDoctor to check your system configuration.
• Install JDK 8 on your machine.
• Install the Kotlin Multiplatform Mobile plugin in your IDE.

To use Connectivity in a single-platform Android project, add the connectivity-core and connectivity-android dependencies. If you require Compose support, also include connectivity-compose-device.

dependencies {
  implementation(libs.connectivity.core)
  implementation(libs.connectivity.android)

  // For compose support
  implementation(libs.connectivity.compose.device)
}

You can observe network connectivity by creating a Connectivity instance and collecting from its statusUpdates flow. Note that you must call .start() to begin monitoring unless autoStart = true is configured in the options.

val connectivity = Connectivity()
connectivity.start()
coroutineScope.launch {
  connectivity.statusUpdates.collect { status ->
    when (status) {
      is Connectivity.Status.Connected -> println("Connected to network")
      is Connectivity.Status.Disconnected -> println("Disconnected from network")
    }
  }
}

Use the suspended status() function to retrieve the current connectivity state immediately.

val connectivity = Connectivity()
coroutineScope.launch {
    val status = connectivity.status()
    when (status) {
        is Connectivity.Status.Connected -> println("Connected to network")
        is Connectivity.Status.Disconnected -> println("Disconnected from network")
    }
}

To use connectivity in Compose, add the appropriate connectivity-compose-x dependency. Use the rememberConnectivityState composable to observe the network status.

@Composable
fun MyApp() {
  val state = rememberConnectivityState { 
    autoStart = true 
  }

  when (state.status) {
    is Connectivity.Status.Connected -> Text("Connected to network")
    is Connectivity.Status.Disconnected -> Text("Disconnected from network")
    else -> {}
  }
}

@Composable
fun MyApp() {
  val state = rememberConnectivityState { 
    // Optional configurator for ConnectivityOptions
    autoStart = true
  }

  when (state.status) {
    is Connectivity.Status.Connected -> Text("Connected to network")
    is Connectivity.Status.Disconnected -> Text("Disconnected from network")
    else -> {}
  }
}

By default, Connectivity does not start monitoring automatically. You can enable automatic starting by passing a configuration block to the Connectivity factory function.

val connectivity = Connectivity {
    autoStart = true
}