@kaleyra/video-react-native-module 1.6.0 → 2.0.1

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

@@ -3,32 +3,54 @@
 
 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.State
+import com.kaleyra.video_common_ui.KaleyraVideo
 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
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.onEach
 
 class ModuleEventsReporter(
-    val sdk: BandyerSDKInstance,
-    val eventsEmitter: EventsEmitter
-) : EventsReporter, BandyerModuleObserver {
+    val sdk: KaleyraVideo,
+    val eventsEmitter: EventsEmitter,
+    val coroutineScope: CoroutineScope
+) : EventsReporter {
 
-    override fun start() = sdk.addModuleObserver(this)
-    override fun stop() = sdk.removeModuleObserver(this)
+    private var jobs: MutableSet<Job> = mutableSetOf()
 
-    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
+    private var previousCallState: State? = null
+
+    private var previousChatState: State? = null
+
+    override fun start() {
+        stop()
+        jobs += sdk.conference.state
+            .mapNotNull { state ->
+                state.toCrossPlatformModuleStatus(previousCallState).also {
+                    previousCallState = state
+                }
+            }
+            .onEach { state -> eventsEmitter.sendEvent(CallModuleStatusChanged, state) }
+            .launchIn(coroutineScope)
+        jobs += sdk.conversation.state
+            .mapNotNull { state ->
+                state.toCrossPlatformModuleStatus(previousChatState).also {
+                    previousChatState = state
+                }
+            }
+            .onEach { state -> eventsEmitter.sendEvent(ChatModuleStatusChanged, state) }
+            .launchIn(coroutineScope)
     }
 
-    override fun onModuleFailed(module: BandyerModule, throwable: Throwable) = Unit
-    override fun onModulePaused(module: BandyerModule) = Unit
-    override fun onModuleReady(module: BandyerModule) = Unit
+    override fun stop() {
+        previousCallState = null
+        previousChatState = null
+        jobs.forEach { it.cancel() }
+        jobs.clear()
+    }
 }

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

@@ -3,7 +3,7 @@
 
 package com.kaleyra.video_hybrid_native_bridge.events.reporter
 
-import com.bandyer.android_sdk.client.BandyerSDKInstance
+import com.kaleyra.video_common_ui.KaleyraVideo
 import com.kaleyra.video_hybrid_native_bridge.events.EventsEmitter
 import com.kaleyra.video_hybrid_native_bridge.events.EventsReporter
 import kotlinx.coroutines.CoroutineScope
@@ -21,20 +21,20 @@ class SDKEventsReporter internal constructor(
         private var instance: SDKEventsReporter? = null
 
         fun create(
-            sdk: BandyerSDKInstance,
+            sdk: KaleyraVideo,
             eventsEmitter: EventsEmitter,
             scope: CoroutineScope
         ): SDKEventsReporter = instance.takeIf { it?.isRunning == true } ?: SDKEventsReporter(sdk, eventsEmitter, scope).apply { instance = this }
     }
 
     private constructor(
-        sdk: BandyerSDKInstance,
+        sdk: KaleyraVideo,
         eventsEmitter: EventsEmitter,
         scope: CoroutineScope
     ) : this(
-        ModuleEventsReporter(sdk, eventsEmitter),
-        CallEventsReporter(sdk, eventsEmitter),
-        ChatEventsReporter(sdk, eventsEmitter),
+        ModuleEventsReporter(sdk, eventsEmitter, scope),
+        CallEventsReporter(sdk, eventsEmitter, scope),
+        ChatEventsReporter(sdk, eventsEmitter, scope),
         scope
     )
 

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

@@ -3,13 +3,14 @@
 
 package com.kaleyra.video_hybrid_native_bridge.extensions
 
+import com.kaleyra.video_common_ui.CallUI
 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
+    Background                 -> CallUI.DisplayMode.Background
+    Foreground                 -> CallUI.DisplayMode.Foreground
+    ForegroundPictureInPicture -> CallUI.DisplayMode.PictureInPicture
 }

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

@@ -0,0 +1,12 @@
+package com.kaleyra.video_hybrid_native_bridge.extensions
+
+import com.kaleyra.video.conference.Call
+import com.kaleyra.video_hybrid_native_bridge.CallType
+
+internal fun CallType.toSDK(): Call.PreferredType {
+    return when(this) {
+        CallType.Audio -> Call.PreferredType.audioOnly()
+        CallType.AudioUpgradable -> Call.PreferredType.audioUpgradable()
+        CallType.AudioVideo -> Call.PreferredType.audioVideo()
+    }
+}

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

