expo-modules-core 0.4.6 → 0.6.0

package/android/src/main/java/expo/modules/kotlin/AppContext.kt

@@ -0,0 +1,166 @@
+package expo.modules.kotlin
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.ReactApplicationContext
+import expo.modules.core.interfaces.ActivityProvider
+import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.interfaces.barcodescanner.BarCodeScannerInterface
+import expo.modules.interfaces.camera.CameraViewInterface
+import expo.modules.interfaces.constants.ConstantsInterface
+import expo.modules.interfaces.filesystem.FilePermissionModuleInterface
+import expo.modules.interfaces.font.FontManagerInterface
+import expo.modules.interfaces.imageloader.ImageLoaderInterface
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.interfaces.sensors.SensorServiceInterface
+import expo.modules.interfaces.taskManager.TaskManagerInterface
+import expo.modules.kotlin.events.EventName
+import expo.modules.kotlin.events.KEventEmitterWrapper
+import expo.modules.kotlin.events.OnActivityResultPayload
+import expo.modules.kotlin.modules.Module
+import java.lang.ref.WeakReference
+
+class AppContext(
+  modulesProvider: ModulesProvider,
+  val legacyModuleRegistry: expo.modules.core.ModuleRegistry,
+  private val reactContextHolder: WeakReference<ReactApplicationContext>
+) {
+  val registry = ModuleRegistry(WeakReference(this)).register(modulesProvider)
+  private val reactLifecycleDelegate = ReactLifecycleDelegate(this)
+
+  init {
+    requireNotNull(reactContextHolder.get()) {
+      "The app context should be created with valid react context."
+    }.apply {
+      addLifecycleEventListener(reactLifecycleDelegate)
+      addActivityEventListener(reactLifecycleDelegate)
+    }
+  }
+
+  /**
+   * Returns a legacy module implementing given interface.
+   */
+  inline fun <reified Module> legacyModule(): Module? {
+    return try {
+      legacyModuleRegistry.getModule(Module::class.java)
+    } catch (_: Exception) {
+      null
+    }
+  }
+
+  /**
+   * Provides access to app's constants from the legacy module registry.
+   */
+  val constants: ConstantsInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the file system manager from the legacy module registry.
+   */
+  val filePermission: FilePermissionModuleInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the permissions manager from the legacy module registry
+   */
+  val permissions: Permissions?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the image loader from the legacy module registry
+   */
+  val imageLoader: ImageLoaderInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the bar code scanner manager from the legacy module registry
+   */
+  val barcodeScanner: BarCodeScannerInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the camera view manager from the legacy module registry
+   */
+  val camera: CameraViewInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the font manager from the legacy module registry
+   */
+  val font: FontManagerInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the sensor manager from the legacy module registry
+   */
+  val sensor: SensorServiceInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the task manager from the legacy module registry
+   */
+  val taskManager: TaskManagerInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the activity provider from the legacy module registry
+   */
+  val activityProvider: ActivityProvider?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the react application context
+   */
+  val reactContext: Context?
+    get() = reactContextHolder.get()
+
+  /**
+   * Provides access to the event emitter
+   */
+  fun eventEmitter(module: Module): EventEmitter? {
+    val legacyEventEmitter = legacyModule<EventEmitter>() ?: return null
+    return KEventEmitterWrapper(
+      requireNotNull(registry.getModuleHolder(module)) {
+        "Cannot create an event emitter for the module that isn't present in the module registry."
+      },
+      legacyEventEmitter
+    )
+  }
+
+  fun onDestroy() {
+    reactContextHolder.get()?.removeLifecycleEventListener(reactLifecycleDelegate)
+    registry.post(EventName.MODULE_DESTROY)
+  }
+
+  fun onHostResume() {
+    registry.post(EventName.ACTIVITY_ENTERS_FOREGROUND)
+  }
+
+  fun onHostPause() {
+    registry.post(EventName.ACTIVITY_ENTERS_BACKGROUND)
+  }
+
+  fun onHostDestroy() {
+    registry.post(EventName.ACTIVITY_DESTROYS)
+  }
+
+  fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    registry.post(
+      EventName.ON_ACTIVITY_RESULT,
+      activity,
+      OnActivityResultPayload(
+        requestCode,
+        resultCode,
+        data
+      )
+    )
+  }
+
+  fun onNewIntent(intent: Intent?) {
+    registry.post(
+      EventName.ON_NEW_INTENT,
+      intent
+    )
+  }
+}

package/android/src/main/java/expo/modules/kotlin/DynamicExtenstions.kt

