@javascriptcommon/react-native-carplay 2.3.11 → 2.4.1-beta.0

package/android/src/main/java/org/birkir/carplay/CarPlayModule.kt

@@ -0,0 +1,321 @@
+package org.birkir.carplay
+
+import android.content.Intent
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.activity.OnBackPressedCallback
+import androidx.car.app.AppManager
+import androidx.car.app.CarContext
+import androidx.car.app.CarToast
+import androidx.car.app.ScreenManager
+import androidx.car.app.SessionInfo
+import androidx.car.app.model.Alert
+import androidx.car.app.model.AlertCallback
+import androidx.car.app.model.CarText
+import androidx.car.app.model.Distance
+import androidx.car.app.model.TabTemplate
+import androidx.car.app.model.Template
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.debug.DevSettingsModule
+import org.birkir.carplay.parser.Parser
+import org.birkir.carplay.parser.TemplateParser
+import org.birkir.carplay.screens.CarScreen
+import org.birkir.carplay.screens.CarScreenContext
+import org.birkir.carplay.utils.EventEmitter
+import java.util.WeakHashMap
+
+
+@ReactModule(name = CarPlayModule.NAME)
+class CarPlayModule internal constructor(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private lateinit var carContext: CarContext
+  private lateinit var parser: Parser;
+
+  private var currentCarScreen: CarScreen? = null
+  private var screenManager: ScreenManager? = null
+  private val carScreens: WeakHashMap<String, CarScreen> = WeakHashMap()
+  private val carTemplates: WeakHashMap<String, ReadableMap> = WeakHashMap()
+  private val carScreenContexts: WeakHashMap<CarScreen, CarScreenContext> =
+    WeakHashMap()
+  private val handler: Handler = Handler(Looper.getMainLooper())
+
+
+  // Global event emitter (no templateId's)
+  private var eventEmitter: EventEmitter? = null
+
+  init {
+    reactContext.addLifecycleEventListener(object : LifecycleEventListener {
+      override fun onHostResume() {
+        eventEmitter = EventEmitter(reactContext)
+        reactContext.getNativeModule(DevSettingsModule::class.java)
+          ?.addMenuItem("Reload Android Auto")
+      }
+
+      override fun onHostPause() {}
+      override fun onHostDestroy() {}
+    })
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  fun setCarContext(carContext: CarContext, currentCarScreen: CarScreen) {
+    parser = Parser(carContext, CarScreenContext("", eventEmitter!!, carScreens));
+    this.carContext = carContext
+    this.currentCarScreen = currentCarScreen
+    screenManager = currentCarScreen.screenManager
+    carScreens["root"] = this.currentCarScreen
+    carContext.onBackPressedDispatcher.addCallback(object : OnBackPressedCallback(true) {
+      override fun handleOnBackPressed() {
+        eventEmitter?.backButtonPressed(screenManager?.top?.marker)
+      }
+    })
+    eventEmitter?.didConnect()
+  }
+
+  private fun parseTemplate(
+    config: ReadableMap,
+    carScreenContext: CarScreenContext
+  ): Template {
+    val factory = TemplateParser(carContext, carScreenContext)
+    return factory.parse(config)
+  }
+
+  @ReactMethod
+  fun checkForConnection() {
+    eventEmitter?.didConnect()
+  }
+
+  @ReactMethod
+  fun createTemplate(templateId: String, config: ReadableMap, callback: Callback?) {
+    handler.post {
+      Log.d(TAG, "Creating template $templateId")
+
+      // Store the template
+      carTemplates[templateId] = config;
+
+      try {
+        createScreen(templateId);
+        callback?.invoke()
+      } catch (err: IllegalArgumentException) {
+        val args = Arguments.createMap()
+        args.putString("error", "Failed to parse template '$templateId': ${err.message}")
+        callback?.invoke(args)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun updateTemplate(templateId: String, config: ReadableMap) {
+    handler.post {
+      carTemplates[templateId] = config;
+      val screen = carScreens[templateId]
+      if (screen != null) {
+        val carScreenContext = carScreenContexts[screen];
+        if (carScreenContext != null) {
+          val template = parseTemplate(config, carScreenContext);
+          screen.setTemplate(template, templateId, config);
+          screen.invalidate()
+          // If this is a tab template, we need to update the main tab screen as well
+          if (template is TabTemplate) {
+            carScreens[carScreenContext.screenMarker]?.setTemplate(template, carScreenContext.screenMarker, config)
+            carScreens[carScreenContext.screenMarker]?.invalidate()
+          }
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun setRootTemplate(templateId: String, animated: Boolean?) {
+    Log.d(TAG, "set Root Template for $templateId")
+    handler.post {
+      val screen = getScreen(templateId)
+      if (screen != null) {
+        currentCarScreen = screen
+        screenManager?.popToRoot()
+        screenManager?.push(screen)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun pushTemplate(templateId: String, animated: Boolean?) {
+    handler.post {
+      val screen = getScreen(templateId)
+      if (screen != null) {
+        currentCarScreen = screen;
+        screenManager?.push(screen)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun popToTemplate(templateId: String, animated: Boolean?) {
+    handler.post {
+      screenManager?.popTo(templateId);
+    }
+  }
+
+  @ReactMethod
+  fun popTemplate(animated: Boolean?) {
+    handler.post {
+      screenManager!!.pop()
+      removeScreen(currentCarScreen)
+      currentCarScreen = screenManager!!.top as CarScreen
+      currentCarScreen?.invalidate()
+    }
+  }
+
+  @ReactMethod
+  fun presentTemplate(templateId: String?, animated: Boolean?) {
+    // void
+  }
+
+  @ReactMethod
+  fun dismissTemplate(templateId: String?, animated: Boolean?) {
+    // void
+  }
+
+  // pragma: Android Auto only stuff
+
+  @ReactMethod
+  fun toast(text: String, duration: Int) {
+    if (!::carContext.isInitialized) {
+      Log.e(TAG, "carContext is not initialized. Cannot show toast.")
+      return
+    }
+    CarToast.makeText(carContext, text, duration).show()
+  }
+
+  @ReactMethod
+  fun alert(props: ReadableMap) {
+    handler.post {
+      val id = props.getInt("id");
+      val title = parser.parseCarText(props.getString("title")!!, props);
+      val duration = props.getInt("duration").toLong();
+      val alert = Alert.Builder(id, title, duration).apply {
+        setCallback(object : AlertCallback {
+          override fun onCancel(reason: Int) {
+            val reasonString = when (reason) {
+              AlertCallback.REASON_TIMEOUT -> "timeout"
+              AlertCallback.REASON_USER_ACTION -> "userAction"
+              AlertCallback.REASON_NOT_SUPPORTED -> "notSupported"
+              else -> "unknown"
+            }
+            eventEmitter?.alertActionPressed("cancel", reasonString);
+          }
+          override fun onDismiss() {
+            eventEmitter?.alertActionPressed("dismiss" );
+          }
+        })
+        props.getString("subtitle")?.let { setSubtitle(parser.parseCarText(it, props)) }
+        props.getMap("icon")?.let { setIcon(parser.parseCarIcon(it)) }
+        props.getArray("actions")?.let {
+          for (i in 0 until it.size()) {
+            addAction(parser.parseAction(it.getMap(i)));
+          }
+        }
+      }.build()
+      carContext.getCarService(AppManager::class.java).showAlert(alert)
+    }
+  }
+
+  @ReactMethod
+  fun dismissAlert(alertId: Int) {
+    carContext.getCarService(AppManager::class.java).dismissAlert(alertId)
+  }
+
+  @ReactMethod
+  fun invalidate(templateId: String) {
+    handler.post {
+      val screen = getScreen(templateId)
+      if (screen === screenManager!!.top) {
+        Log.d(TAG, "Invalidated screen $templateId")
+        screen.invalidate()
+      }
+    }
+  }
+
+  @ReactMethod
+  fun reload() {
+    val intent = Intent("org.birkir.carplay.APP_RELOAD")
+    reactContext.sendBroadcast(intent)
+  }
+
+  @ReactMethod
+  fun getHostInfo(promise: Promise) {
+    return promise.resolve(Arguments.createMap().apply {
+      carContext.hostInfo?.packageName?.let { putString("packageName", it) }
+      carContext.hostInfo?.uid?.let { putInt("uid", it) }
+    });
+  }
+
+  // Others
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    Log.d(TAG, "listener added $eventName")
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    Log.d(TAG, "remove listeners $count")
+  }
+
+  private fun createCarScreenContext(screen: CarScreen): CarScreenContext {
+    val templateId = screen.marker!!
+    return CarScreenContext(templateId, EventEmitter(reactContext, templateId), carScreens)
+  }
+
+  private fun createScreen(templateId: String): CarScreen? {
+    if (!::carContext.isInitialized) {
+      Log.e(TAG, "carContext is not initialized.")
+      return null
+    }
+    val config = carTemplates[templateId];
+    if (config != null) {
+      val screen = CarScreen(carContext)
+      screen.marker = templateId;
+
+      // context
+      carScreenContexts.remove(screen)
+      val carScreenContext = createCarScreenContext(screen)
+      carScreenContexts[screen] = carScreenContext
+
+      val template = parseTemplate(config, carScreenContext);
+      screen.setTemplate(template, templateId, config)
+      carScreens[templateId] = screen;
+
+      return screen;
+    }
+    return null;
+  }
+
+  private fun getScreen(name: String): CarScreen? {
+    return carScreens[name] ?: createScreen(name);
+  }
+
+  private fun removeScreen(screen: CarScreen?) {
+    val params = WritableNativeMap()
+    params.putString("screen", screen!!.marker)
+    carScreens.values.remove(screen)
+  }
+
+  companion object {
+    const val NAME = "RNCarPlay"
+    const val TAG = "CarPlay"
+  }
+}

package/android/src/main/java/org/birkir/carplay/CarPlayPackage.kt

@@ -0,0 +1,18 @@
+package org.birkir.carplay
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class CarPlayPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    val modules: MutableList<NativeModule> = ArrayList()
+    modules.add(CarPlayModule(reactContext))
+    return modules
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/java/org/birkir/carplay/CarPlayService.kt

@@ -0,0 +1,35 @@
+package org.birkir.carplay
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.util.Log
+import androidx.car.app.CarAppService
+import androidx.car.app.Session
+import androidx.car.app.SessionInfo
+import androidx.car.app.validation.HostValidator
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactInstanceManager
+
+class CarPlayService : CarAppService() {
+  private lateinit var reactInstanceManager: ReactInstanceManager
+  override fun onCreate() {
+    super.onCreate()
+    reactInstanceManager =
+      (application as ReactApplication).reactNativeHost.reactInstanceManager
+  }
+
+  override fun createHostValidator(): HostValidator {
+    return HostValidator.ALLOW_ALL_HOSTS_VALIDATOR
+  }
+
+  override fun onCreateSession(sessionInfo: SessionInfo): Session {
+    Log.d(TAG, "onCreateSession: sessionId = ${sessionInfo.sessionId}, display = ${sessionInfo.displayType}")
+    return CarPlaySession(reactInstanceManager)
+  }
+
+  companion object {
+    var TAG = "CarPlayService"
+  }
+}

package/android/src/main/java/org/birkir/carplay/CarPlaySession.kt

@@ -0,0 +1,126 @@
+package org.birkir.carplay
+
+import android.annotation.SuppressLint
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.res.Configuration
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+import androidx.car.app.CarContext.SCREEN_SERVICE
+import androidx.car.app.Screen
+import androidx.car.app.ScreenManager
+import androidx.car.app.Session
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.ReactInstanceManager
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.modules.appregistry.AppRegistry
+import com.facebook.react.modules.core.TimingModule
+import com.facebook.react.modules.debug.DevSettingsModule
+import org.birkir.carplay.screens.CarScreen
+
+
+class CarPlaySession(private val reactInstanceManager: ReactInstanceManager) : Session(), DefaultLifecycleObserver {
+  private lateinit var screen: CarScreen
+
+  @SuppressLint("UnspecifiedRegisterReceiverFlag")
+  override fun onCreateScreen(intent: Intent): Screen {
+    Log.d(TAG, "On create screen " + intent.action + " - " + intent.dataString)
+    val lifecycle = lifecycle
+    lifecycle.addObserver(this)
+    screen = CarScreen(carContext)
+    screen.marker = "root"
+
+    // Handle reload events
+    if (Build.VERSION.SDK_INT >= 34 && carContext.getApplicationInfo().targetSdkVersion >= 34) {
+    carContext.registerReceiver(object : BroadcastReceiver() {
+      override fun onReceive(context: Context, intent: Intent) {
+        if ("org.birkir.carplay.APP_RELOAD" == intent.action) {
+          invokeStartTask(reactInstanceManager.currentReactContext!!);
+        }
+      }
+    }, IntentFilter("org.birkir.carplay.APP_RELOAD"), Context.RECEIVER_EXPORTED)
+    }else{
+           carContext.registerReceiver(object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                 if ("org.birkir.carplay.APP_RELOAD" == intent.action) {
+                     invokeStartTask(reactInstanceManager.currentReactContext!!);
+                   }
+               }
+      }, IntentFilter("org.birkir.carplay.APP_RELOAD"))
+    }
+
+    // Run JS
+    runJsApplication()
+    return screen
+  }
+
+  private fun runJsApplication() {
+    val reactContext = reactInstanceManager.currentReactContext
+    if (reactContext == null) {
+      reactInstanceManager.addReactInstanceEventListener(
+        object : ReactInstanceManager.ReactInstanceEventListener {
+          override fun onReactContextInitialized(reactContext: ReactContext) {
+            invokeStartTask(reactContext)
+            reactInstanceManager.removeReactInstanceEventListener(this)
+          }
+        })
+      reactInstanceManager.createReactContextInBackground()
+    } else {
+      invokeStartTask(reactContext)
+    }
+  }
+
+  private fun invokeStartTask(reactContext: ReactContext) {
+    try {
+      val catalystInstance = reactContext.catalystInstance
+      val jsAppModuleName = "AndroidAuto"
+      val appParams = WritableNativeMap()
+      appParams.putDouble("rootTag", 1.0)
+      val appProperties = Bundle.EMPTY
+      if (appProperties != null) {
+        appParams.putMap("initialProps", Arguments.fromBundle(appProperties))
+      }
+
+      catalystInstance.getJSModule(AppRegistry::class.java)
+        .runApplication(jsAppModuleName, appParams)
+
+      val timingModule = reactContext.getNativeModule(
+        TimingModule::class.java
+      )
+      val carModule = reactInstanceManager
+        .currentReactContext?.getNativeModule(CarPlayModule::class.java)
+      carModule!!.setCarContext(carContext, screen)
+      timingModule!!.onHostResume()
+
+    } catch (e: Exception) {
+      e.printStackTrace()
+    }
+  }
+
+  override fun onDestroy(owner: LifecycleOwner) {
+    Log.i(TAG, "onDestroy")
+    val context = carContext
+    // stop services here, if any
+  }
+
+  override fun onNewIntent(intent: Intent) {
+    // handle intents
+    Log.d(TAG, "CarPlaySession.onNewIntent")
+  }
+
+  override fun onCarConfigurationChanged(configuration: Configuration) {
+    // we should report this over the bridge
+    Log.d(TAG, "CarPlaySession.onCarConfigurationChanged")
+  }
+
+  companion object {
+    const val TAG = "CarPlaySession"
+  }
+}
+

package/android/src/main/java/org/birkir/carplay/parser/Ext.kt

@@ -0,0 +1,11 @@
+package org.birkir.carplay.parser
+
+import com.facebook.react.bridge.ReadableMap
+
+fun ReadableMap.isLoading(): Boolean {
+  return try {
+    getBoolean("loading")
+  } catch (e: Exception) {
+    return false
+  }
+}

package/android/src/main/java/org/birkir/carplay/parser/Parser.kt

@@ -0,0 +1,18 @@
+package org.birkir.carplay.parser
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.Pane
+import androidx.car.app.model.PaneTemplate
+import androidx.car.app.model.Template
+import com.facebook.react.bridge.ReadableMap
+import org.birkir.carplay.screens.CarScreenContext
+
+class Parser(
+  context: CarContext,
+  carScreenContext: CarScreenContext
+) : RCTTemplate(context, carScreenContext) {
+  override fun parse(props: ReadableMap): Template {
+    return PaneTemplate.Builder(Pane.Builder().build()).build()
+  }
+
+}

package/android/src/main/java/org/birkir/carplay/parser/RCTGridTemplate.kt

@@ -0,0 +1,28 @@
+package org.birkir.carplay.parser
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.GridTemplate
+import com.facebook.react.bridge.ReadableMap
+import org.birkir.carplay.screens.CarScreenContext
+
+class RCTGridTemplate(
+  context: CarContext,
+  carScreenContext: CarScreenContext
+) : RCTTemplate(context, carScreenContext) {
+
+  override fun parse(props: ReadableMap): GridTemplate {
+    return GridTemplate.Builder().apply {
+      setLoading(props.isLoading())
+      props.getString("title")?.let { setTitle(it) }
+      props.getMap("headerAction")?.let { setHeaderAction(parseAction(it)) }
+      props.getArray("actions")?.let { setActionStrip(parseActionStrip(it)) }
+      this.setSingleList(
+        parseItemList(props.getArray("buttons"), "grid")
+      )
+    }.build()
+  }
+
+  companion object {
+    const val TAG = "RCTGridTemplate"
+  }
+}

package/android/src/main/java/org/birkir/carplay/parser/RCTListTemplate.kt

@@ -0,0 +1,64 @@
+package org.birkir.carplay.parser
+
+import androidx.car.app.CarContext
+import androidx.car.app.model.ListTemplate
+import androidx.car.app.model.SectionedItemList
+import com.facebook.react.bridge.ReadableMap
+import org.birkir.carplay.screens.CarScreenContext
+
+class RCTListTemplate(
+  context: CarContext,
+  screenContext: CarScreenContext
+) : RCTTemplate(context, screenContext) {
+
+  override fun parse(props: ReadableMap): ListTemplate {
+    return ListTemplate.Builder().apply {
+      props.getString("title")?.let { setTitle(it) }
+
+      // Actions
+      props.getArray("actions")?.let {
+        setActionStrip(
+          parseActionStrip(it)
+        )
+      }
+
+      // Header Action
+      props.getMap("headerAction")?.let {
+        setHeaderAction(
+          parseAction(it)
+        )
+      }
+
+      // Loading
+      setLoading(props.isLoading())
+
+      // Sections
+      props.getArray("sections")?.let {
+        for (i in 0 until it.size()) {
+          val section = it.getMap(i)
+          val header = section.getString("header")
+          addSectionedList(
+            SectionedItemList.create(
+              parseItemList(section.getArray("items")),
+              header ?: "Missing title"
+            )
+          )
+        }
+      }
+
+      // Single List
+      // @todo handle when sections and items are defined at once.
+      props.getArray("items")?.let {
+        setSingleList(
+          parseItemList(it)
+        )
+      }
+
+    }.build()
+  }
+
+
+  companion object {
+    const val TAG = "RCTListTemplate"
+  }
+}