expo-dev-launcher 5.2.0-canary-20250630-547cd82 → 5.2.0-canary-20250709-136b77f

package/CHANGELOG.md

@@ -11,6 +11,7 @@
 ### 🐛 Bug fixes
 
 - [iOS] Fix missing CDP headers when using static frameworks. ([#37448](https://github.com/expo/expo/pull/37448) by [@alanjhughes](https://github.com/alanjhughes))
+- [Android] Use same strings in UI as iOS. ([#37786](https://github.com/expo/expo/pull/37786) by [@douglowder](https://github.com/douglowder))
 
 ### 💡 Others
 
@@ -20,6 +21,14 @@
 
 - Added support for React Native 0.80.x. ([#37400](https://github.com/expo/expo/pull/37400) by [@gabrieldonadel](https://github.com/gabrieldonadel))
 
+## 5.1.16 - 2025-07-03
+
+_This version does not introduce any user-facing changes._
+
+## 5.1.15 - 2025-07-02
+
+_This version does not introduce any user-facing changes._
+
 ## 5.1.14 - 2025-06-26
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -5,6 +5,7 @@ buildscript {
   dependencies {
     classpath("org.jetbrains.kotlin.plugin.compose:org.jetbrains.kotlin.plugin.compose.gradle.plugin:${kotlinVersion}")
     classpath("org.jetbrains.kotlin.plugin.serialization:org.jetbrains.kotlin.plugin.serialization.gradle.plugin:${kotlinVersion}")
+    classpath("com.apollographql.apollo:apollo-gradle-plugin:4.3.1")
   }
 }
 
@@ -12,19 +13,20 @@ apply plugin: 'com.android.library'
 apply plugin: 'expo-module-gradle-plugin'
 apply plugin: 'org.jetbrains.kotlin.plugin.compose'
 apply plugin: 'org.jetbrains.kotlin.plugin.serialization'
+apply plugin: 'com.apollographql.apollo'
 
 expoModule {
   canBePublished false
 }
 
 group = "host.exp.exponent"
-version = "5.2.0-canary-20250630-547cd82"
+version = "5.2.0-canary-20250709-136b77f"
 
 android {
   namespace "expo.modules.devlauncher"
   defaultConfig {
     versionCode 9
-    versionName "5.2.0-canary-20250630-547cd82"
+    versionName "5.2.0-canary-20250709-136b77f"
   }
 
   buildTypes {
@@ -39,6 +41,15 @@ android {
   }
 }
 
+apollo {
+  service("service") {
+    packageName.set("expo.modules.devlauncher")
+    introspection {
+      endpointUrl.set("https://api.expo.dev/graphql")
+      schemaFile.set(file("src/main/graphql/schema.graphqls"))
+    }
+  }
+}
 repositories {
   // ref: https://www.baeldung.com/maven-local-repository
   mavenLocal()
@@ -87,6 +98,8 @@ dependencies {
   implementation "androidx.compose.ui:ui-tooling:$composeVersion"
   implementation "androidx.navigation:navigation-compose:2.9.0"
 
+  implementation("com.apollographql.apollo:apollo-runtime:4.3.1")
+
   implementation("com.composables:core:1.31.1")
 
   testImplementation 'androidx.test:core:1.4.0'

package/android/src/debug/AndroidManifest.xml

@@ -4,7 +4,12 @@
       android:name="expo.modules.devlauncher.launcher.DevLauncherActivity"
       android:exported="true"
       android:launchMode="singleTask"
-      android:theme="@style/Theme.DevLauncher.LauncherActivity">
+      android:theme="@style/Theme.DevLauncher.LauncherActivity" />
+
+    <activity
+      android:name="expo.modules.devlauncher.compose.AuthActivity"
+      android:exported="true"
+      android:launchMode="singleTask">
       <intent-filter>
         <action android:name="android.intent.action.VIEW" />
 

package/android/src/debug/java/expo/modules/devlauncher/compose/AuthActivity.kt

@@ -0,0 +1,136 @@
+package expo.modules.devlauncher.compose
+
+import android.content.Context
+import android.content.Intent
+import android.content.Intent.ACTION_VIEW
+import android.os.Bundle
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.appcompat.app.AppCompatActivity
+import androidx.browser.customtabs.CustomTabsIntent
+import androidx.core.net.toUri
+import java.net.URLEncoder
+
+enum class AuthRequestType(val type: String) {
+  LOGIN("login"),
+  SIGNUP("signup");
+
+  companion object {
+    fun fromString(type: String): AuthRequestType {
+      return entries.firstOrNull { it.type == type } ?: LOGIN
+    }
+  }
+}
+
+private const val SESSION_KEY = "session"
+private const val USERNAME_KEY = "username"
+private const val AUTH_REQUEST_TYPE_KEY = "auth_request_type"
+
+private const val WEBSITE_ORIGIN = "https://expo.dev"
+private const val REDIRECT_BASE = "expo-dev-launcher://auth"
+
+sealed interface AuthResult {
+  data class Success(val sessionSecret: String, val username: String) : AuthResult
+  object Canceled : AuthResult
+}
+
+class AuthActivity : AppCompatActivity() {
+  class Contract : ActivityResultContract<AuthRequestType, AuthResult>() {
+    override fun createIntent(context: Context, type: AuthRequestType): Intent {
+      return Intent(context, AuthActivity::class.java).apply {
+        action = ACTION_VIEW
+        putExtra(AUTH_REQUEST_TYPE_KEY, type.type)
+      }
+    }
+
+    override fun parseResult(resultCode: Int, intent: Intent?): AuthResult {
+      if (resultCode == RESULT_CANCELED || intent == null) {
+        return AuthResult.Canceled
+      }
+
+      val sessionSecret = intent.getStringExtra(SESSION_KEY) ?: return AuthResult.Canceled
+      val username = intent.getStringExtra(USERNAME_KEY) ?: return AuthResult.Canceled
+
+      return AuthResult.Success(
+        sessionSecret = sessionSecret,
+        username = username
+      )
+    }
+  }
+
+  var wasStarted = false
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    val extraType = intent.getStringExtra(AUTH_REQUEST_TYPE_KEY)
+    if (extraType != null) {
+      wasStarted = true
+      openWebBrowserAsync(startUrl = createAuthUrl(type = AuthRequestType.fromString(extraType)))
+    }
+  }
+
+  override fun onResume() {
+    super.onResume()
+    // onNewIntent will handle the response from the web browser
+    if (intent?.data?.host == "expo-dev-launcher") {
+      return
+    }
+
+    // We just open the browser
+    if (wasStarted) {
+      wasStarted = false
+      return
+    }
+
+    val resultIntent = Intent()
+    setResult(RESULT_CANCELED, resultIntent)
+    finish()
+  }
+
+  override fun onNewIntent(intent: Intent) {
+    super.onNewIntent(intent)
+
+    if (intent.action == ACTION_VIEW && intent.data?.scheme == "expo-dev-launcher" && intent.data?.host == "auth") {
+      val sessionSecret = intent.data?.getQueryParameter("session_secret")
+      val userNameOrEmail = intent.data?.getQueryParameter("username_or_email")
+
+      if (sessionSecret.isNullOrEmpty() || userNameOrEmail.isNullOrEmpty()) {
+        setResult(RESULT_CANCELED)
+        finish()
+        return
+      }
+
+      val resultIntent = Intent().apply {
+        putExtra(SESSION_KEY, sessionSecret)
+        putExtra(USERNAME_KEY, userNameOrEmail)
+      }
+      setResult(RESULT_OK, resultIntent)
+      finish()
+    }
+  }
+
+  private fun openWebBrowserAsync(startUrl: String) {
+    requireNotNull(startUrl)
+
+    val intent = createCustomTabsIntent()
+    intent.data = startUrl.toUri()
+
+    startActivity(intent)
+  }
+
+  private fun createCustomTabsIntent(): Intent {
+    val builder = CustomTabsIntent.Builder()
+    builder.setShowTitle(false)
+
+    val intent = builder.build().intent
+
+    // We cannot use builder's method enableUrlBarHiding, because there is no corresponding disable method and some browsers enables it by default.
+    intent.putExtra(CustomTabsIntent.EXTRA_ENABLE_URLBAR_HIDING, false)
+
+    return intent
+  }
+
+  private fun createAuthUrl(type: AuthRequestType): String {
+    return "${WEBSITE_ORIGIN}/${type.type}?confirm_account=1&app_redirect_uri=${URLEncoder.encode(REDIRECT_BASE, "UTF-8")}"
+  }
+}

package/android/src/debug/java/expo/modules/devlauncher/compose/BindingView.kt

@@ -2,20 +2,15 @@ package expo.modules.devlauncher.compose
 
 import android.content.Context
 import android.widget.LinearLayout
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
 import androidx.compose.ui.platform.ComposeView
 import expo.modules.devmenu.compose.theme.AppTheme
 
-class BindingView(context: Context, lazyViewModel: Lazy<DevLauncherViewModel>) : LinearLayout(context) {
-  val viewModel by lazyViewModel
-
+class BindingView(context: Context) : LinearLayout(context) {
   init {
     addView(
       ComposeView(context).apply {
         setContent {
           AppTheme {
-            val runningPackager by viewModel.packagerService.runningPackagers.collectAsState()
             DevLauncherBottomTabsNavigator()
           }
         }

package/android/src/debug/java/expo/modules/devlauncher/compose/DevLauncherBottomTabsNavigator.kt

@@ -10,29 +10,19 @@ import androidx.compose.foundation.verticalScroll
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.painter.Painter
-import androidx.compose.ui.tooling.preview.Preview
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.rememberNavController
-import com.composables.core.SheetDetent.Companion.Hidden
 import expo.modules.devlauncher.compose.primitives.DefaultScaffold
-import expo.modules.devlauncher.compose.screens.HomeScreen
-import expo.modules.devlauncher.compose.screens.HomeScreenState
-import expo.modules.devlauncher.compose.screens.SettingsScreen
-import expo.modules.devlauncher.compose.screens.SignUp
-import expo.modules.devlauncher.compose.ui.BottomSheet
+import expo.modules.devlauncher.compose.routes.Home
+import expo.modules.devlauncher.compose.routes.HomeRoute
+import expo.modules.devlauncher.compose.routes.ProfileRoute
+import expo.modules.devlauncher.compose.routes.Settings
+import expo.modules.devlauncher.compose.routes.SettingsRoute
 import expo.modules.devlauncher.compose.ui.BottomTabBar
 import expo.modules.devlauncher.compose.ui.Full
 import expo.modules.devlauncher.compose.ui.rememberBottomSheetState
-import expo.modules.devmenu.compose.theme.AppTheme
 import expo.modules.devmenu.compose.theme.Theme
-import kotlinx.serialization.Serializable
-
-@Serializable
-object Home
-
-@Serializable
-object Settings
 
 @Composable
 fun DefaultScreenContainer(
@@ -59,7 +49,6 @@ data class Tab(
 @Composable
 fun DevLauncherBottomTabsNavigator() {
   val navController = rememberNavController()
-
   val bottomSheetState = rememberBottomSheetState()
 
   DefaultScaffold(bottomTab = {
@@ -75,22 +64,14 @@ fun DevLauncherBottomTabsNavigator() {
         ExitTransition.None
       }
     ) {
-      composable<Home> { DefaultScreenContainer { HomeScreen(HomeScreenState(appName = "BareExpo", onProfileClick = { bottomSheetState.jumpTo(Full) })) } }
-      composable<Settings> { DefaultScreenContainer { SettingsScreen() } }
+      composable<Home> {
+        HomeRoute(onProfileClick = { bottomSheetState.jumpTo(Full) })
+      }
+      composable<Settings> {
+        SettingsRoute()
+      }
     }
   }
 
-  BottomSheet(bottomSheetState) {
-    SignUp(onClose = {
-      bottomSheetState.targetDetent = Hidden
-    })
-  }
-}
-
-@Composable
-@Preview(showBackground = true)
-fun DevLauncherBottomTabsNavigatorPreview() {
-  AppTheme {
-    DevLauncherBottomTabsNavigator()
-  }
+  ProfileRoute(bottomSheetState)
 }

package/android/src/debug/java/expo/modules/devlauncher/compose/HomeViewModel.kt

@@ -0,0 +1,84 @@
+package expo.modules.devlauncher.compose
+
+import android.util.Log
+import androidx.compose.runtime.mutableStateOf
+import androidx.core.net.toUri
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import expo.modules.devlauncher.DevLauncherController
+import expo.modules.devlauncher.MeQuery
+import expo.modules.devlauncher.services.HttpClientService
+import expo.modules.devlauncher.services.PackagerInfo
+import expo.modules.devlauncher.services.PackagerService
+import expo.modules.devlauncher.services.SessionService
+import expo.modules.devlauncher.services.UserState
+import expo.modules.devlauncher.services.inject
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
+
+sealed interface HomeAction {
+  class OpenApp(val url: String) : HomeAction
+}
+
+typealias HomeActionHandler = (HomeAction) -> Unit
+
+data class HomeState(
+  val appName: String = "BareExpo",
+  val runningPackagers: Set<PackagerInfo> = emptySet(),
+  val currentAccount: MeQuery.Account? = null
+)
+
+class HomeViewModel() : ViewModel() {
+  val httpClientService = inject<HttpClientService>()
+  val devLauncherController = inject<DevLauncherController>()
+  val sessionService = inject<SessionService>()
+
+  val packagerService = PackagerService(httpClientService.httpClient, viewModelScope)
+
+  private var _state = mutableStateOf(
+    HomeState(
+      runningPackagers = packagerService.runningPackagers.value,
+      currentAccount = when (val userState = sessionService.user.value) {
+        UserState.Fetching, UserState.LoggedOut -> null
+        is UserState.LoggedIn -> userState.selectedAccount
+      }
+    )
+  )
+
+  val state
+    get() = _state.value
+
+  init {
+    packagerService.runningPackagers.onEach { newPackagers ->
+      _state.value = _state.value.copy(
+        runningPackagers = newPackagers
+      )
+    }.launchIn(viewModelScope)
+
+    sessionService.user.onEach { newUser ->
+      when (newUser) {
+        UserState.Fetching, UserState.LoggedOut -> _state.value = _state.value.copy(
+          currentAccount = null
+        )
+
+        is UserState.LoggedIn -> _state.value = _state.value.copy(
+          currentAccount = newUser.selectedAccount
+        )
+      }
+    }.launchIn(viewModelScope)
+  }
+
+  fun onAction(action: HomeAction) {
+    when (action) {
+      is HomeAction.OpenApp ->
+        viewModelScope.launch {
+          try {
+            devLauncherController.loadApp(action.url.toUri(), mainActivity = null)
+          } catch (e: Exception) {
+            Log.e("DevLauncher", "Failed to open app: ${action.url}", e)
+          }
+        }
+    }
+  }
+}

package/android/src/debug/java/expo/modules/devlauncher/compose/ProfileViewModel.kt

@@ -0,0 +1,81 @@
+package expo.modules.devlauncher.compose
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import expo.modules.devlauncher.services.SessionService
+import expo.modules.devlauncher.services.UserState
+import expo.modules.devlauncher.services.inject
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.update
+
+data class Account(
+  val id: String,
+  val name: String,
+  val avatar: String?,
+  val isSelected: Boolean = false
+)
+
+sealed interface ProfileState {
+  class LoggedIn(
+    val accounts: List<Account> = emptyList()
+  ) : ProfileState
+
+  object Fetching : ProfileState
+  object LoggedOut : ProfileState
+}
+
+class ProfileViewModel : ViewModel() {
+  sealed interface Action {
+    class LogIn(val sessionSecret: String) : Action
+    class SwitchAccount(val account: Account) : Action
+    object SignOut : Action
+  }
+
+  val session = inject<SessionService>()
+
+  private val _state = MutableStateFlow<ProfileState>(ProfileState.LoggedOut)
+
+  val state
+    get() = _state.asStateFlow()
+
+  init {
+    session.user.onEach { newUserState ->
+      when (newUserState) {
+        UserState.LoggedOut -> _state.update { ProfileState.LoggedOut }
+        UserState.Fetching -> _state.update { ProfileState.Fetching }
+        is UserState.LoggedIn -> _state.update {
+          ProfileState.LoggedIn(
+            accounts = newUserState.data.meUserActor?.accounts?.map { account ->
+              Account(
+                id = account.id,
+                name = account.name,
+                avatar = account.ownerUserActor?.profilePhoto,
+                isSelected = account.id == newUserState.selectedAccount?.id
+              )
+            } ?: emptyList()
+          )
+        }
+      }
+    }
+      .launchIn(viewModelScope)
+  }
+
+  fun onAction(action: Action) {
+    when (action) {
+      is Action.LogIn -> {
+        session.setSession(
+          Session(action.sessionSecret)
+        )
+      }
+
+      Action.SignOut -> {
+        session.setSession(null)
+      }
+
+      is Action.SwitchAccount -> session.switchAccount(action.account.id)
+    }
+  }
+}

package/android/src/debug/java/expo/modules/devlauncher/compose/Session.kt

@@ -0,0 +1,33 @@
+package expo.modules.devlauncher.compose
+
+import android.content.SharedPreferences
+import org.json.JSONObject
+import androidx.core.content.edit
+
+data class Session(
+  val sessionSecret: String
+) {
+  val token: String
+    get() = JSONObject(sessionSecret).getString("id")
+
+  val version: Int
+    get() = JSONObject(sessionSecret).getInt("version")
+
+  val expiresAt: Long
+    get() = JSONObject(sessionSecret).getLong("expires_at")
+
+  companion object {
+    fun loadFromPreferences(preferences: SharedPreferences): Session? {
+      val sessionSecret = preferences.getString("session_secret", null) ?: return null
+      return Session(sessionSecret)
+    }
+  }
+}
+
+fun Session?.saveToPreferences(preferences: SharedPreferences) {
+  if (this == null) {
+    preferences.edit(commit = true) { remove("session_secret") }
+  } else {
+    preferences.edit(commit = true) { putString("session_secret", sessionSecret) }
+  }
+}

package/android/src/debug/java/expo/modules/devlauncher/compose/primitives/Accordion.kt

@@ -50,7 +50,7 @@ fun Accordion(
         Row(
           verticalAlignment = Alignment.CenterVertically,
           modifier = Modifier
-            .padding(Theme.spacing.small)
+            .padding(Theme.spacing.medium)
         ) {
           Icon(
             painter = painterResource(expo.modules.devmenu.R.drawable._expodevclientcomponents_assets_chevronrighticon),
@@ -91,7 +91,7 @@ fun Accordion(
 @Composable
 @Preview(showBackground = true, heightDp = 200)
 fun AccordionVariantPreview() {
-  Accordion(text = "Enter URL") {
+  Accordion(text = "Enter URL manually") {
     Text("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed ac nisl interdum, mattis purus a, consequat ipsum. Aliquam sem mauris, egestas a elit a, lacinia efficitur nisi. Maecenas scelerisque erat nisi, ac interdum mauris volutpat vel. Proin sed lectus at purus interdum porta. Ut mollis feugiat dignissim.")
   }
 }

package/android/src/debug/java/expo/modules/devlauncher/compose/primitives/Asyncimage.kt

@@ -0,0 +1,40 @@
+package expo.modules.devlauncher.compose.primitives
+
+import androidx.compose.foundation.Image
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.asImageBitmap
+import expo.modules.devlauncher.services.ImageLoaderService
+import expo.modules.devlauncher.services.inject
+import kotlinx.coroutines.launch
+
+@Composable
+fun AsyncImage(
+  url: String
+) {
+  val imageLoaderService = inject<ImageLoaderService>()
+  val scope = rememberCoroutineScope()
+  var imageBitmap by remember { mutableStateOf<ImageBitmap?>(null) }
+
+  LaunchedEffect(url) {
+    scope.launch {
+      val image = imageLoaderService.loadImage(url)
+      if (image != null) {
+        imageBitmap = image.asImageBitmap()
+      }
+    }
+  }
+
+  imageBitmap?.let {
+    Image(
+      bitmap = it,
+      contentDescription = url
+    )
+  }
+}

package/android/src/debug/java/expo/modules/devlauncher/compose/routes/Home.kt

@@ -0,0 +1,23 @@
+package expo.modules.devlauncher.compose.routes
+
+import androidx.compose.runtime.Composable
+import androidx.lifecycle.viewmodel.compose.viewModel
+import expo.modules.devlauncher.compose.DefaultScreenContainer
+import expo.modules.devlauncher.compose.HomeViewModel
+import expo.modules.devlauncher.compose.screens.HomeScreen
+import kotlinx.serialization.Serializable
+
+@Serializable
+object Home
+
+@Composable
+fun HomeRoute(onProfileClick: () -> Unit) {
+  DefaultScreenContainer {
+    val viewModel = viewModel<HomeViewModel>()
+    HomeScreen(
+      state = viewModel.state,
+      onAction = viewModel::onAction,
+      onProfileClick = onProfileClick
+    )
+  }
+}

package/android/src/debug/java/expo/modules/devlauncher/compose/routes/Profile.kt

@@ -0,0 +1,70 @@
+package expo.modules.devlauncher.compose.routes
+
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.composables.core.ModalBottomSheetState
+import com.composables.core.SheetDetent.Companion.Hidden
+import expo.modules.devlauncher.compose.AuthActivity
+import expo.modules.devlauncher.compose.AuthRequestType
+import expo.modules.devlauncher.compose.AuthResult
+import expo.modules.devlauncher.compose.ProfileState
+import expo.modules.devlauncher.compose.ProfileViewModel
+import expo.modules.devlauncher.compose.ui.AccountSelector
+import expo.modules.devlauncher.compose.ui.BottomSheet
+import expo.modules.devlauncher.compose.ui.ProfileLayout
+import expo.modules.devlauncher.compose.ui.SignUp
+
+@Composable
+fun ProfileRoute(
+  bottomSheetState: ModalBottomSheetState,
+  viewModel: ProfileViewModel = viewModel()
+) {
+  val state by viewModel.state.collectAsStateWithLifecycle()
+
+  val authLauncher = rememberLauncherForActivityResult(AuthActivity.Contract()) { result ->
+    when (result) {
+      is AuthResult.Canceled -> {}
+      is AuthResult.Success -> {
+        viewModel.onAction(ProfileViewModel.Action.LogIn(result.sessionSecret))
+      }
+    }
+  }
+
+  BottomSheet(bottomSheetState) {
+    ProfileLayout(onClose = {
+      bottomSheetState.targetDetent = Hidden
+    }) {
+      when (state) {
+        is ProfileState.LoggedIn -> {
+          val state = state as ProfileState.LoggedIn
+          AccountSelector(
+            accounts = state.accounts,
+            onSignOut = {
+              viewModel.onAction(ProfileViewModel.Action.SignOut)
+            },
+            onClick = { account ->
+              viewModel.onAction(ProfileViewModel.Action.SwitchAccount(account))
+            }
+          )
+        }
+
+        ProfileState.LoggedOut -> {
+          SignUp(
+            onLogIn = {
+              authLauncher.launch(AuthRequestType.LOGIN)
+            },
+            onSignUp = {
+              authLauncher.launch(AuthRequestType.SIGNUP)
+            }
+          )
+        }
+
+        ProfileState.Fetching -> {
+        }
+      }
+    }
+  }
+}