Preparing release 1.2.1

Author: queue-it

.gitignore

@@ -28,13 +28,15 @@ DerivedData
 *.ipa
 *.xcuserstate
 project.xcworkspace
+exampleApp/ios/.xcode.env.local
 
 # Android/IJ
 .idea
 .gradle
 local.properties
 android.iml
 android/bin/
+android/.settings/
 
 # Cocoapods
 exampleApp/ios/Pods

README.md

@@ -72,21 +72,19 @@ enqueue = async () => {
       enqueueResult = await QueueIt.runWithEnqueueKey(
         this.state.clientId,
         this.state.eventOrAlias,
-        this.getEnqueueKey(),
-        'mobile'
+        this.getEnqueueKey()
+        
       );
     } else if (this.state.enqueueToken) {
       enqueueResult = await QueueIt.runWithEnqueueToken(
         this.state.clientId,
         this.state.eventOrAlias,
-        this.getEnqueueToken(),
-        'mobile'
+        this.getEnqueueToken()
       );
     } else {
       enqueueResult = await QueueIt.run(
         this.state.clientId,
-        this.state.eventOrAlias,
-        'mobile'
+        this.state.eventOrAlias
       );
     }
     switch (enqueueResult.State) {

android/build.gradle

@@ -33,6 +33,10 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['QueueIt_' + name]).toInteger()
 }
 
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.newArchEnabled == "true"
+}
+
 android {
   namespace "com.reactnativequeueit"
   compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
@@ -44,6 +48,7 @@ android {
     targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
     versionCode 1
     versionName "1.0"
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
 
     externalNativeBuild {
       cmake {
@@ -78,13 +83,25 @@ android {
       java.srcDirs += "$buildDir/generated/source/codegen/java"
       jniLibs.srcDirs += "$buildDir/generated/source/codegen/jni"
     }
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += ['src/newarch']
+      } else {
+        java.srcDirs += ['src/oldarch']
+      }
+    }
+  }
+
+  packaging {
+    jniLibs {
+      excludes += ["**/libreactnative.so", "**/libjsi.so"]
+    }
   }
 }
 
 def kotlin_version = getExtOrDefault('kotlinVersion')
 dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
   implementation(libs.react.android)
   implementation(libs.fbjni)
 

android/src/main/java/com/reactnativequeueit/QueueItModule.kt

@@ -5,98 +5,35 @@ import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.queue_it.androidsdk.*
 
-
 enum class EnqueueResultState {
   Passed, Disabled, Unavailable, RestartedSession
 }
 
