@kaleyra/video-react-native-module 1.0.0

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/events/reporter/CallEventsReporter.kt

@@ -0,0 +1,54 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.events.reporter
+
+import androidx.appcompat.app.AppCompatActivity
+import com.bandyer.android_sdk.call.CallException
+import com.bandyer.android_sdk.call.CallObserver
+import com.bandyer.android_sdk.call.CallUIObserver
+import com.bandyer.android_sdk.client.BandyerSDKInstance
+import com.bandyer.android_sdk.intent.call.Call
+import com.kaleyra.video_hybrid_native_bridge.events.Events.CallError
+import com.kaleyra.video_hybrid_native_bridge.events.EventsEmitter
+import com.kaleyra.video_hybrid_native_bridge.events.EventsReporter
+import java.lang.ref.WeakReference
+
+class CallEventsReporter(
+    private val sdk: BandyerSDKInstance,
+    private val eventsEmitter: EventsEmitter
+) : EventsReporter, CallObserver, CallUIObserver {
+
+    private val failedCalls = HashMap<String, Call>()
+
+    override fun start() {
+        sdk.callModule!!.addCallObserver(this)
+        sdk.callModule!!.addCallUIObserver(this)
+    }
+
+    override fun stop() {
+        sdk.callModule!!.removeCallObserver(this)
+        sdk.callModule!!.removeCallUIObserver(this)
+    }
+
+    override fun onCallEndedWithError(call: Call, callException: CallException) {
+        val id = call.callInfo.callId
+        if (failedCalls.containsKey(id)) return
+        failedCalls[id] = call
+        eventsEmitter.sendEvent(CallError, callException.localizedMessage)
+    }
+
+    override fun onActivityError(call: Call, activity: WeakReference<AppCompatActivity>, error: CallException) {
+        val id = call.callInfo.callId
+        if (failedCalls.containsKey(id)) return
+        failedCalls[id] = call
+        eventsEmitter.sendEvent(CallError, error.localizedMessage)
+    }
+
+    override fun onCallCreated(call: Call) = Unit
+    override fun onCallEnded(call: Call) = Unit
+    override fun onCallStarted(call: Call) = Unit
+
+    override fun onActivityDestroyed(call: Call, activity: WeakReference<AppCompatActivity>) = Unit
+    override fun onActivityStarted(call: Call, activity: WeakReference<AppCompatActivity>) = Unit
+}

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/events/reporter/ChatEventsReporter.kt

@@ -0,0 +1,43 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.events.reporter
+
+import androidx.appcompat.app.AppCompatActivity
+import com.bandyer.android_sdk.chat.ChatException
+import com.bandyer.android_sdk.chat.ChatObserver
+import com.bandyer.android_sdk.chat.ChatUIObserver
+import com.bandyer.android_sdk.client.BandyerSDKInstance
+import com.bandyer.android_sdk.intent.chat.Chat
+import com.kaleyra.video_hybrid_native_bridge.events.Events.ChatError
+import com.kaleyra.video_hybrid_native_bridge.events.EventsEmitter
+import com.kaleyra.video_hybrid_native_bridge.events.EventsReporter
+import java.lang.ref.WeakReference
+
+class ChatEventsReporter(
+    private val sdk: BandyerSDKInstance,
+    private val eventsEmitter: EventsEmitter
+) : EventsReporter, ChatObserver, ChatUIObserver {
+
+    private val failedChats = HashMap<String, Chat>()
+
+    override fun start() {
+        sdk.chatModule?.addChatObserver(this)
+        sdk.chatModule?.addChatUIObserver(this)
+    }
+
+    override fun stop() {
+        sdk.chatModule?.removeChatObserver(this)
+        sdk.chatModule?.removeChatUIObserver(this)
+    }
+
+    override fun onActivityError(chat: Chat, activity: WeakReference<AppCompatActivity>, error: ChatException) {
+        val id = chat.chatInfo.chatId
+        if (failedChats.containsKey(id)) return
+        failedChats[id] = chat
+        eventsEmitter.sendEvent(ChatError, error.localizedMessage)
+    }
+
+    override fun onActivityStarted(chat: Chat, activity: WeakReference<AppCompatActivity>) = Unit
+    override fun onActivityDestroyed(chat: Chat, activity: WeakReference<AppCompatActivity>) = Unit
+}

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/events/reporter/CrossPlatformModuleStatus.kt

