expo-dev-launcher 5.2.0-canary-20250630-547cd82 → 5.2.0-canary-20250701-6a945c5

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-20250701-6a945c5"
 
 android {
   namespace "expo.modules.devlauncher"
   defaultConfig {
     versionCode 9
-    versionName "5.2.0-canary-20250630-547cd82"
+    versionName "5.2.0-canary-20250701-6a945c5"
   }
 
   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

@@ -4,19 +4,26 @@ import android.content.Context
 import android.widget.LinearLayout
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
 import androidx.compose.ui.platform.ComposeView
+import expo.modules.devmenu.AppInfo
 import expo.modules.devmenu.compose.theme.AppTheme
 
-class BindingView(context: Context, lazyViewModel: Lazy<DevLauncherViewModel>) : LinearLayout(context) {
-  val viewModel by lazyViewModel
-
+class BindingView(context: Context, val viewModel: DevLauncherViewModel) : LinearLayout(context) {
   init {
     addView(
       ComposeView(context).apply {
         setContent {
           AppTheme {
             val runningPackager by viewModel.packagerService.runningPackagers.collectAsState()
-            DevLauncherBottomTabsNavigator()
+            val nativeAppInfo = remember { AppInfo.getNativeAppInfo(context) }
+            DevLauncherBottomTabsNavigator(
+              DevLauncherState(
+                appName = nativeAppInfo.appName,
+                runningPackagers = runningPackager,
+                onAction = viewModel::onAction
+              )
+            )
           }
         }
       }

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

@@ -0,0 +1,7 @@
+package expo.modules.devlauncher.compose
+
+sealed interface DevLauncherAction {
+  class OpenApp(val url: String) : DevLauncherAction
+}
+
+typealias DevLauncherActionHandler = (DevLauncherAction) -> Unit

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

@@ -10,21 +10,17 @@ 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.Profile
 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.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.devlauncher.services.PackagerInfo
 import expo.modules.devmenu.compose.theme.Theme
 import kotlinx.serialization.Serializable
 
@@ -56,10 +52,17 @@ data class Tab(
   val screen: Any
 )
 
+data class DevLauncherState(
+  val appName: String = "BareExpo",
+  val runningPackagers: Set<PackagerInfo> = emptySet<PackagerInfo>(),
+  val onAction: DevLauncherActionHandler = {}
+)
+
 @Composable
-fun DevLauncherBottomTabsNavigator() {
+fun DevLauncherBottomTabsNavigator(
+  state: DevLauncherState
+) {
   val navController = rememberNavController()
-
   val bottomSheetState = rememberBottomSheetState()
 
   DefaultScaffold(bottomTab = {
@@ -75,22 +78,10 @@ fun DevLauncherBottomTabsNavigator() {
         ExitTransition.None
       }
     ) {
-      composable<Home> { DefaultScreenContainer { HomeScreen(HomeScreenState(appName = "BareExpo", onProfileClick = { bottomSheetState.jumpTo(Full) })) } }
+      composable<Home> { DefaultScreenContainer { HomeScreen(state, onProfileClick = { bottomSheetState.jumpTo(Full) }) } }
       composable<Settings> { DefaultScreenContainer { SettingsScreen() } }
     }
   }
 
-  BottomSheet(bottomSheetState) {
-    SignUp(onClose = {
-      bottomSheetState.targetDetent = Hidden
-    })
-  }
-}
-
-@Composable
-@Preview(showBackground = true)
-fun DevLauncherBottomTabsNavigatorPreview() {
-  AppTheme {
-    DevLauncherBottomTabsNavigator()
-  }
+  Profile(bottomSheetState)
 }

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

@@ -1,11 +1,43 @@
 package expo.modules.devlauncher.compose
 
+import android.util.Log
+import androidx.core.net.toUri
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.viewModelScope
+import expo.modules.devlauncher.DevLauncherController
 import expo.modules.devlauncher.services.PackagerService
+import kotlinx.coroutines.launch
 import okhttp3.OkHttpClient
 
-class DevLauncherViewModel : ViewModel() {
+class DevLauncherViewModel(
+  val devLauncherController: DevLauncherController
+) : ViewModel() {
   val httpClient = OkHttpClient()
+
   val packagerService = PackagerService(httpClient, viewModelScope)
+
+  fun onAction(action: DevLauncherAction) {
+    when (action) {
+      is DevLauncherAction.OpenApp ->
+        viewModelScope.launch {
+          try {
+            devLauncherController.loadApp(action.url.toUri(), mainActivity = null)
+          } catch (e: Exception) {
+            Log.e("DevLauncher", "Failed to open app: ${action.url}", e)
+          }
+        }
+    }
+  }
+
+  companion object {
+    class Factory(
+      private val devLauncherController: DevLauncherController
+    ) : ViewModelProvider.Factory {
+      override fun <T : ViewModel> create(modelClass: Class<T>): T {
+        @Suppress("UNCHECKED_CAST")
+        return DevLauncherViewModel(devLauncherController) as T
+      }
+    }
+  }
 }

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

@@ -0,0 +1,95 @@
+package expo.modules.devlauncher.compose
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import expo.modules.devlauncher.services.ApolloClientService
+import expo.modules.devlauncher.services.SessionService
+import expo.modules.devlauncher.services.inject
+import kotlinx.coroutines.Dispatchers
+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
+import kotlinx.coroutines.launch
+
+sealed interface ProfileState {
+  data class Account(
+    val name: String,
+    val avatar: String?
+  )
+
+  class LoggedIn(
+    val isLoading: Boolean = true,
+    val accounts: List<Account> = emptyList()
+  ) : ProfileState
+
+  object LoggedOut : ProfileState
+}
+
+class ProfileViewModel : ViewModel() {
+  sealed interface Action {
+    class LogIn(val sessionSecret: String) : Action
+    object SignOut : Action
+  }
+
+  val sessionSession = inject<SessionService>()
+  val apolloClientService = inject<ApolloClientService>()
+
+  private val _state = MutableStateFlow<ProfileState>(ProfileState.LoggedOut)
+
+  val state
+    get() = _state.asStateFlow()
+
+  init {
+    sessionSession.session.onEach { newSession ->
+      if (newSession != null) {
+        fetchMe()
+        _state.update {
+          ProfileState.LoggedIn()
+        }
+      } else {
+        _state.update { ProfileState.LoggedOut }
+      }
+    }
+      .launchIn(viewModelScope)
+  }
+
+  private fun fetchMe() {
+    viewModelScope.launch(Dispatchers.IO) {
+      val me = apolloClientService.fetchMe()
+      _state.update { prevState ->
+        // User logged out in the meantime, we can ignore the result
+        if (prevState is ProfileState.LoggedOut) {
+          return@update prevState
+        }
+
+        val accounts = me.data?.meUserActor?.accounts?.map {
+          ProfileState.Account(
+            name = it.name,
+            avatar = it.ownerUserActor?.profilePhoto
+          )
+        } ?: emptyList()
+
+        ProfileState.LoggedIn(
+          isLoading = false,
+          accounts = accounts
+        )
+      }
+    }
+  }
+
+  fun onAction(action: Action) {
+    when (action) {
+      is Action.LogIn -> {
+        sessionSession.setSession(
+          Session(action.sessionSecret)
+        )
+      }
+
+      Action.SignOut -> {
+        sessionSession.setSession(null)
+      }
+    }
+  }
+}

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),

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

@@ -19,8 +19,11 @@ import androidx.compose.ui.tooling.preview.Preview
 import com.composeunstyled.Button
 import com.composeunstyled.TextField
 import expo.modules.devlauncher.R
+import expo.modules.devlauncher.compose.DevLauncherAction
+import expo.modules.devlauncher.compose.DevLauncherState
 import expo.modules.devlauncher.compose.primitives.Accordion
 import expo.modules.devlauncher.compose.ui.AppHeader
+import expo.modules.devlauncher.compose.ui.RunningAppCard
 import expo.modules.devlauncher.compose.ui.ScreenHeaderContainer
 import expo.modules.devlauncher.compose.ui.SectionHeader
 import expo.modules.devmenu.compose.primitives.Divider
@@ -28,18 +31,12 @@ import expo.modules.devmenu.compose.primitives.RoundedSurface
 import expo.modules.devmenu.compose.primitives.Spacer
 import expo.modules.devmenu.compose.primitives.Text
 import expo.modules.devmenu.compose.theme.Theme
-import expo.modules.devmenu.compose.ui.MenuButton
-
-data class HomeScreenState(
-  val appName: String,
-  val onProfileClick: () -> Unit = {}
-)
 
 @Composable
-fun HomeScreen(state: HomeScreenState) {
+fun HomeScreen(state: DevLauncherState, onProfileClick: () -> Unit) {
   Column {
     ScreenHeaderContainer(modifier = Modifier.padding(Theme.spacing.medium)) {
-      AppHeader(state.appName, onProfileClick = state.onProfileClick)
+      AppHeader(state.appName, onProfileClick = onProfileClick)
     }
 
     Column(
@@ -72,10 +69,15 @@ fun HomeScreen(state: HomeScreenState) {
 
       RoundedSurface {
         Column {
-          MenuButton("http://10.0.2.2:8081")
-          Divider()
-          MenuButton("Fetch development")
-          Divider()
+          for (packager in state.runningPackagers) {
+            RunningAppCard(
+              appIp = packager.url
+            ) {
+              state.onAction(DevLauncherAction.OpenApp(packager.url))
+            }
+            Divider()
+          }
+
           Accordion("Enter URL", initialState = false) {
             val url = remember { mutableStateOf("") }
 
@@ -106,7 +108,9 @@ fun HomeScreen(state: HomeScreenState) {
 
               Spacer(Theme.spacing.tiny)
 
-              Button(onClick = {}, modifier = Modifier.fillMaxWidth()) {
+              Button(onClick = {
+                state.onAction(DevLauncherAction.OpenApp(url.value))
+              }, modifier = Modifier.fillMaxWidth()) {
                 Row(modifier = Modifier.padding(vertical = Theme.spacing.small)) {
                   Text("Connect")
                 }
@@ -126,5 +130,5 @@ fun HomeScreen(state: HomeScreenState) {
 @Preview(showBackground = true)
 @Composable
 fun HomeScreenPreview() {
-  HomeScreen(state = HomeScreenState("BareExpo"))
+  HomeScreen(state = DevLauncherState(), onProfileClick = {})
 }

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

@@ -0,0 +1,64 @@
+package expo.modules.devlauncher.compose.screens
+
+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 Profile(
+  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)
+            }
+          )
+        }
+
+        ProfileState.LoggedOut -> {
+          SignUp(
+            onLogIn = {
+              authLauncher.launch(AuthRequestType.LOGIN)
+            },
+            onSignUp = {
+              authLauncher.launch(AuthRequestType.SIGNUP)
+            }
+          )
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,37 @@
+package expo.modules.devlauncher.compose.ui
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.runtime.Composable
+import com.apollographql.apollo.api.label
+import expo.modules.devlauncher.compose.ProfileState
+import expo.modules.devmenu.compose.primitives.RoundedSurface
+import expo.modules.devmenu.compose.primitives.Spacer
+import expo.modules.devmenu.compose.theme.Theme
+import expo.modules.devmenu.compose.ui.MenuButton
+
+@Composable
+fun AccountSelector(
+  accounts: List<ProfileState.Account>,
+  onSignOut: () -> Unit = {}
+) {
+  Column {
+    RoundedSurface {
+      Column {
+        for (account in accounts) {
+          MenuButton(
+
+            label = account.name
+          )
+        }
+      }
+    }
+
+    Spacer(Theme.spacing.medium)
+
+    ActionButton(
+      "Log Out",
+      style = Theme.colors.button.tertiary,
+      onClick = onSignOut
+    )
+  }
+}