@@ -3,12 +3,11 @@
 
 package com.kaleyra.video_hybrid_native_bridge.extensions
 
-import com.bandyer.android_sdk.client.BandyerSDKConfiguration
+import com.kaleyra.video.configuration.Configuration
 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 com.kaleyra.video_utils.logging.BaseLogger
+import com.kaleyra.video_utils.logging.androidPrioryLogger
 import okhttp3.OkHttpClient
 import java.security.cert.X509Certificate
 import javax.net.ssl.X509TrustManager
@@ -17,23 +16,18 @@ 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()
+internal fun KaleyraVideoConfiguration.toSDK() =
+    Configuration(
+        appId = appID,
+        environment = environment.toSDK(),
+        region = region.toSDK(),
+        httpStack = trustedHttpClient(),
+        logger = if (logEnabled == true) androidPrioryLogger(BaseLogger.VERBOSE, -1) else null
+    )
 
-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()
+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

@@ -6,7 +6,7 @@ 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)
+    "sandbox"    -> com.kaleyra.video.configuration.Environment.Sandbox
+    "production" -> com.kaleyra.video.configuration.Environment.Production
+    else         -> com.kaleyra.video.configuration.Environment.create(name)
 }

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

@@ -3,13 +3,11 @@
 
 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.conference.Call
 import com.kaleyra.video_hybrid_native_bridge.RecordingType
 
-internal fun RecordingType?.toSDK(): CallRecordingType = when (this) {
-    RecordingType.Manual    -> MANUAL
-    RecordingType.Automatic -> AUTOMATIC
-    else                    -> CallRecordingType.NONE
+internal fun RecordingType?.toSDK() = when (this) {
+    RecordingType.Manual    -> Call.Recording.manual()
+    RecordingType.Automatic -> Call.Recording.automatic()
+    else                    -> Call.Recording.disabled()
 }

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

@@ -6,8 +6,8 @@ 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)
+    "europe" -> com.kaleyra.video.configuration.Region.Europe
+    "india"  -> com.kaleyra.video.configuration.Region.India
+    "us"     -> com.kaleyra.video.configuration.Region.US
+    else     -> com.kaleyra.video.configuration.Region.create(name)
 }

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

@@ -3,13 +3,12 @@
 
 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_common_ui.CallUI
 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)
+internal fun ScreenShareToolConfiguration?.toSDK(): CallUI.Action.ScreenShare? = when {
+    this?.inApp == true && this.wholeDevice == true -> CallUI.Action.ScreenShare.UserChoice
+    this?.inApp == true                             -> CallUI.Action.ScreenShare.App
+    this?.wholeDevice == true                       -> CallUI.Action.ScreenShare.WholeDevice
     else                                            -> null
 }

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

@@ -3,93 +3,61 @@
 
 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.conference.Call
+import com.kaleyra.video_common_ui.CallUI
+import com.kaleyra.video_common_ui.ChatUI
+import com.kaleyra.video_common_ui.ChatUI.Action.CreateCall
 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
+internal fun Tools.toCallActions(): Set<CallUI.Action> {
+    val callActions = CallUI.Action.default.toMutableSet()
+    if (this.whiteboard == true) {
+        callActions.add(CallUI.Action.OpenWhiteboard.Full)
+    }
+    if (this.fileShare == true) {
+        callActions.add(CallUI.Action.FileShare)
+    }
 
-    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
-    )
+    screenShare.toSDK()?.let {
+        callActions.add(it)
+    }
 
-    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 }
-    ))
+    return callActions
 }
 