-class QueueItModule(reactContext: ReactApplicationContext)
-  : ReactContextBaseJavaModule(reactContext) {
+class QueueItModule(reactContext: ReactApplicationContext) {
+
+  companion object {
+    const val NAME = "QueueIt"
+  }
 
-  private val handler = Handler(reactContext.mainLooper)
-  private val context = reactContext
+  public val handler = Handler(reactContext.mainLooper)
+  public val context = reactContext
 
-  override fun getName(): String {
-    return "QueueIt"
+  fun getName(): String {
+    return NAME
   }
 
-  @ReactMethod
   fun enableTesting(value: Boolean) {
     QueueService.IsTest = value
   }
 
-  fun getQueueListener(promise: Promise): QueueListener {
-    return object : QueueListener() {
-      override fun onUserExited() {
-        val params = Arguments.createMap()
-        sendEvent(context, "userExited", params)
-      }
-
-      override fun onQueuePassed(queuePassedInfo: QueuePassedInfo?) {
-        handler.post {
-          val params = Arguments.createMap()
-          val token = if (queuePassedInfo?.queueItToken != null) queuePassedInfo.queueItToken else ""
-          params.putString("queueittoken", token)
-          params.putString("state", EnqueueResultState.Passed.name)
-          promise.resolve(params)
-        }
-      }
-
-      override fun onQueueItUnavailable() {
-        handler.post {
-          val params = Arguments.createMap()
-          params.putNull("queueittoken")
-          params.putString("state", EnqueueResultState.Unavailable.name)
-          promise.resolve(params)
-        }
-      }
-
-      override fun onQueueViewWillOpen() {
-        val params = Arguments.createMap()
-        sendEvent(context, "openingQueueView", params)
-      }
-
-      override fun onQueueDisabled(queueDisabledInfo: QueueDisabledInfo?) {
-        handler.post {
-          val params = Arguments.createMap()
-          val token = if (queueDisabledInfo?.queueItToken != null) queueDisabledInfo.queueItToken else ""
-          params.putString("queueittoken", token)
-          params.putString("state", EnqueueResultState.Disabled.name)
-          promise.resolve(params)
-        }
-      }
-
-      override fun onError(error: Error?, errorMessage: String?) {
-        handler.post {
-          promise.reject("error", errorMessage)
-        }
-      }
-
-      override fun onSessionRestart(queueITEngine: QueueITEngine?) {
-        handler.post {
-          val params = Arguments.createMap()
-          params.putNull("queueittoken")
-          params.putString("state", EnqueueResultState.RestartedSession.name)
-          promise.resolve(params)
-        }
-      }
-
-      override fun onWebViewClosed(){
-        val params = Arguments.createMap()
-        sendEvent(context, "webViewClosed", params)
-      }
-    }
-  }
-
-  @ReactMethod
-  fun runAsync(customerId: String, eventAlias: String, layoutName: String?, language: String?, promise: Promise) {
+  fun runAsync(customerId: String, eventAlias: String, layoutName: String?, language: String?, queueListener: QueueListener?, promise: Promise) {
     handler.post {
       if (context.currentActivity == null) {
         promise.reject("error", "Calling QueueItRun with a null activity/context")
         return@post
       }
       try {
-        val queueEngine = QueueITEngine(context.currentActivity, customerId, eventAlias, layoutName, language, getQueueListener(promise))
+        val queueEngine = QueueITEngine(context.currentActivity, customerId, eventAlias, layoutName, language, queueListener)
         queueEngine.run(context.currentActivity)
       } catch (e: Exception) {
         promise.reject("error", e.message)
@@ -105,15 +42,14 @@ class QueueItModule(reactContext: ReactApplicationContext)
     }
   }
 
-  @ReactMethod
-  fun runWithEnqueueTokenAsync(customerId: String, eventAlias: String, enqueueToken: String, layoutName: String?, language: String?, promise: Promise) {
+  fun runWithEnqueueTokenAsync(customerId: String, eventAlias: String, enqueueToken: String, layoutName: String?, language: String?, queueListener: QueueListener?, promise: Promise) {
     handler.post {
       if (context.currentActivity == null) {
         promise.reject("error", "Calling QueueItRun with a null activity/context")
         return@post
       }
       try {
-        val queueEngine = QueueITEngine(context.currentActivity, customerId, eventAlias, layoutName, language, getQueueListener(promise))
+        val queueEngine = QueueITEngine(context.currentActivity, customerId, eventAlias, layoutName, language, queueListener)
         queueEngine.runWithEnqueueToken(context.currentActivity, enqueueToken)
       } catch (e: Exception) {
         promise.reject("error", e.message)
@@ -122,27 +58,19 @@ class QueueItModule(reactContext: ReactApplicationContext)
     }
   }
 
-  @ReactMethod
-  fun runWithEnqueueKeyAsync(customerId: String, eventAlias: String, enqueueKey: String, layoutName: String?, language: String?, promise: Promise) {
+  fun runWithEnqueueKeyAsync(customerId: String, eventAlias: String, enqueueKey: String, layoutName: String?, language: String?, queueListener: QueueListener?, promise: Promise) {
     handler.post {
       if (context.currentActivity == null) {
         promise.reject("error", "Calling QueueItRun with a null activity/context")
         return@post
       }
       try {
-        val queueEngine = QueueITEngine(context.currentActivity, customerId, eventAlias, layoutName, language, getQueueListener(promise))
+        val queueEngine = QueueITEngine(context.currentActivity, customerId, eventAlias, layoutName, language, queueListener)
         queueEngine.runWithEnqueueKey(context.currentActivity, enqueueKey)
       } catch (e: Exception) {
         promise.reject("error", e.message)
         return@post
       }
     }
   }
-
-  private fun sendEvent(reactContext: ReactContext,
-                        eventName: String,
-                        params: WritableMap) {
-    reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-      .emit(eventName, params)
-  }
 }

android/src/main/java/com/reactnativequeueit/QueueItPackage.kt

@@ -1,18 +1,39 @@
 package com.reactnativequeueit
 
-import java.util.Arrays
-
-import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class QueueItPackage : TurboReactPackage() {
 
-class QueueItPackage : ReactPackage {
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return Arrays.asList<NativeModule>(QueueItModule(reactContext))
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    if (name == QueueItModule.NAME) {
+      return QueueIt(reactContext)
+    }
+    return null
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
     return emptyList<ViewManager<*, *>>()
   }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos = mutableMapOf<String, ReactModuleInfo>()
+      val isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+      moduleInfos[QueueItModule.NAME] = ReactModuleInfo(
+        QueueItModule.NAME,
+        QueueItModule::class.java.name,
+        false,
+        false,
+        true,
+        false,
+        isTurboModule
+      )
+      moduleInfos
+    }
+  }  
 }

android/src/main/jni/CMakeLists.txt

@@ -48,7 +48,7 @@ add_library(queueit_library SHARED ${SOURCE_FILES})
 
 find_package(fbjni REQUIRED CONFIG)
 target_link_libraries(queueit_library
-  fbjni
+  fbjni::fbjni
   jsi
   reactnative
 )