@@ -0,0 +1,29 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.events.reporter
+
+import com.bandyer.android_sdk.module.BandyerModuleStatus
+import com.bandyer.android_sdk.module.BandyerModuleStatus.CONNECTED
+import com.bandyer.android_sdk.module.BandyerModuleStatus.CONNECTING
+import com.bandyer.android_sdk.module.BandyerModuleStatus.DISCONNECTED
+import com.bandyer.android_sdk.module.BandyerModuleStatus.FAILED
+import com.bandyer.android_sdk.module.BandyerModuleStatus.READY
+import com.kaleyra.video_hybrid_native_bridge.events.reporter.CrossPlatformModuleStatus.Connecting
+import com.kaleyra.video_hybrid_native_bridge.events.reporter.CrossPlatformModuleStatus.Failed
+import com.kaleyra.video_hybrid_native_bridge.events.reporter.CrossPlatformModuleStatus.Ready
+import com.kaleyra.video_hybrid_native_bridge.events.reporter.CrossPlatformModuleStatus.Stopped
+
+enum class CrossPlatformModuleStatus {
+    Ready,
+    Connecting,
+    Stopped,
+    Failed
+}
+
+internal fun BandyerModuleStatus.toCrossPlatformModuleStatus(): String = when (this) {
+    CONNECTING       -> Connecting.name.lowercase()
+    CONNECTED, READY -> Ready.name.lowercase()
+    DISCONNECTED     -> Stopped.name.lowercase()
+    FAILED           -> Failed.name.lowercase()
+}

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/events/reporter/ModuleEventsReporter.kt

@@ -0,0 +1,34 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.events.reporter
+
+import com.bandyer.android_sdk.call.CallModule
+import com.bandyer.android_sdk.chat.ChatModule
+import com.bandyer.android_sdk.client.BandyerSDKInstance
+import com.bandyer.android_sdk.module.BandyerModule
+import com.bandyer.android_sdk.module.BandyerModuleObserver
+import com.bandyer.android_sdk.module.BandyerModuleStatus
+import com.kaleyra.video_hybrid_native_bridge.events.Events.CallModuleStatusChanged
+import com.kaleyra.video_hybrid_native_bridge.events.Events.ChatModuleStatusChanged
+import com.kaleyra.video_hybrid_native_bridge.events.EventsEmitter
+import com.kaleyra.video_hybrid_native_bridge.events.EventsReporter
+
+class ModuleEventsReporter(
+    val sdk: BandyerSDKInstance,
+    val eventsEmitter: EventsEmitter
+) : EventsReporter, BandyerModuleObserver {
+
+    override fun start() = sdk.addModuleObserver(this)
+    override fun stop() = sdk.removeModuleObserver(this)
+
+    override fun onModuleStatusChanged(module: BandyerModule, moduleStatus: BandyerModuleStatus) = when (module) {
+        is CallModule -> eventsEmitter.sendEvent(CallModuleStatusChanged, moduleStatus.toCrossPlatformModuleStatus())
+        is ChatModule -> eventsEmitter.sendEvent(ChatModuleStatusChanged, moduleStatus.toCrossPlatformModuleStatus())
+        else          -> Unit
+    }
+
+    override fun onModuleFailed(module: BandyerModule, throwable: Throwable) = Unit
+    override fun onModulePaused(module: BandyerModule) = Unit
+    override fun onModuleReady(module: BandyerModule) = Unit
+}

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/events/reporter/SDKEventsReporter.kt