-private fun screenShare(tools: Tools): CustomScreenShareConfiguration? {
-    tools.screenShare ?: return null
-    val optionSet = tools.screenShare.toSDK() ?: return CustomScreenShareConfiguration()
-    return CustomScreenShareConfiguration(optionSet = optionSet)
+internal fun Tools.toChatActions(): Set<ChatUI.Action> {
+    chat ?: return emptySet()
+    val chatActions = mutableSetOf<ChatUI.Action>()
+    when (chat.audioCallOption?.type) {
+        Audio -> {
+            chatActions.add(
+                CreateCall(
+                    preferredType = Call.PreferredType.audioOnly(),
+                    recordingType = chat.audioCallOption.recordingType.toSDK()
+                )
+            )
+        }
+
+        AudioUpgradable -> {
+            chatActions.add(
+                CreateCall(
+                    preferredType = Call.PreferredType.audioUpgradable(),
+                    recordingType = chat.audioCallOption.recordingType.toSDK()
+                )
+            )
+        }
+
+        else -> Unit
+    }
+    if (chat.videoCallOption != null) {
+        chatActions.add(
+            CreateCall(
+                preferredType = Call.PreferredType.audioVideo(),
+                recordingType = chat.videoCallOption.recordingType.toSDK()
+            )
+        )
+    }
+    return chatActions
 }
-
-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

@@ -3,7 +3,8 @@
 
 package com.kaleyra.video_hybrid_native_bridge.extensions
 
-import com.bandyer.android_sdk.utils.provider.UserDetails
+import android.net.Uri
+import com.kaleyra.video_common_ui.model.UserDetails
 import com.kaleyra.video_hybrid_native_bridge.repository.UserDetailsEntity
 
 /**
@@ -11,25 +12,31 @@ 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) }
+    return UserDetails(
+        userId = userID,
+        name = name ?: userID,
+        image = imageUrl?.let { Uri.parse(it) } ?: Uri.EMPTY
+    )
+}
 
-        email?.let { builder.withEmail(it) }
+internal fun com.kaleyra.video_hybrid_native_bridge.UserDetails.toSDK(): UserDetails {
+    return UserDetails(
+        userId = userID,
+        name = name ?: userID,
+        image = imageURL?.let { Uri.parse(it) } ?: Uri.EMPTY
+    )
+}
 
-        imageUrl?.let { builder.withImageUrl(it) }
-    }.build()
+internal fun com.kaleyra.video_hybrid_native_bridge.UserDetails.toDatabaseEntity(): UserDetailsEntity {
+    return UserDetailsEntity(
+        userID = userID,
+        name = name,
+        imageUrl = imageURL
+    )
 }
 
 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
+    userID = this.userID,
+    name = this.name,
+    imageURL = 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/KaleyraVideoNotificationService.kt

@@ -8,9 +8,9 @@ import android.content.Context
 import android.content.Intent
 import android.util.Log
 import androidx.core.app.JobIntentService
-import com.kaleyra.video_hybrid_native_bridge.VideoSDKHybridBridge
 import com.kaleyra.video_hybrid_native_bridge.ContextContainer
 import com.kaleyra.video_hybrid_native_bridge.CrossPlatformAccessTokenProvider
+import com.kaleyra.video_hybrid_native_bridge.VideoSDKHybridBridge
 import com.kaleyra.video_hybrid_native_bridge.events.Events
 import com.kaleyra.video_hybrid_native_bridge.events.EventsEmitter
 import com.kaleyra.video_hybrid_native_bridge.events.EventsReporter
@@ -59,7 +59,6 @@ class KaleyraVideoNotificationService : JobIntentService() {
                 plugin.addUsersDetails(plugin.cachedUserDetails.toTypedArray())
                 plugin.configureBridge(savedConfiguration)
                 plugin.connect(savedUsed)
-                plugin.handlePushNotificationPayload(webHookPayload)
             }
         } catch (exception: Throwable) {
             Log.e("KaleyraNotService", "" + exception.message)

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/repository/UserDetailsDao.kt

@@ -10,7 +10,7 @@ interface UserDetailsDao {
     @get:Query("SELECT * FROM userdetailsentity")
     val all: List<UserDetailsEntity>
 
-    @Query("SELECT * FROM userdetailsentity WHERE userAlias = :userAlias LIMIT 1")
+    @Query("SELECT * FROM userdetailsentity WHERE userID = :userAlias LIMIT 1")
     fun getUserDetailsEntity(userAlias: String): UserDetailsEntity?
 
     @Insert(onConflict = OnConflictStrategy.REPLACE)

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/repository/UserDetailsEntity.kt

@@ -6,17 +6,13 @@ package com.kaleyra.video_hybrid_native_bridge.repository
 import androidx.room.Entity
 import androidx.room.PrimaryKey
 
-
 /**
  * @suppress
  * @author kristiyan
  */
 @Entity
 data class UserDetailsEntity(
-    @PrimaryKey val userAlias: String,
-    var firstName: String? = null,
-    var lastName: String? = null,
-    var nickName: String? = null,
-    var email: String? = null,
+    @PrimaryKey val userID: String,
+    var name: String? = null,
     var imageUrl: String? = null
 )

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/repository/VideoHybridBridgeRepository.kt

@@ -14,7 +14,7 @@ import androidx.room.TypeConverters
  *
  * @author kristiyan
  */
-@Database(entities = [UserDetailsEntity::class, ConfigurationEntity::class, ConnectedUserEntity::class], version = 2, exportSchema = false)
+@Database(entities = [UserDetailsEntity::class, ConfigurationEntity::class, ConnectedUserEntity::class], version = 3, exportSchema = false)
 @TypeConverters(Converters::class)
 abstract class VideoHybridBridgeRepository : RoomDatabase() {
 

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/ui/SDKUserInterfacePresenter.kt

@@ -3,47 +3,49 @@
 
 package com.kaleyra.video_hybrid_native_bridge.ui
 
-import com.bandyer.android_sdk.client.BandyerSDKInstance
-import com.bandyer.android_sdk.intent.BandyerIntent
+import com.kaleyra.video_common_ui.KaleyraVideo
 import com.kaleyra.video_hybrid_native_bridge.CallDisplayMode
-import com.kaleyra.video_hybrid_native_bridge.CallType.Audio
-import com.kaleyra.video_hybrid_native_bridge.CallType.AudioUpgradable
-import com.kaleyra.video_hybrid_native_bridge.CallType.AudioVideo
 import com.kaleyra.video_hybrid_native_bridge.ContextContainer
 import com.kaleyra.video_hybrid_native_bridge.CreateCallOptions
+import com.kaleyra.video_hybrid_native_bridge.configurator.CachedSDKConfigurator
 import com.kaleyra.video_hybrid_native_bridge.extensions.toSDK
+import com.kaleyra.video.State
 
 internal class SDKUserInterfacePresenter(
-    private val sdk: BandyerSDKInstance,
-    private val contextContainer: ContextContainer
+    private val sdk: KaleyraVideo,
+    private val contextContainer: ContextContainer,
+    private val configurator: CachedSDKConfigurator
 ) : UserInterfacePresenter {
 
     private val context
         get() = contextContainer.context
 
     override fun startCall(callOptions: CreateCallOptions) {
-        val bandyerCallIntent = BandyerIntent.Builder().let {
-            when (callOptions.callType) {
-                Audio           -> it.startWithAudioCall(context)
-                AudioUpgradable -> it.startWithAudioUpgradableCall(context)
-                AudioVideo      -> it.startWithAudioVideoCall(context)
-            }.with(ArrayList(callOptions.callees)).build()
+        sdk.conference.call(
+            userIDs = callOptions.callees,
+            options = {
+                recordingType = callOptions.recordingType.toSDK()
+                preferredType = callOptions.callType.toSDK()
+            }
+        ).onSuccess {
+            val withFeedback = configurator.lastConfiguration?.tools?.feedback == true
+            it.withFeedback = withFeedback
         }
-        context.startActivity(bandyerCallIntent)
     }
 
     override fun startCallUrl(url: String) {
-        val bandyerCallIntent = BandyerIntent.Builder().startFromJoinCallUrl(context, url).build()
-        context.startActivity(bandyerCallIntent)
+        if (sdk.state.value == State.Disconnected) {
+            sdk.connect(url)
+        }
+        sdk.conference.joinUrl(url)
     }
 
     override fun startChat(userId: String) {
-        val bandyerCallIntent = BandyerIntent.Builder().startWithChat(context).with(userId).build()
-        context.startActivity(bandyerCallIntent)
+        sdk.conversation.chat(context, userId)
     }
 
     override fun setDisplayModeForCurrentCall(mode: CallDisplayMode) {
-        val ongoingCall = sdk.callModule?.ongoingCall ?: return
-        sdk.callModule?.setDisplayMode(ongoingCall, mode.toSDK())
+        val ongoingCall = sdk.conference.call.replayCache.firstOrNull() ?: return
+        ongoingCall.setDisplayMode(mode.toSDK())
     }
 }

package/native-bridge/android/src/main/java/com/kaleyra/video_hybrid_native_bridge/user_details/CachedUserDetails.kt

@@ -4,14 +4,11 @@
 package com.kaleyra.video_hybrid_native_bridge.user_details
 
 import com.kaleyra.video_hybrid_native_bridge.UserDetails
-import com.kaleyra.video_hybrid_native_bridge.UserDetailsFormat
 
 interface CachedUserDetails {
 
     val cachedUserDetails: androidx.collection.ArraySet<UserDetails>
 
-    fun setUserDetailsFormat(format: UserDetailsFormat)
-
     fun addUsersDetails(userDetails: Array<UserDetails>)
 
     fun removeUserDetails()