@@ -0,0 +1,9 @@
+package expo.modules.kotlin
+
+import com.facebook.react.bridge.Dynamic
+
+inline fun <T> Dynamic.recycle(block: Dynamic.() -> T): T {
+  val result = block(this)
+  this.recycle()
+  return result
+}

package/android/src/main/java/expo/modules/kotlin/ExpoModulesHelper.kt

@@ -0,0 +1,18 @@
+package expo.modules.kotlin
+
+import android.util.Log
+
+class ExpoModulesHelper {
+  companion object {
+    @Suppress("unchecked_cast")
+    val modulesProvider by lazy {
+      try {
+        val expoModules = Class.forName("expo.modules.ExpoModulesPackageList")
+        expoModules.newInstance() as ModulesProvider
+      } catch (e: Exception) {
+        Log.e("ExpoModulesHelper", "Couldn't get expo modules list.", e)
+        null
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/KPromiseWrapper.kt

@@ -0,0 +1,24 @@
+package expo.modules.kotlin
+
+import android.os.Bundle
+import com.facebook.react.bridge.Arguments
+
+class KPromiseWrapper(
+  private val bridgePromise: com.facebook.react.bridge.Promise
+) : Promise {
+
+  override fun resolve(value: Any?) {
+    bridgePromise.resolve(
+      when (value) {
+        is Unit -> null
+        is Bundle -> Arguments.fromBundle(value as Bundle?)
+        is List<*> -> Arguments.fromList(value as List<*>?)
+        else -> value
+      }
+    )
+  }
+
+  override fun reject(code: String, message: String?, cause: Throwable?) {
+    bridgePromise.reject(code, message, cause)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/KotlinInteropModuleRegistry.kt

@@ -0,0 +1,98 @@
+package expo.modules.kotlin
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.uimanager.ViewManager
+import expo.modules.kotlin.views.GroupViewManagerWrapper
+import expo.modules.kotlin.views.SimpleViewManagerWrapper
+import expo.modules.kotlin.views.ViewManagerWrapperDelegate
+import expo.modules.kotlin.views.ViewWrapperDelegateHolder
+import java.lang.ref.WeakReference
+
+private typealias ModuleName = String
+private typealias ModuleConstants = Map<String, Any?>
+private typealias ModuleMethodInfo = Map<String, Any?>
+
+class KotlinInteropModuleRegistry(
+  modulesProvider: ModulesProvider,
+  legacyModuleRegistry: expo.modules.core.ModuleRegistry,
+  reactContext: WeakReference<ReactApplicationContext>
+) {
+  private val appContext = AppContext(modulesProvider, legacyModuleRegistry, reactContext)
+
+  private val registry: ModuleRegistry
+    get() = appContext.registry
+
+  fun hasModule(name: String): Boolean = registry.hasModule(name)
+
+  fun callMethod(moduleName: String, method: String, arguments: ReadableArray, promise: Promise) {
+    registry
+      .getModuleHolder(moduleName)
+      ?.call(method, arguments, promise)
+  }
+
+  fun exportedModulesConstants(): Map<ModuleName, ModuleConstants> {
+    return registry
+      .map { holder ->
+        holder.name to holder.definition.constantsProvider()
+      }
+      .toMap()
+  }
+
+  fun exportMethods(exportKey: (String, List<ModuleMethodInfo>) -> Unit = { _, _ -> }): Map<ModuleName, List<ModuleMethodInfo>> {
+    return registry
+      .map { holder ->
+        val methodsInfo = holder.definition.methods.map { (name, method) ->
+          mapOf(
+            "name" to name,
+            "argumentsCount" to method.argsCount
+          )
+        }
+        exportKey(holder.name, methodsInfo)
+        holder.name to methodsInfo
+      }
+      .toMap()
+  }
+
+  fun exportViewManagers(): List<ViewManager<*, *>> {
+    return registry
+      .filter { it.definition.viewManagerDefinition != null }
+      .map {
+        val wrapperDelegate = ViewManagerWrapperDelegate(it)
+        when (it.definition.viewManagerDefinition!!.getViewManagerType()) {
+          expo.modules.core.ViewManager.ViewManagerType.SIMPLE -> SimpleViewManagerWrapper(wrapperDelegate)
+          expo.modules.core.ViewManager.ViewManagerType.GROUP -> GroupViewManagerWrapper(wrapperDelegate)
+        }
+      }
+  }
+
+  fun extractViewManagersDelegateHolders(viewManagers: List<ViewManager<*, *>>): List<ViewWrapperDelegateHolder> =
+    viewManagers.filterIsInstance<ViewWrapperDelegateHolder>()
+
+  /**
+   * Since React Native v0.55, {@link com.facebook.react.ReactPackage#createViewManagers(ReactApplicationContext)}
+   * gets called only once per lifetime of {@link com.facebook.react.ReactInstanceManager}.
+   * However, in our new architecture, users can make a bind between ViewManager and module
+   * (for instance, they can use `this` in prop definition). This will lead to bugs, cause
+   * the instance that was bound with the prop method won't be the same as the instance returned by module registry.
+   * To fix that we need to update all modules holder in exported view managers.
+   */
+  fun updateModuleHoldersInViewManagers(viewWrapperHolders: List<ViewWrapperDelegateHolder>) {
+    viewWrapperHolders
+      .map { it.viewWrapperDelegate }
+      .forEach { holderWrapper ->
+        holderWrapper.moduleHolder = requireNotNull(registry.getModuleHolder(holderWrapper.moduleHolder.name)) {
+          "Cannot update the module holder for ${holderWrapper.moduleHolder.name}."
+        }
+      }
+  }
+
+  fun exportedViewManagersNames(): List<String> =
+    registry
+      .filter { it.definition.viewManagerDefinition != null }
+      .map { it.definition.name }
+
+  fun onDestroy() {
+    appContext.onDestroy()
+  }
+}

package/android/src/main/java/expo/modules/kotlin/ModuleHolder.kt

@@ -0,0 +1,41 @@
+package expo.modules.kotlin
+
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.core.utilities.ifNull
+import expo.modules.kotlin.events.BasicEventListener
+import expo.modules.kotlin.events.EventListenerWithPayload
+import expo.modules.kotlin.events.EventListenerWithSenderAndPayload
+import expo.modules.kotlin.events.EventName
+import expo.modules.kotlin.exception.MethodNotFoundException
+import expo.modules.kotlin.modules.Module
+
+class ModuleHolder(val module: Module) {
+  val definition = module.definition()
+  val name get() = definition.name
+
+  fun call(methodName: String, args: ReadableArray, promise: Promise) {
+    val method = definition.methods[methodName].ifNull {
+      promise.reject(MethodNotFoundException(methodName, definition.name))
+      return
+    }
+
+    method.call(args, promise)
+  }
+
+  fun post(eventName: EventName) {
+    val listener = definition.eventListeners[eventName] ?: return
+    (listener as? BasicEventListener)?.call()
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  fun <Payload> post(eventName: EventName, payload: Payload) {
+    val listener = definition.eventListeners[eventName] ?: return
+    (listener as? EventListenerWithPayload<Payload>)?.call(payload)
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  fun <Sender, Payload> post(eventName: EventName, sender: Sender, payload: Payload) {
+    val listener = definition.eventListeners[eventName] ?: return
+    (listener as? EventListenerWithSenderAndPayload<Sender, Payload>)?.call(sender, payload)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/ModuleRegistry.kt

@@ -0,0 +1,56 @@
+package expo.modules.kotlin
+
+import expo.modules.kotlin.events.EventName
+import expo.modules.kotlin.modules.Module
+import java.lang.ref.WeakReference
+
+class ModuleRegistry(
+  private val appContext: WeakReference<AppContext>
+) : Iterable<ModuleHolder> {
+  private val registry = mutableMapOf<String, ModuleHolder>()
+
+  fun register(module: Module) {
+    val holder = ModuleHolder(module)
+    module._appContext = requireNotNull(appContext.get()) { "Cannot create a module for invalid app context." }
+    holder.post(EventName.MODULE_CREATE)
+    registry[holder.name] = holder
+  }
+
+  fun register(provider: ModulesProvider) = apply {
+    provider.getModulesList().forEach { type ->
+      val module = type.newInstance()
+      register(module)
+    }
+  }
+
+  fun hasModule(name: String): Boolean = registry.containsKey(name)
+
+  fun getModule(name: String): Module? = registry[name]?.module
+
+  fun getModuleHolder(name: String): ModuleHolder? = registry[name]
+
+  fun getModuleHolder(module: Module): ModuleHolder? =
+    registry.values.find { it.module === module }
+
+  fun post(eventName: EventName) {
+    forEach {
+      it.post(eventName)
+    }
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  fun <Sender> post(eventName: EventName, sender: Sender) {
+    forEach {
+      it.post(eventName, sender)
+    }
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  fun <Sender, Payload> post(eventName: EventName, sender: Sender, payload: Payload) {
+    forEach {
+      it.post(eventName, sender, payload)
+    }
+  }
+
+  override fun iterator(): Iterator<ModuleHolder> = registry.values.iterator()
+}

package/android/src/main/java/expo/modules/kotlin/ModulesProvider.kt

@@ -0,0 +1,7 @@
+package expo.modules.kotlin
+
+import expo.modules.kotlin.modules.Module
+
+interface ModulesProvider {
+  fun getModulesList(): List<Class<out Module>>
+}

package/android/src/main/java/expo/modules/kotlin/Promise.kt

@@ -0,0 +1,13 @@
+package expo.modules.kotlin
+
+import expo.modules.kotlin.exception.CodedException
+
+interface Promise {
+  fun resolve(value: Any?)
+
+  fun reject(code: String, message: String?, cause: Throwable?)
+
+  fun reject(exception: CodedException) {
+    reject(exception.code, exception.message, exception.cause)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/ReactLifecycleDelegate.kt

@@ -0,0 +1,39 @@
+package expo.modules.kotlin
+
+import android.app.Activity
+import android.content.Intent
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.LifecycleEventListener
+import java.lang.ref.WeakReference
+
+/**
+ * We had to extract this from AppContext, because otherwise, we can't access AppContext
+ * in a package that doesn't depend on the React Native directly.
+ * Due to:
+ * Cannot access 'com.facebook.react.bridge.LifecycleEventListener'
+ * which is a supertype of 'expo.modules.kotlin.AppContext'.
+ * Check your module classpath for missing or conflicting dependencies
+ */
+class ReactLifecycleDelegate(appContext: AppContext) : LifecycleEventListener, ActivityEventListener {
+  private val appContextHolder = WeakReference(appContext)
+
+  override fun onHostResume() {
+    appContextHolder.get()?.onHostResume()
+  }
+
+  override fun onHostPause() {
+    appContextHolder.get()?.onHostPause()
+  }
+
+  override fun onHostDestroy() {
+    appContextHolder.get()?.onHostDestroy()
+  }
+
+  override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    appContextHolder.get()?.onActivityResult(activity, requestCode, resultCode, data)
+  }
+
+  override fun onNewIntent(intent: Intent?) {
+    appContextHolder.get()?.onNewIntent(intent)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/ReadableArrayIterator.kt

@@ -0,0 +1,14 @@
+package expo.modules.kotlin
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
+
+class ReadableArrayIterator(private val array: ReadableArray) : Iterator<Dynamic> {
+  var current = 0
+
+  override fun hasNext(): Boolean = current < array.size()
+
+  override fun next(): Dynamic = array.getDynamic(current++)
+}
+
+fun ReadableArray.iterator(): ReadableArrayIterator = ReadableArrayIterator(this)

package/android/src/main/java/expo/modules/kotlin/ReadableTypeExtensions.kt

@@ -0,0 +1,18 @@
+package expo.modules.kotlin
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import kotlin.reflect.KType
+import kotlin.reflect.full.createType
+
+fun ReadableType.toKType(): KType {
+  return when (this) {
+    ReadableType.Null -> Any::class.createType(nullable = true)
+    ReadableType.Boolean -> Boolean::class.createType()
+    ReadableType.Number -> Number::class.createType()
+    ReadableType.String -> String::class.createType()
+    ReadableType.Map -> ReadableMap::class.createType()
+    ReadableType.Array -> ReadableArray::class.createType()
+  }
+}

package/android/src/main/java/expo/modules/kotlin/allocators/ObjectConstructor.kt

@@ -0,0 +1,5 @@
+package expo.modules.kotlin.allocators
+
+fun interface ObjectConstructor<T> {
+  fun construct(): T
+}

package/android/src/main/java/expo/modules/kotlin/allocators/ObjectConstructorFactory.kt

@@ -0,0 +1,31 @@
+package expo.modules.kotlin.allocators
+
+/**
+ * This class was created based on https://github.com/google/gson/blob/master/gson/src/main/java/com/google/gson/internal/ConstructorConstructor.java.
+ */
+class ObjectConstructorFactory {
+  fun <T> get(clazz: Class<T>): ObjectConstructor<T> =
+    tryToUseDefaultConstructor(clazz) ?: useUnsafeAllocator(clazz)
+
+  private fun <T> tryToUseDefaultConstructor(clazz: Class<T>): ObjectConstructor<T>? {
+    return try {
+      val ctor = clazz.getDeclaredConstructor()
+      if (!ctor.isAccessible) {
+        ctor.isAccessible = true
+      }
+
+      ObjectConstructor {
+        ctor.newInstance() as T
+      }
+    } catch (e: NoSuchMethodException) {
+      null
+    }
+  }
+
+  private fun <T> useUnsafeAllocator(clazz: Class<T>): ObjectConstructor<T> {
+    val allocator = UnsafeAllocator.createAllocator(clazz)
+    return ObjectConstructor {
+      allocator.newInstance()
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/allocators/UnsafeAllocator.kt

@@ -0,0 +1,49 @@
+package expo.modules.kotlin.allocators
+
+import android.annotation.SuppressLint
+import java.io.ObjectStreamClass
+import kotlin.jvm.Throws
+
+/**
+ * Base on https://github.com/google/gson/blob/master/gson/src/main/java/com/google/gson/internal/UnsafeAllocator.java.
+ */
+fun interface UnsafeAllocator<T> {
+  @Throws(Exception::class)
+  fun newInstance(): T
+
+  companion object {
+    @SuppressLint("DiscouragedPrivateApi")
+    @Suppress("UNCHECKED_CAST")
+    fun <T> createAllocator(clazz: Class<T>): UnsafeAllocator<T> {
+      // try DalvikVM
+      try {
+        val getConstructorId = ObjectStreamClass::class.java.getDeclaredMethod("getConstructorId", Class::class.java)
+        getConstructorId.isAccessible = true
+        val constructorId = getConstructorId.invoke(null, Object::class.java) as Int
+        val newInstance = ObjectStreamClass::class.java.getDeclaredMethod("newInstance", Class::class.java, Int::class.java)
+        newInstance.isAccessible = true
+        return UnsafeAllocator {
+          newInstance.invoke(null, clazz, constructorId) as T
+        }
+      } catch (_: Throwable) {
+      }
+
+      // try JVM (for unit tests)
+      try {
+        val unsafeClass = Class.forName("sun.misc.Unsafe")
+        val theUnsafe = unsafeClass.getDeclaredField("theUnsafe")
+        theUnsafe.isAccessible = true
+        val unsafeObj = theUnsafe.get(null)
+        val allocateInstance = unsafeClass.getMethod("allocateInstance", Class::class.java)
+        return UnsafeAllocator {
+          allocateInstance.invoke(unsafeObj, clazz) as T
+        }
+      } catch (_: Throwable) {
+      }
+
+      return UnsafeAllocator {
+        throw IllegalArgumentException("Cannot allocate $clazz")
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/events/EventListener.kt

@@ -0,0 +1,39 @@
+package expo.modules.kotlin.events
+
+sealed class EventListener(val eventName: EventName)
+
+/**
+ * Listener for events without sender and payload.
+ */
+class BasicEventListener(
+  eventName: EventName,
+  val body: () -> Unit
+) : EventListener(eventName) {
+  fun call() {
+    body()
+  }
+}
+
+/**
+ * Listener for events with payload.
+ */
+class EventListenerWithPayload<Payload>(
+  eventName: EventName,
+  val body: (Payload) -> Unit
+) : EventListener(eventName) {
+  fun call(sender: Payload) {
+    body(sender)
+  }
+}
+
+/**
+ * Listener for events that specify sender and payload.
+ */
+class EventListenerWithSenderAndPayload<Sender, Payload>(
+  eventName: EventName,
+  val body: (Sender, Payload) -> Unit
+) : EventListener(eventName) {
+  fun call(sender: Sender, payload: Payload) {
+    body(sender, payload)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/events/EventName.kt

@@ -0,0 +1,31 @@
+package expo.modules.kotlin.events
+
+enum class EventName {
+  MODULE_CREATE,
+  MODULE_DESTROY,
+
+  /**
+   * Called when the host activity receives a resume event (e.g. Activity.onResume)
+   */
+  ACTIVITY_ENTERS_FOREGROUND,
+
+  /**
+   * Called when host activity receives pause event (e.g. Activity.onPause)
+   */
+  ACTIVITY_ENTERS_BACKGROUND,
+
+  /**
+   * Called when host activity receives destroy event (e.g. Activity.onDestroy)
+   */
+  ACTIVITY_DESTROYS,
+
+  /**
+   * Called when a new intent is passed to the activity
+   */
+  ON_NEW_INTENT,
+
+  /**
+   * Called when other activity returns
+   */
+  ON_ACTIVITY_RESULT
+}

package/android/src/main/java/expo/modules/kotlin/events/EventsDefinition.kt

@@ -0,0 +1,3 @@
+package expo.modules.kotlin.events
+
+class EventsDefinition(val names: Array<out String>)