@@ -0,0 +1,63 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.events.reporter
+
+import com.bandyer.android_sdk.client.BandyerSDKInstance
+import com.kaleyra.video_hybrid_native_bridge.events.EventsEmitter
+import com.kaleyra.video_hybrid_native_bridge.events.EventsReporter
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+
+class SDKEventsReporter internal constructor(
+    private val moduleEventsReporter: ModuleEventsReporter,
+    private val callEventsReporter: CallEventsReporter,
+    private val chatEventsReporter: ChatEventsReporter,
+    private val scope: CoroutineScope
+) : EventsReporter {
+
+    companion object {
+
+        private var instance: SDKEventsReporter? = null
+
+        fun create(
+            sdk: BandyerSDKInstance,
+            eventsEmitter: EventsEmitter,
+            scope: CoroutineScope
+        ): SDKEventsReporter = instance.takeIf { it?.isRunning == true } ?: SDKEventsReporter(sdk, eventsEmitter, scope).apply { instance = this }
+    }
+
+    private constructor(
+        sdk: BandyerSDKInstance,
+        eventsEmitter: EventsEmitter,
+        scope: CoroutineScope
+    ) : this(
+        ModuleEventsReporter(sdk, eventsEmitter),
+        CallEventsReporter(sdk, eventsEmitter),
+        ChatEventsReporter(sdk, eventsEmitter),
+        scope
+    )
+
+    private var isRunning = false
+
+    override fun start() {
+        scope.launch {
+            if (isRunning) return@launch
+            isRunning = true
+            moduleEventsReporter.start()
+            callEventsReporter.start()
+            chatEventsReporter.start()
+        }
+    }
+
+    override fun stop() {
+        scope.launch {
+            if (!isRunning) return@launch
+            isRunning = false
+            moduleEventsReporter.stop()
+            callEventsReporter.stop()
+            chatEventsReporter.stop()
+        }
+    }
+
+}

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/extensions/CallDisplayExtension.kt

@@ -0,0 +1,15 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.extensions
+
+import com.kaleyra.video_hybrid_native_bridge.CallDisplayMode
+import com.kaleyra.video_hybrid_native_bridge.CallDisplayMode.Background
+import com.kaleyra.video_hybrid_native_bridge.CallDisplayMode.Foreground
+import com.kaleyra.video_hybrid_native_bridge.CallDisplayMode.ForegroundPictureInPicture
+
+internal fun CallDisplayMode.toSDK() = when (this) {
+    Background                 -> com.bandyer.android_sdk.intent.call.CallDisplayMode.BACKGROUND
+    Foreground                 -> com.bandyer.android_sdk.intent.call.CallDisplayMode.FOREGROUND
+    ForegroundPictureInPicture -> com.bandyer.android_sdk.intent.call.CallDisplayMode.FOREGROUND_PICTURE_IN_PICTURE
+}

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/extensions/ConfigurationExtension.kt

