Full OMA experience app

microapps/OfflineMapAreasApp/README.md

@@ -2,12 +2,8 @@
 
 This micro-app demonstrates the use of the `OfflineMapAreas` toolkit component to take a web map offline by downloading map areas.
 
-| Online map 	| Opened map 	| Offline mode 	|
-|:---:	|---	|:---:	|
-| <img src="microapp_screenshot.png"> | <img src="open_map_screenshot.png"> | <img src="offline_map_screenshot.png"> |
-
 ## Usage
 
-The application displays the ahead-of-time (preplanned) maps available to download using the stormwater network within Naperville [web-map](https://arcgisruntime.maps.arcgis.com/home/item.html?id=acc027394bc84c2fb04d1ed317aac674). This app displays, downloads, and monitors the status of map areas, allowing users to view details or remove downloaded files. For preplanned maps, it shows available areas when online and downloaded ones when offline; for on-demand, users can define and download custom map areas.
+ToDo…
 
-For more information on the `OfflineMapAreas` component and how it works, see its [Readme](../../toolkit/offline).
+For more information on the `OfflineMapAreas` component and how it works, see its [Readme](../../toolkit/offline).

microapps/OfflineMapAreasApp/app/build.gradle.kts

@@ -21,6 +21,8 @@ plugins {
     id("org.jetbrains.kotlin.android")
     id("org.jetbrains.kotlin.plugin.compose")
     id("com.google.android.libraries.mapsplatform.secrets-gradle-plugin")
+    id("com.google.dagger.hilt.android")
+    id("com.google.devtools.ksp")
 }
 
 secrets {
@@ -77,16 +79,33 @@ android {
 }
 
 dependencies {
+    implementation(project(":authentication"))
     implementation(project(":geoview-compose"))
-    implementation(arcgis.mapsSdk)
     implementation(project(":offline"))
     implementation(project(":microapps-lib"))
+    // sdk
+    implementation(arcgis.mapsSdk)
+    // hilt
+    implementation(libs.hilt.android.core)
+    implementation(libs.androidx.hilt.navigation.compose)
+    ksp(libs.hilt.compiler)
+    // room
+    implementation(libs.room.runtime)
+    annotationProcessor(libs.room.compiler)
+    implementation(libs.room.ext)
+    ksp(libs.room.compiler)
+    // jetpack window manager
+    implementation(libs.androidx.window)
+    implementation(libs.androidx.window.core)
+    // compose
     implementation(platform(libs.androidx.compose.bom))
     implementation(libs.bundles.composeCore)
     implementation(libs.bundles.core)
     implementation(libs.androidx.activity.compose)
+    implementation(libs.androidx.compose.navigation)
     implementation(libs.androidx.lifecycle.viewmodel.compose)
     testImplementation(libs.bundles.unitTest)
+    testImplementation(platform(libs.androidx.compose.bom))
     androidTestImplementation(platform(libs.androidx.compose.bom))
     androidTestImplementation(libs.bundles.composeTest)
     debugImplementation(libs.bundles.debug)

microapps/OfflineMapAreasApp/app/src/main/AndroidManifest.xml

@@ -25,6 +25,7 @@
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
 
     <application
+        android:name=".OfflineMapAreasApplication"
         android:allowBackup="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"
@@ -44,6 +45,22 @@
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+        <activity
+            android:name="com.arcgismaps.toolkit.authentication.AuthenticationActivity"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenSize"
+            android:exported="true"
+            android:launchMode="singleTop" >
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data
+                    android:host="auth"
+                    android:scheme="featureformsapp" />
+            </intent-filter>
+        </activity>
     </application>
 
 </manifest>

microapps/OfflineMapAreasApp/app/src/main/java/com/arcgismaps/toolkit/offlinemapareasapp/MainActivity.kt

@@ -1,6 +1,6 @@
 /*
  *
- *  Copyright 2025 Esri
+ *  Copyright 2024 Esri
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -26,41 +26,113 @@ import android.util.Log
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
 import androidx.activity.result.contract.ActivityResultContracts.RequestPermission
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
 import androidx.core.content.ContextCompat
-import com.arcgismaps.ApiKey
+import androidx.lifecycle.lifecycleScope
+import androidx.navigation.compose.rememberNavController
 import com.arcgismaps.ArcGISEnvironment
-import com.arcgismaps.toolkit.offlinemapareasapp.screens.MainScreen
-import com.esri.microappslib.theme.MicroAppTheme
+import com.arcgismaps.httpcore.authentication.ArcGISCredentialStore
+import com.arcgismaps.httpcore.authentication.NetworkCredentialStore
+import com.arcgismaps.portal.Portal
+import com.arcgismaps.toolkit.offlinemapareasapp.data.PortalSettings
+import com.arcgismaps.toolkit.offlinemapareasapp.navigation.AppNavigation
+import com.arcgismaps.toolkit.offlinemapareasapp.navigation.NavigationRoute
+import com.arcgismaps.toolkit.offlinemapareasapp.navigation.Navigator
+import com.arcgismaps.toolkit.offlinemapareasapp.theme.OfflineMapAreasAppTheme
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
 
+@AndroidEntryPoint
 class MainActivity : ComponentActivity() {
+
+    // Interface to get the PortalSettings instance from Hilt
+    @EntryPoint
+    @InstallIn(SingletonComponent::class)
+    interface PortalSettingsFactory {
+        fun getPortalSettings(): PortalSettings
+    }
+
+    @Inject
+    lateinit var navigator: Navigator
+
+    private val appState: MutableStateFlow<AppState> = MutableStateFlow(AppState.Loading)
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        ArcGISEnvironment.apiKey = ApiKey.create(BuildConfig.API_KEY)
+        ArcGISEnvironment.applicationContext = this
+        enableEdgeToEdge()
         setContent {
-            MicroAppTheme {
-                OfflineMapAreasApp()
-                RequestNotificationPermission(
-                    onResult = { isGranted ->
-                        if (!isGranted) {
-                            Log.e("OfflineMapAreas", "Notification permission request was denied.")
-                        }
-                    })
+            OfflineMapAreasAppTheme {
+                OfflineMapAreasApp(
+                    appState.collectAsState().value,
+                    navigator
+                )
             }
         }
+        lifecycleScope.launch {
+            // fetch the singleton PortalSettings
+            val factory = EntryPointAccessors.fromApplication(
+                this@MainActivity,
+                PortalSettingsFactory::class.java
+            )
+            loadCredentials(factory.getPortalSettings())
+        }
     }
-}
 
-@Composable
-fun OfflineMapAreasApp() {
-    MainScreen()
+    private suspend fun loadCredentials(portalSettings: PortalSettings) =
+        withContext(Dispatchers.Default) {
+            // create and set a ArcGISCredentialStore that persists
+            val arcGISCredentialStore = ArcGISCredentialStore.createWithPersistence().getOrThrow()
+            ArcGISEnvironment.authenticationManager.arcGISCredentialStore = arcGISCredentialStore
+            // create and set a NetworkCredentialStore that persists
+            val networkCredentialStore = NetworkCredentialStore.createWithPersistence().getOrThrow()
+            ArcGISEnvironment.authenticationManager.networkCredentialStore = networkCredentialStore
+            // get the portal settings url
+            val url = portalSettings.getPortalUrl()
+            // check if any credentials are present for this portal
+            val credential =
+                ArcGISEnvironment.authenticationManager.arcGISCredentialStore.getCredential(url)
+            appState.value = if (credential == null) {
+                // if the portal connection type set it Anonymous, then the user has skipped sign in
+                if (portalSettings.getPortalConnection() == Portal.Connection.Anonymous) {
+                    AppState.SkipSignIn
+                } else {
+                    AppState.NotLoggedIn
+                }
+            } else {
+                AppState.LoggedIn
+            }
+        }
 }
 
 @Composable
@@ -102,3 +174,75 @@ private fun RequestNotificationPermission(
         }
     }
 }
+
+@Composable
+fun OfflineMapAreasApp(
+    appState: AppState,
+    navigator: Navigator
+) {
+    if (appState is AppState.Loading) {
+        AnimatedLoading({ true }, modifier = Modifier.fillMaxSize())
+    } else {
+        // create a NavController
+        val navController = rememberNavController()
+        // if the user has logged in or skipped sign in, go to the Home screen, else present
+        // login screen
+        val startDestination =
+            if (appState is AppState.LoggedIn || appState is AppState.SkipSignIn) {
+                NavigationRoute.Home.route
+            } else {
+                NavigationRoute.Login.route
+            }
+        AppNavigation(
+            navController = navController,
+            navigator = navigator,
+            startDestination = startDestination
+        )
+    }
+    RequestNotificationPermission(
+        onResult = { isGranted ->
+            if (!isGranted) {
+                Log.e("OfflineMapAreas", "Notification permission request was denied.")
+            }
+        })
+}
+
+@Composable
+fun AnimatedLoading(
+    visibilityProvider: () -> Boolean,
+    modifier: Modifier = Modifier,
+    backgroundColor: Color = MaterialTheme.colorScheme.surface,
+    statusText: String = "",
+) {
+    val visible = visibilityProvider()
+    if (visible) {
+        Surface(
+            modifier = modifier,
+            color = backgroundColor
+        ) {
+            Column(
+                verticalArrangement = Arrangement.Center,
+                horizontalAlignment = Alignment.CenterHorizontally
+            ) {
+                CircularProgressIndicator(
+                    modifier = Modifier.size(30.dp),
+                    strokeWidth = 5.dp
+                )
+                if (statusText.isNotEmpty()) {
+                    Spacer(modifier = Modifier.size(10.dp))
+                    Text(text = statusText)
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Represents the current app state based on the login state of the user.
+ */
+sealed class AppState {
+    data object Loading : AppState()
+    data object LoggedIn : AppState()
+    data object NotLoggedIn : AppState()
+    data object SkipSignIn : AppState()
+}

microapps/OfflineMapAreasApp/app/src/main/java/com/arcgismaps/toolkit/offlinemapareasapp/OfflineMapAreasApplication.kt

@@ -0,0 +1,25 @@
+/*
+ *
+ *  Copyright 2023 Esri
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package com.arcgismaps.toolkit.offlinemapareasapp
+
+import android.app.Application
+import dagger.hilt.android.HiltAndroidApp
+
+@HiltAndroidApp
+class OfflineMapAreasApplication : Application()