Android 14 migration

Author: Kesavcontus

app/build.gradle

@@ -32,10 +32,10 @@ android {
 
     defaultConfig {
         minSdkVersion 21
-        targetSdkVersion 33
-        compileSdk(33)
+        targetSdkVersion 34
+        compileSdk(34)
         versionCode 16
-        versionName "7.11.0"
+        versionName "7.11.4"
         multiDexEnabled true
         buildConfigField "java.util.Date", "BUILD_TIME", "new java.util.Date(" + System.currentTimeMillis() + "L)"
         vectorDrawables.useSupportLibrary = true
@@ -45,7 +45,6 @@ android {
 
     buildTypes {
         debug {
-            initWith debug
             buildConfigField 'Boolean', 'IS_QA_BUILD', 'true'
             buildConfigField 'String', 'LICENSE', '"Please enter your License key"'
             buildConfigField 'String', 'WEB_CHAT_LOGIN', '"https://webchat-preprod-sandbox.mirrorfly.com/"'
@@ -86,7 +85,6 @@ android {
         javaMaxHeapSize "4g"
     }
 
-
     buildTypes.each {
         it.buildConfigField 'String', 'GOOGLE_TRANSLATE_KEY', GOOGLE_TRANSLATE_KEY
         it.buildConfigField 'Boolean', 'HIPAA_COMPLIANCE_ENABLED', HIPAA_COMPLIANCE_ENABLED
@@ -203,7 +201,7 @@ dependencies {
     implementation project(':sdk:googletranslation')
     implementation project(path: ':call')
 
-    implementation 'com.mirrorfly.sdk:mirrorflysdk:7.11.0'
+    implementation 'com.mirrorfly.sdk:mirrorflysdk:7.11.4'
 
     //Socket - versions.gradle
     implementation 'com.github.nkzawa:socket.io-client:0.6.0'

app/src/main/AndroidManifest.xml

@@ -43,6 +43,16 @@
 
     <uses-feature android:name="android.hardware.camera" />
 
+    <!--Android 14 permission changes -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CAMERA"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC"/>
+
+    <uses-permission android:name="android.permission.TURN_SCREEN_ON"/>
+
     <queries>
         <intent>
             <action android:name="android.intent.action.VIEW" />

app/src/main/java/com/contusfly/activities/ChatActivity.kt

@@ -2164,7 +2164,6 @@ class ChatActivity : ChatParent(), ActionMode.Callback, View.OnTouchListener, Em
     }
 
     override fun onCancelUploadClicked(messageItem: ChatMessage) {
-        LogMessage.d(FILE_UPLOAD_TAG,"Cancel Uploading.......")
         if (!messageItem.isMediaUploaded() || !messageItem.isMediaDownloaded())
             handleCancelClickedOnMediaMessage(messageItem)
         else {
@@ -2190,7 +2189,6 @@ class ChatActivity : ChatParent(), ActionMode.Callback, View.OnTouchListener, Em
     }
 
     override fun onRetryClicked(item: ChatMessage?) {
-        LogMessage.d(FILE_UPLOAD_TAG,"Resume Uploading.......")
         netConditionalCall({
             item?.let {
                 FlyMessenger.uploadMedia(it.messageId)
@@ -2240,7 +2238,6 @@ class ChatActivity : ChatParent(), ActionMode.Callback, View.OnTouchListener, Em
                 listChats.scrollToPosition(mainList.size - 1)
         } catch (e: java.lang.Exception) {
             LogMessage.e(e)
-            LogMessage.e(FILE_UPLOAD_TAG,"Clear Chat Error $e")
         }
     }
 

app/src/main/java/com/contusfly/activities/parent/ChatParent.kt

@@ -142,8 +142,6 @@ open class ChatParent : BaseActivity(), CoroutineScope, MessageListener,
 
     private var isRefreshing = false
 
-    val FILE_UPLOAD_TAG: String =" #FileUploadTask "
-
     protected val mentionViewModel by lazy {
         ViewModelProvider(this).get(MentionsViewModel::class.java)
     }

app/src/main/java/com/contusfly/call/groupcall/GroupCallActivity.kt

@@ -27,8 +27,10 @@ import com.contusfly.call.groupcall.listeners.ActivityOnClickListener
 import com.contusfly.call.groupcall.utils.CallUtils
 import com.contusfly.databinding.ActivityGroupCallBinding
 import com.contusfly.utils.ChatUtils
+import com.contusfly.utils.Constants
 import com.contusfly.utils.MediaPermissions
 import com.contusfly.utils.ProfileDetailsUtils
+import com.contusfly.utils.SharedPreferenceManager
 import com.contusfly.views.PermissionAlertDialog
 import com.mirrorflysdk.AppUtils
 import com.mirrorflysdk.flycall.call.utils.GroupCallUtils
@@ -223,6 +225,8 @@ class GroupCallActivity : BaseActivity(), View.OnClickListener, ActivityOnClickL
         initClickListeners()
         setUpCallDataAndUI()
         groupCallViewModel.checkInternetConnection()
+
+        checkAndRequestFullScreenPermission()
     }
 
     private fun setUpCallDataAndUI() {
@@ -1216,4 +1220,26 @@ class GroupCallActivity : BaseActivity(), View.OnClickListener, ActivityOnClickL
         LogMessage.d(TAG, "$CALL_UI onGroupProfileUpdated groupJid:$groupJid")
         updateUserDetailsUpdatedInCall(groupJid)
     }
+
+    fun checkAndRequestFullScreenPermission() {
+        if(!ChatUtils.checkFullScreenNotificationPermissionEnabled()){
+            com.contusfly.utils.LogMessage.d(TAG,"#fullscreen fullScreenNotificationPermission requesting!!")
+            if(!SharedPreferenceManager.getBoolean(Constants.ASK_FULL_SCREEN_INTENT_PERMISSION)) {
+                MediaPermissions.requestFullScreenNotificationPermission(
+                    this,
+                    permissionAlertDialog,
+                    fullScreenNotificationPermissionLauncher,isCall = true)
+            }
+
+        } else {
+            com.contusfly.utils.LogMessage.d(TAG,"#fullscreen fullScreenNotificationPermission enabled!!")
+        }
+    }
+
+    private val fullScreenNotificationPermissionLauncher = registerForActivityResult(
+        ActivityResultContracts.RequestMultiplePermissions()) { _ ->
+        if(ChatUtils.checkFullScreenNotificationPermissionEnabled()){
+            com.contusfly.utils.LogMessage.d(TAG,"#fullscreen fullScreenNotificationPermission Launcher enabled!!")
+        }
+    }
 }

app/src/main/java/com/contusfly/utils/ChatUtils.kt

@@ -157,6 +157,16 @@ object ChatUtils {
         }
     }
 
+    fun checkFullScreenNotificationPermissionEnabled(): Boolean {
+        val minSdk34 = Build.VERSION.SDK_INT > Build.VERSION_CODES.TIRAMISU
+        var needToRequestFullScreenPermission = minSdk34
+        if(needToRequestFullScreenPermission){
+            return CallManager.canUseFullScreenIntent()
+        }
+        return  minSdk34
+    }
+
+
     fun checkNotificationPermission(context: Context, permission: String): Boolean {
         return MediaPermissions.isPermissionAllowed(context, permission)
     }

app/src/main/java/com/contusfly/utils/Constants.kt

@@ -141,8 +141,8 @@ class Constants {
         const val EMAIL = "email"
         const val ASK_PERMISSION = "ask_permission"
         const val USER_PROFILE_NAME = "profile_name"
-        const val EMAIL_PATTERN = ("^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@"
-                + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,3})$")
+        const val EMAIL_PATTERN = ("^[_A-Za-z0-9-%+!$&#\\+]+(\\.[_A-Za-z0-9-%+!$&#\\+]+)*@"
+                + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,6})$")
         const val FROM_SETTINGS_PROFILE = "from_settings_profile"
         const val FROM_LOGIN_PROFILE = "from_login_profile"
         const val REGISTER_END_POINT = "/api/v1/sandbox/register"
@@ -426,5 +426,10 @@ class Constants {
         const val MAX_DOCUMENT_UPLOAD_SIZE = 2048 // 2 GB
         const val MAX_AUDIO_SIZE_LIMIT = 2048 // 2 GB
 
+        //Full Screen Intent Permission
+        const val ASK_FULL_SCREEN_INTENT_PERMISSION = "ask_full_screen_notification_permission"
+        const val FULLSCREEN_NOTIFICATION_PERMISSION_ASKED = "fullscreen_notification_permission_asked_before"
+
+
     }
 }

app/src/main/java/com/contusfly/utils/MediaPermissions.kt

@@ -2,19 +2,29 @@ package com.contusfly.utils
 
 import android.Manifest
 import android.app.Activity
+import android.app.NotificationManager
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
 import android.net.Uri
 import android.os.Build
 import android.os.Build.VERSION.SDK_INT
+import android.os.RemoteException
 import android.provider.Settings
+import android.util.Log
+import android.view.LayoutInflater
 import android.view.View
+import android.view.WindowManager
 import androidx.activity.result.ActivityResultLauncher
+import androidx.annotation.RequiresApi
+import androidx.appcompat.app.AlertDialog
 import androidx.core.app.ActivityCompat
 import androidx.core.content.ContextCompat
+import androidx.viewbinding.ViewBinding
 import com.mirrorflysdk.flycall.webrtc.api.CallManager
 import com.contusfly.R
+import com.contusfly.chat.AndroidUtils
+import com.contusfly.databinding.NotificationPermissionDialogBinding
 import com.contusfly.interfaces.PermissionDialogListener
 import com.contusfly.views.PermissionAlertDialog
 import com.google.android.material.snackbar.Snackbar
@@ -1204,4 +1214,177 @@ object MediaPermissions {
             )
         }
     }
+
+
+    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+    private fun isFullScreenNotificationPermissionNotEnabled(activity: Activity):Boolean{
+        val notificationManager =  activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        var canUseFullScreenIntent = false
+        try {
+            canUseFullScreenIntent =  notificationManager.canUseFullScreenIntent()
+        } catch (e: RemoteException) {
+            LogMessage.d("MediaPermissions", "isFullScreenNotificationPermissionNotEnabled: exception")
+            e.printStackTrace()
+        }
+        LogMessage.d("MediaPermissions", "#fullscreen isFullScreenNotificationPermissionNotEnabled: $canUseFullScreenIntent")
+        return canUseFullScreenIntent
+    }
+
+    fun requestFullScreenNotificationPermission(
+        activity: Activity,
+        permissionAlertDialog: PermissionAlertDialog,
+        permissionsLauncher: ActivityResultLauncher<Array<String>>,
+        isCall: Boolean = false,
+        permissionDialogListener: PermissionDialogListener? = null,
+    ) {
+
+        if (SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE && !isFullScreenNotificationPermissionNotEnabled(activity)) {
+            val permissionsToRequest = mutableListOf<String>()
+            permissionsToRequest.add(Manifest.permission.USE_FULL_SCREEN_INTENT)
+            if (permissionsToRequest.isNotEmpty()) {
+                when {
+                    ActivityCompat.shouldShowRequestPermissionRationale(
+                        activity,
+                        Manifest.permission.USE_FULL_SCREEN_INTENT
+                    ) -> {
+                        if (isCall) {
+
+                            fullScreenNotificationDialogShow(activity)
+
+                        } else {
+                            showPermissionPopUpForFullScreenNotification(
+                                permissionsLauncher,
+                                permissionsToRequest,
+                                permissionAlertDialog,
+                                isCall,
+                                permissionDialogListener,activity
+                            )
+                        }
+                    }
+
+                    SharedPreferenceManager.getBoolean(Constants.FULLSCREEN_NOTIFICATION_PERMISSION_ASKED) -> {
+                        fullScreenNotificationPermissionAsked(activity, permissionAlertDialog, isCall, permissionDialogListener)
+                    }
+
+                    else -> {
+                        showPermissionPopUpForFullScreenNotification(
+                            permissionsLauncher,
+                            permissionsToRequest,
+                            permissionAlertDialog,
+                            isCall,
+                            permissionDialogListener,activity
+                        )
+                    }
+                }
+            }
+        }
+
+    }
+    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+    private fun fullScreenNotificationDialogShow(activity: Activity) {
+
+        try {
+            var dialogBinding: ViewBinding? = null
+            var dialogBuilder: AlertDialog.Builder
+            dialogBuilder = AlertDialog.Builder(activity, R.style.TrasparentAlertDialog)
+            val inflater: LayoutInflater = activity.layoutInflater
+            dialogBinding = NotificationPermissionDialogBinding.inflate(inflater)
+            dialogBuilder.apply {
+                setCancelable(false)
+                setView((dialogBinding)!!.root)
+            }
+            val alertDialog = dialogBuilder.create()
+            alertDialog.show()
+            alertDialogWidth(activity,alertDialog)
+            dialogBinding.closeIcon.visibility = View.INVISIBLE
+            dialogBinding.titleTv.text = activity.resources.getString(R.string.notification_full_screen_title)
+            dialogBinding.dialogDescription.text = activity.resources.getString(R.string.notification_full_intent_permission_denied_alert_label)
+            dialogBinding.turnOnTv.setOnClickListener {
+                SharedPreferenceManager.setBoolean(Constants.ASK_FULL_SCREEN_INTENT_PERMISSION, true)
+                openSettingsForFullScreenNotificationPermissionWithoutSmackBar(activity)
+                alertDialog.dismiss()
+            }
+
+            dialogBinding.notNowTv.setOnClickListener {
+                SharedPreferenceManager.setBoolean(Constants.ASK_FULL_SCREEN_INTENT_PERMISSION, true)
+                alertDialog.dismiss()
+            }
+
+        } catch (e:Exception) {
+            Log.e("TAG", "showPermissionInstructionDialog: $e")
+        }
+
+    }
+
+    private fun alertDialogWidth(activity: Activity, alertDialog: AlertDialog) {
+        val layoutParams = WindowManager.LayoutParams()
+        layoutParams.copyFrom(alertDialog.window!!.attributes)
+        layoutParams.width = (AndroidUtils.getScreenWidth(activity) * 0.80).toInt()
+        alertDialog.window!!.attributes = layoutParams
+    }
+
+    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+    private fun openSettingsForFullScreenNotificationPermissionWithoutSmackBar(activity: Activity) {
+        val intent = Intent(
+            Settings.ACTION_MANAGE_APP_USE_FULL_SCREEN_INTENT,
+            Uri.fromParts("package", activity.packageName, null)
+        )
+        intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
+        intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY)
+        intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
+        activity.startActivity(intent)
+    }
+
+    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+    private fun showPermissionPopUpForFullScreenNotification(
+        permissionsLauncher: ActivityResultLauncher<Array<String>>,
+        permissionsToRequest: MutableList<String>,
+        permissionAlertDialog: PermissionAlertDialog,
+        isCall: Boolean,
+        permissionDialogListener: PermissionDialogListener?,
+        activity: Activity
+    ) {
+        if(isCall) {
+            SharedPreferenceManager.setBoolean(Constants.FULLSCREEN_NOTIFICATION_PERMISSION_ASKED, true)
+            fullScreenNotificationDialogShow(activity)
+        } else {
+            permissionAlertDialog.showPermissionInstructionDialog(PermissionAlertDialog.FULLSCREEN_NOTIFICATION_PERMISSION_DENIED,
+                object : PermissionDialogListener {
+                    override fun onPositiveButtonClicked() {
+                        SharedPreferenceManager.setBoolean(Constants.FULLSCREEN_NOTIFICATION_PERMISSION_ASKED, true)
+                        permissionsLauncher.launch(permissionsToRequest.toTypedArray())
+                    }
+
+                    override fun onNegativeButtonClicked() {
+                        permissionDialogListener?.onNegativeButtonClicked()
+                    }
+                })
+        }
+
+    }
+
+    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+    private fun fullScreenNotificationPermissionAsked(
+        activity: Activity,
+        permissionAlertDialog: PermissionAlertDialog,
+        isCall: Boolean,
+        permissionDialogListener: PermissionDialogListener?,
+    ) {
+        if (isCall) {
+            fullScreenNotificationDialogShow(activity)
+        } else {
+            permissionAlertDialog.showPermissionInstructionDialog(
+                PermissionAlertDialog.FULLSCREEN_NOTIFICATION_PERMISSION_DENIED,
+                object : PermissionDialogListener {
+                    override fun onPositiveButtonClicked() {
+                        openSettingsForFullScreenNotificationPermissionWithoutSmackBar(activity)
+                    }
+
+                    override fun onNegativeButtonClicked() {
+                        permissionDialogListener?.onNegativeButtonClicked()
+                    }
+                }
+            )
+        }
+    }
 }

app/src/main/java/com/contusfly/views/PermissionAlertDialog.kt

@@ -141,5 +141,7 @@ class PermissionAlertDialog(private var activity: Activity) {
         const val VIDEO_CALL_PERMISSION_DENIED = "video_call_permission_denied"
         const val NOTIFCATION_PERMISSION_DENIED = "notification_permission_denied"
         const val NOTIFICATION_LOCKED_STATE_PERMISSION_DENIED = "notification_permission_locked_state_denied"
+        const val FULLSCREEN_NOTIFICATION_PERMISSION_DENIED = "fullscreen_notification_permission_denied"
+
     }
 }