@@ -0,0 +1,39 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.extensions
+
+import com.bandyer.android_sdk.client.BandyerSDKConfiguration
+import com.kaleyra.video_hybrid_native_bridge.KaleyraVideoConfiguration
+import com.kaleyra.video_hybrid_native_bridge.CreateCallOptionsProxy
+import com.kaleyra.video_hybrid_native_bridge.utils.TLSSocketFactoryCompat
+import com.kaleyra.collaboration_suite_utils.logging.BaseLogger
+import com.kaleyra.collaboration_suite_utils.logging.androidPrioryLogger
+import okhttp3.OkHttpClient
+import java.security.cert.X509Certificate
+import javax.net.ssl.X509TrustManager
+
+/**
+ *
+ * @author kristiyan
+ */
+internal fun KaleyraVideoConfiguration.toSDK(createCallOptionsProxy: CreateCallOptionsProxy) = BandyerSDKConfiguration.Builder(appID, environment.toSDK(), region.toSDK()).apply {
+    tools {
+        tools ?: return@tools
+        val chatToolsConfiguration = tools.toChatConfiguration()
+        val callToolsConfiguration = tools.toCallConfiguration(chatToolsConfiguration, createCallOptionsProxy)
+        withCall { callConfiguration = callToolsConfiguration }
+        chatToolsConfiguration ?: return@tools
+        withChat { chatConfiguration = chatToolsConfiguration }
+    }
+    if (logEnabled == true) enableLogger()
+    httpStack(trustedHttpClient())
+}.build()
+
+private fun BandyerSDKConfiguration.Builder.enableLogger() = logger(androidPrioryLogger(BaseLogger.VERBOSE, -1))
+
+private fun trustedHttpClient() = OkHttpClient.Builder().sslSocketFactory(TLSSocketFactoryCompat(), object : X509TrustManager {
+    override fun getAcceptedIssuers(): Array<X509Certificate> = arrayOf()
+    override fun checkClientTrusted(certs: Array<X509Certificate>, authType: String) = Unit
+    override fun checkServerTrusted(certs: Array<X509Certificate>, authType: String) = Unit
+}).build()

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/extensions/EnvironmentExtension.kt

@@ -0,0 +1,12 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.extensions
+
+import com.kaleyra.video_hybrid_native_bridge.Environment
+
+internal fun Environment.toSDK() = when (name.lowercase()) {
+    "sandbox"    -> com.kaleyra.collaboration_suite_networking.Environment.Sandbox
+    "production" -> com.kaleyra.collaboration_suite_networking.Environment.Production
+    else         -> com.kaleyra.collaboration_suite_networking.Environment.create(name)
+}

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/extensions/RecordingTypeExtension.kt

@@ -0,0 +1,15 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.extensions
+
+import com.bandyer.android_sdk.intent.call.CallRecordingType
+import com.bandyer.android_sdk.intent.call.CallRecordingType.AUTOMATIC
+import com.bandyer.android_sdk.intent.call.CallRecordingType.MANUAL
+import com.kaleyra.video_hybrid_native_bridge.RecordingType
+
+internal fun RecordingType?.toSDK(): CallRecordingType = when (this) {
+    RecordingType.Manual    -> MANUAL
+    RecordingType.Automatic -> AUTOMATIC
+    else                    -> CallRecordingType.NONE
+}

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/extensions/RegionExtension.kt

@@ -0,0 +1,13 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.extensions
+
+import com.kaleyra.video_hybrid_native_bridge.Region
+
+internal fun Region.toSDK() = when (name.lowercase()) {
+    "europe" -> com.kaleyra.collaboration_suite_networking.Region.Eu
+    "india"  -> com.kaleyra.collaboration_suite_networking.Region.In
+    "us"     -> com.kaleyra.collaboration_suite_networking.Region.Us
+    else     -> com.kaleyra.collaboration_suite_networking.Region.create(name)
+}

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/extensions/ScreenShareToolConfigurationExtension.kt

@@ -0,0 +1,15 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.extensions
+
+import com.bandyer.android_sdk.tool_configuration.screen_share.CustomScreenShareConfiguration
+import com.bandyer.android_sdk.tool_configuration.screen_share.ScreenShareOptionSet
+import com.kaleyra.video_hybrid_native_bridge.ScreenShareToolConfiguration
+
+internal fun ScreenShareToolConfiguration?.toSDK(): ScreenShareOptionSet? = when {
+    this?.inApp == true && this.wholeDevice == true -> CustomScreenShareConfiguration.Options(ScreenShareOptionSet.USER_SELECTION)
+    this?.inApp == true                             -> CustomScreenShareConfiguration.Options(ScreenShareOptionSet.APP_ONLY)
+    this?.wholeDevice == true                       -> CustomScreenShareConfiguration.Options(ScreenShareOptionSet.WHOLE_DEVICE)
+    else                                            -> null
+}

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/extensions/ToolsExtension.kt

@@ -0,0 +1,95 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.extensions
+
+import com.bandyer.android_sdk.intent.call.CallOptions
+import com.bandyer.android_sdk.tool_configuration.call.CustomCallConfiguration
+import com.bandyer.android_sdk.tool_configuration.chat.CustomChatConfiguration
+import com.bandyer.android_sdk.tool_configuration.chat.CustomChatConfiguration.CustomCapabilitySet
+import com.bandyer.android_sdk.tool_configuration.file_share.CustomFileShareConfiguration
+import com.bandyer.android_sdk.tool_configuration.file_share.FileShareConfiguration
+import com.bandyer.android_sdk.tool_configuration.screen_share.CustomScreenShareConfiguration
+import com.bandyer.android_sdk.tool_configuration.screen_share.ScreenShareConfiguration
+import com.bandyer.android_sdk.tool_configuration.whiteboard.CustomWhiteboardConfiguration
+import com.bandyer.android_sdk.tool_configuration.whiteboard.WhiteboardConfiguration
+import com.kaleyra.video_hybrid_native_bridge.AudioCallType.Audio
+import com.kaleyra.video_hybrid_native_bridge.AudioCallType.AudioUpgradable
+import com.kaleyra.video_hybrid_native_bridge.CreateCallOptionsProxy
+import com.kaleyra.video_hybrid_native_bridge.RecordingType
+import com.kaleyra.video_hybrid_native_bridge.Tools
+
+internal fun Tools.toCallConfiguration(chatConfiguration: CustomChatConfiguration?, createCallOptionsProxy: CreateCallOptionsProxy): CustomCallConfiguration {
+    val fileShareConfiguration = CustomFileShareConfiguration().takeIf { fileShare == true }
+    val screenShareConfiguration = screenShare(this)
+    val whiteboardConfiguration = CustomWhiteboardConfiguration().takeIf { whiteboard == true }
+    val feedback = feedback == true
+
+    return CustomCallConfiguration(
+        capabilitySet = CustomCallConfiguration.CustomCapabilitySet(
+            chatConfiguration,
+            fileShareConfiguration,
+            screenShareConfiguration,
+            whiteboardConfiguration
+        ),
+        optionSet = callOptions(feedback, createCallOptionsProxy.createCallOptions.recordingType)
+    )
+}
+
+internal fun Tools.toChatConfiguration(): CustomChatConfiguration? {
+    this.chat ?: return null
+    val fileShareConfiguration = CustomFileShareConfiguration().takeIf { fileShare == true }
+    val screenShareConfiguration = screenShare(this)
+    val whiteboardConfiguration = CustomWhiteboardConfiguration().takeIf { whiteboard == true }
+    val feedback = feedback == true
+
+    val audioChatCallConfiguration = chatCallConfiguration(
+        fileShareConfiguration,
+        screenShareConfiguration,
+        whiteboardConfiguration,
+        feedback,
+        chat.audioCallOption?.recordingType
+    )
+
+    val audioVideoChatCallConfiguration = chatCallConfiguration(
+        fileShareConfiguration,
+        screenShareConfiguration,
+        whiteboardConfiguration,
+        feedback,
+        chat.videoCallOption?.recordingType
+    )
+    return CustomChatConfiguration(CustomCapabilitySet(
+        audioCallConfiguration = audioChatCallConfiguration.takeIf { chat.audioCallOption?.type == Audio },
+        audioUpgradableCallConfiguration = audioChatCallConfiguration.takeIf { chat.audioCallOption?.type == AudioUpgradable },
+        audioVideoCallConfiguration = audioVideoChatCallConfiguration.takeIf { chat.videoCallOption != null }
+    ))
+}
+
+private fun screenShare(tools: Tools): CustomScreenShareConfiguration? {
+    tools.screenShare ?: return null
+    val optionSet = tools.screenShare.toSDK() ?: return CustomScreenShareConfiguration()
+    return CustomScreenShareConfiguration(optionSet = optionSet)
+}
+
+private fun callOptions(feedback: Boolean, recordingType: RecordingType?) = CallOptions(feedbackEnabled = feedback, callRecordingType = recordingType.toSDK())
+
+private fun chatCallCapabilitySet(
+    fileShareConfiguration: FileShareConfiguration?,
+    screenShareConfiguration: ScreenShareConfiguration?,
+    whiteboardConfiguration: WhiteboardConfiguration?
+) = CustomCapabilitySet.CustomCallConfiguration.CustomCapabilitySet(
+    fileShareConfiguration,
+    screenShareConfiguration,
+    whiteboardConfiguration
+)
+
+private fun chatCallConfiguration(
+    fileShareConfiguration: CustomFileShareConfiguration?,
+    screenShareConfiguration: CustomScreenShareConfiguration?,
+    whiteboardConfiguration: CustomWhiteboardConfiguration?,
+    feedback: Boolean,
+    recordingType: RecordingType?
+) = CustomCapabilitySet.CustomCallConfiguration(
+    capabilitySet = chatCallCapabilitySet(fileShareConfiguration, screenShareConfiguration, whiteboardConfiguration),
+    optionSet = callOptions(feedback, recordingType)
+)

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/extensions/UserExtensions.kt

@@ -0,0 +1,35 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.extensions
+
+import com.bandyer.android_sdk.utils.provider.UserDetails
+import com.kaleyra.video_hybrid_native_bridge.repository.UserDetailsEntity
+
+/**
+ *
+ * @author kristiyan
+ */
+internal fun UserDetailsEntity.toSDK(): UserDetails {
+    return UserDetails.Builder(userAlias).also { builder ->
+
+        firstName?.let { builder.withFirstName(it) }
+        lastName?.let { builder.withLastName(it) }
+        nickName?.let { builder.withNickName(it) }
+
+        email?.let { builder.withEmail(it) }
+
+        imageUrl?.let { builder.withImageUrl(it) }
+    }.build()
+}
+
+internal fun UserDetailsEntity.toUserDetails(): com.kaleyra.video_hybrid_native_bridge.UserDetails = com.kaleyra.video_hybrid_native_bridge.UserDetails(
+    email = this.email,
+    userID = this.userAlias,
+    firstName = this.firstName,
+    lastName = this.lastName,
+    nickName = this.nickName,
+    profileImageURL = this.imageUrl
+)
+
+internal fun UserDetails.toUserDetailsEntity(): UserDetailsEntity = UserDetailsEntity(userAlias, firstName, lastName, nickName, email, imageUrl)

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/notifications/KaleyraVideoNotificationReceiver.kt

@@ -0,0 +1,139 @@
+// Copyright © 2018-2023 Kaleyra S.p.a. All Rights Reserved.
+// See LICENSE for licensing information
+
+package com.kaleyra.video_hybrid_native_bridge.notifications
+
+import android.app.Activity
+import android.content.BroadcastReceiver
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Bundle
+import android.util.Log
+//import com.bandyer.flutter_plugin.exceptions.PluginNotificationKeyNotFound
+//import com.bandyer.flutter_plugin.exceptions.NotificationPayloadDataPathNotDefined
+//import com.bandyer.flutter_plugin.extensions.asJSONObject
+import org.json.JSONObject
+
+/**
+ * @author kristiyan
+ */
+class KaleyraVideoNotificationReceiver : BroadcastReceiver() {
+
+    companion object {
+        private val GCM_RECEIVE_ACTION = "com.google.android.c2dm.intent.RECEIVE"
+        private val GCM_TYPE = "gcm"
+        private val MESSAGE_TYPE_EXTRA_KEY = "message_type"
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val bundle = intent.extras
+        // check if is from gcm/fcm, else return because it is not a notification
+        if (bundle == null || "google.com/iid" == bundle.getString("from")) return
+        if (!isGcmMessage(intent)) {
+            if (isOrderedBroadcast) resultCode = Activity.RESULT_OK
+            return
+        }
+
+        // check if a bandyer notification service was defined in the manifest
+        val serviceIntent = Intent().setAction("com.bandyer.NotificationEvent").setPackage(context.packageName)
+        val resolveInfo = context.packageManager.queryIntentServices(serviceIntent, PackageManager.GET_RESOLVED_FILTER)
+        if (resolveInfo.size < 1) return
+
+        val bandyerPayloadPath: String
+        try {
+            bandyerPayloadPath = resolveInfo[0].filter.getDataPath(0).path
+        } catch (e: Throwable) {
+            throw Throwable("You have not defined data path in your intent-filter!! Bandyer requires it to know where to find the payload!")
+        }
+
+        val payload = getBandyerPayload(intent, bandyerPayloadPath)
+        // if bandyer can handle payload proceed
+        if (payload == null) {
+            resultCode = Activity.RESULT_OK
+            return
+        }
+
+        val component = ComponentName(context, resolveInfo[0].serviceInfo.name)
+
+        serviceIntent.component = component
+        serviceIntent.putExtra("payload", payload)
+
+        KaleyraVideoNotificationService.enqueueWork(context, component, serviceIntent)
+
+        if (isOrderedBroadcast) abortBroadcast()
+        resultCode = Activity.RESULT_OK
+    }
+
+    private fun getBandyerPayload(intent: Intent, bandyerPayloadPath: String): String? {
+        try {
+            val keyPath = bandyerPayloadPath.split("\\.".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+            val payload = intent.extras!!.asJSONObject()
+            if (!payload.toString().isBandyerNotification()) return null
+            if (!payload.has(keyPath[0]))
+                throw PluginNotificationKeyNotFound("\nRequired jsonObject:" + keyPath[0] + " is not contained in " + payload.keys().asString())
+            var bandyerData = payload.getString(keyPath[0])
+            for (i in 1 until keyPath.size) {
+                val data = JSONObject(bandyerData)
+                if (!data.has(keyPath[i]))
+                    throw PluginNotificationKeyNotFound("\nRequired jsonObject:" + keyPath[i] + " is not contained in " + payload.keys().asString())
+                bandyerData = JSONObject(bandyerData).getString(keyPath[i])
+            }
+            return bandyerData
+        } catch (e: Throwable) {
+            if (e is PluginNotificationKeyNotFound) {
+                Log.w(
+                    "BandyerNotReceiver", "Failed to handle notification!!!" + e.message +
+                            "\nThis notification will not be handled by Bandyer!" +
+                            "\nBandyer payload not found in the following path: " + bandyerPayloadPath
+                )
+            } else
+                Log.w(
+                    "BandyerNotReceiver", "Failed to handle notification!!!" +
+                            "\nThis notification will not be handled by Bandyer!" +
+                            e.localizedMessage!!
+                )
+        }
+        return null
+    }
+
+    private fun Iterator<String>.asString(): String {
+        val value = StringBuilder()
+        value.append("<")
+        while (hasNext()) {
+            value.append(next())
+            if (hasNext()) value.append(",")
+        }
+        value.append(">")
+        return value.toString()
+    }
+
+    private fun String.isBandyerNotification(): Boolean = contains("on_call_incoming") || contains("on_message_sent");
+
+    private fun isGcmMessage(intent: Intent): Boolean {
+        if (GCM_RECEIVE_ACTION == intent.action) {
+            val messageType = intent.getStringExtra(MESSAGE_TYPE_EXTRA_KEY)
+            return messageType == null || GCM_TYPE == messageType
+        }
+        return false
+    }
+
+    private fun Bundle.asJSONObject(): JSONObject {
+        val json = JSONObject()
+        val keys = keySet()
+
+        for (key in keys) {
+            try {
+                json.put(key, get(key))
+            } catch (e: Throwable) {
+                e.printStackTrace()
+            }
+        }
+        return json
+    }
+
+    class PluginNotificationKeyNotFound(override val message: String?): Throwable(message)
+
+}
+