From 203d67da05f167eab9cc24044862d61c14dba704 Mon Sep 17 00:00:00 2001
From: Girish Suragani <girish.suragani@navi.com>
Date: Thu, 26 Oct 2023 18:08:00 +0530
Subject: [PATCH] Merge 1.0.4 version to master (#17)

Co-authored-by: Sayed Owais Ali <sayed.owais@navi.com>
---
 app/src/main/AndroidManifest.xml              |   2 +-
 .../demo/AlfredNetworkFailureReceiver.kt      |  40 +
 .../java/com/alfred/demo/MainApplication.kt   |  82 +-
 .../com/alfred/demo/activity/DemoActivity.kt  |  23 -
 .../com/alfred/demo/activity/MainActivity.kt  |   2 +-
 .../com/alfred/demo/activity/SWWActivity.kt   |  57 +
 app/src/main/res/layout/activity_demo.xml     |  11 -
 app/src/main/res/layout/activity_main.xml     |   2 +-
 app/src/main/res/layout/activity_sww.xml      |  21 +
 navi-alfred/build.gradle                      |   3 +-
 .../main/java/com/navi/alfred/AlfredConfig.kt |  34 +-
 .../java/com/navi/alfred/AlfredManager.kt     | 980 +++---------------
 .../navi/alfred/callbacks/NetworkCallback.kt  |  11 -
 .../com/navi/alfred/model/ErrorMessage.kt     |   8 +-
 .../com/navi/alfred/model/SessionRequest.kt   |  13 +-
 .../alfred/network/AlfredNetworkRepository.kt |  16 +-
 .../alfred/network/AlfredRetrofitProvider.kt  |  28 +-
 .../alfred/network/AlfredRetrofitService.kt   |  11 +-
 .../navi/alfred/network/model/RequestInfo.kt  |  11 +
 .../com/navi/alfred/utils/AlfredConstants.kt  |  15 +-
 .../java/com/navi/alfred/utils/CommonUtils.kt |  32 +
 .../navi/alfred/utils/CruiseConfigUtils.kt    |  81 ++
 .../navi/alfred/utils/DeviceMetricsUtils.kt   | 146 +++
 .../java/com/navi/alfred/utils/EventUtils.kt  | 278 +++++
 .../com/navi/alfred/utils/MaskingUtils.kt     |  25 +
 .../com/navi/alfred/utils/NetworkUtils.kt     |  10 +-
 .../com/navi/alfred/utils/ScreenNameUtils.kt  |  59 ++
 .../com/navi/alfred/utils/ScreenShotUtils.kt  | 312 ++++++
 .../java/com/navi/alfred/utils/UploadUtils.kt | 144 +++
 .../navi/alfred/utils/UserBehaviourUtils.kt   |  47 +
 .../main/java/com/navi/alfred/utils/Utils.kt  | 452 --------
 .../java/com/navi/alfred/utils/ZipUtils.kt    | 222 ++++
 .../com/navi/alfred/worker/SyncDataTask.kt    |   7 +-
 .../navi/alfred/worker/UploadFileWorker.kt    |   3 +-
 .../src/main/res/layout/anr_screen.xml        |  20 +
 .../main/res/layout/app_background_screen.xml |  21 +
 .../src/main/res/layout/crash_screen.xml      |  20 +
 .../main/res/layout/third_party_screen.xml    |  36 +
 navi-alfred/src/main/res/values/colors.xml    |   5 +
 navi-alfred/src/main/res/values/strings.xml   |   7 +
 40 files changed, 1856 insertions(+), 1441 deletions(-)
 create mode 100644 app/src/main/java/com/alfred/demo/AlfredNetworkFailureReceiver.kt
 delete mode 100644 app/src/main/java/com/alfred/demo/activity/DemoActivity.kt
 create mode 100644 app/src/main/java/com/alfred/demo/activity/SWWActivity.kt
 delete mode 100644 app/src/main/res/layout/activity_demo.xml
 create mode 100644 app/src/main/res/layout/activity_sww.xml
 delete mode 100644 navi-alfred/src/main/java/com/navi/alfred/callbacks/NetworkCallback.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/network/model/RequestInfo.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/CommonUtils.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/CruiseConfigUtils.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/DeviceMetricsUtils.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/EventUtils.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/MaskingUtils.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/ScreenNameUtils.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/ScreenShotUtils.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/UploadUtils.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/UserBehaviourUtils.kt
 delete mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/Utils.kt
 create mode 100644 navi-alfred/src/main/java/com/navi/alfred/utils/ZipUtils.kt
 create mode 100644 navi-alfred/src/main/res/layout/anr_screen.xml
 create mode 100644 navi-alfred/src/main/res/layout/app_background_screen.xml
 create mode 100644 navi-alfred/src/main/res/layout/crash_screen.xml
 create mode 100644 navi-alfred/src/main/res/layout/third_party_screen.xml
 create mode 100644 navi-alfred/src/main/res/values/colors.xml
 create mode 100644 navi-alfred/src/main/res/values/strings.xml

diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index ed64060..de677e9 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -25,7 +25,7 @@
         </activity>
 
         <activity
-            android:name=".activity.DemoActivity"
+            android:name=".activity.SWWActivity"
             android:exported="true"
             android:theme="@style/Theme.AppCompat.Light" />
     </application>
diff --git a/app/src/main/java/com/alfred/demo/AlfredNetworkFailureReceiver.kt b/app/src/main/java/com/alfred/demo/AlfredNetworkFailureReceiver.kt
new file mode 100644
index 0000000..7d46535
--- /dev/null
+++ b/app/src/main/java/com/alfred/demo/AlfredNetworkFailureReceiver.kt
@@ -0,0 +1,40 @@
+package com.alfred.demo
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import com.navi.alfred.model.ErrorMessage
+import com.navi.alfred.network.model.RequestInfo
+import com.navi.alfred.utils.AlfredConstants.BROADCAST_ACTION_TYPE
+import com.navi.alfred.utils.AlfredConstants.BROADCAST_ERROR_MESSAGE
+import com.navi.alfred.utils.AlfredConstants.BROADCAST_EXCEPTION
+import com.navi.alfred.utils.AlfredConstants.BROADCAST_REQUEST
+import android.widget.Toast
+import com.navi.alfred.utils.log
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class AlfredNetworkFailureReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context?, intent: Intent?) {
+        if (intent?.action == BROADCAST_ACTION_TYPE) {
+            try {
+                val exception = intent.getSerializableExtra(BROADCAST_EXCEPTION)
+                val request = intent.getParcelableExtra<RequestInfo>(BROADCAST_REQUEST)
+                val errorMessage = intent.getParcelableExtra<ErrorMessage>(BROADCAST_ERROR_MESSAGE)
+
+                if (exception is Exception) {
+                    CoroutineScope(Dispatchers.IO).launch {
+                        Log.d(
+                            "AlfredNetworkFailure",
+                            "Network Failure exception = $exception, request = $request, errorMessage = $errorMessage"
+                        )
+                    }
+                }
+            } catch (e: Exception) {
+                e.log()
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/com/alfred/demo/MainApplication.kt b/app/src/main/java/com/alfred/demo/MainApplication.kt
index e569533..3d9ba35 100644
--- a/app/src/main/java/com/alfred/demo/MainApplication.kt
+++ b/app/src/main/java/com/alfred/demo/MainApplication.kt
@@ -2,12 +2,10 @@ package com.alfred.demo
 
 import android.app.Activity
 import android.app.Application
+import android.content.IntentFilter
 import android.os.Bundle
 import android.util.Log
-import android.view.LayoutInflater
-import android.view.View
-import androidx.appcompat.widget.AppCompatTextView
-import com.alfred.demo.activity.DemoActivity
+import com.alfred.demo.activity.SWWActivity
 import com.alfred.demo.activity.MainActivity
 import com.navi.alfred.AlfredConfig
 import com.navi.alfred.AlfredManager
@@ -17,13 +15,10 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import com.github.anrwatchdog.ANRWatchDog
-import com.navi.alfred.callbacks.NetworkCallback
-import com.navi.alfred.model.ErrorMessage
-import com.navi.alfred.network.AlfredRetrofitProvider
-import okhttp3.Request
-import okhttp3.Response
+import com.navi.alfred.AlfredManager.isAlfredRecordingEnabled
+import com.navi.alfred.utils.AlfredConstants.BROADCAST_ACTION_TYPE
 
-class MainApplication : Application(), Application.ActivityLifecycleCallbacks, NetworkCallback {
+class MainApplication : Application(), Application.ActivityLifecycleCallbacks {
     private var appForegroundCounter: Int = 0
 
     override fun onCreate() {
@@ -53,13 +48,8 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, N
                 "LINE_NUMBER" to it.cause?.stackTrace?.get(0)?.lineNumber.toString(),
                 "APP_IN_FOREGROUND" to isAppInForeground().toString()
             )
-            if (AlfredManager.config.getAlfredStatus() && AlfredManager.config.getAnrEnableStatus()) {
-                anrEventProperties["STACK_TRACE"] = it.cause?.stackTrace?.get(0).toString()
-                val anrView =
-                    LayoutInflater.from(applicationContext).inflate(R.layout.anr_screen, null)
-                AlfredManager.measureInflatedView(anrView)
-                AlfredManager.handleAnrEvent(anrEventProperties, anrView)
-            }
+            anrEventProperties["STACK_TRACE"] = it.cause?.stackTrace?.get(0).toString()
+            AlfredManager.handleAnrEvent(anrEventProperties)
         }.start()
 
         // Crash Reporting to backend
@@ -76,15 +66,10 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, N
                     "LINE_NUMBER" to exception.stackTrace[0]?.lineNumber.toString(),
                     "APP_IN_FOREGROUND" to isAppInForeground().toString()
                 )
-                if (AlfredManager.config.getAlfredStatus() && AlfredManager.config.getCrashEnableStatus()) {
-                    exception.stackTrace[0]?.let { stackTraceElement ->
-                        crashEventProperties["STACK_TRACE"] = stackTraceElement.toString()
-                    }
-                    val crashView =
-                        LayoutInflater.from(applicationContext).inflate(R.layout.crash_screen, null)
-                    AlfredManager.measureInflatedView(crashView)
-                    AlfredManager.handleCrashEvent(crashEventProperties, crashView.rootView)
+                exception.stackTrace[0]?.let { stackTraceElement ->
+                    crashEventProperties["STACK_TRACE"] = stackTraceElement.toString()
                 }
+                AlfredManager.handleCrashEvent(crashEventProperties)
             } finally {
                 defaultHandler?.uncaughtException(thread, exception)
             }
@@ -110,13 +95,7 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, N
     override fun onActivityStopped(activity: Activity) {
         appForegroundCounter--
         if (appForegroundCounter == 0) {
-            if (AlfredManager.config.getAlfredStatus() && AlfredManager.config.getEnableRecordingStatus()) {
-                val appBackgroundView =
-                    LayoutInflater.from(this)
-                        .inflate(R.layout.app_background_screen, null)
-                AlfredManager.measureInflatedView(appBackgroundView)
-                AlfredManager.stopRecording(appBackgroundView)
-            }
+            AlfredManager.stopRecording()
         }
     }
 
@@ -127,29 +106,23 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, N
     }
 
     private fun startAlfredRecording(activity: Activity) {
-        if (AlfredManager.config.getAlfredStatus() && AlfredManager.config.getEnableRecordingStatus()) {
-            var screenName: kotlin.String? = null
-            var moduleName: kotlin.String? = null
-            var thirdPartyScreenView: View? = null
+        if (isAlfredRecordingEnabled()) {
+            val screenName: String?
+            val moduleName: String?
             when (activity) {
                 is MainActivity -> {
                     screenName = "MainActivity"
                     moduleName = "Demo App"
                 }
 
-                is DemoActivity -> {
-                    screenName = "DemoActivity"
+                is SWWActivity -> {
+                    screenName = "SWWActivity"
                     moduleName = "Demo App"
                 }
 
                 else -> {
                     screenName = AlfredConstants.THIRD_PARTY_SCREEN
                     moduleName = AlfredConstants.THIRD_PARTY_MODULE
-                    thirdPartyScreenView = LayoutInflater.from(applicationContext)
-                        .inflate(R.layout.third_party_screen, null)
-                    AlfredManager.measureInflatedView(thirdPartyScreenView)
-                    thirdPartyScreenView.findViewById<AppCompatTextView>(R.id.tv_third_party_name).text =
-                        "${activity.localClassName}"
                 }
             }
             try {
@@ -158,7 +131,6 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, N
                     activity.window.decorView.rootView,
                     screenName,
                     moduleName,
-                    thirdPartyScreenView,
                     onSessionIdGenerated = { sessionId ->
                         Log.d("Alfred", "Alfred Session ID: $sessionId")
                     }
@@ -175,14 +147,16 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, N
 
     private fun getAlfredCruiseInfo() {
         Log.d("Alfred", "Alfred - getAlfredCruiseInfo started")
+        val appNetworkReceiver = AlfredNetworkFailureReceiver()
+        val intentFilter = IntentFilter(BROADCAST_ACTION_TYPE)
+        registerReceiver(appNetworkReceiver, intentFilter)
         CoroutineScope(Dispatchers.IO).launch {
             try {
                 Log.d(
                     "Alfred",
                     "Alfred - getAlfredCruiseInfo started inside try thread = ${Thread.currentThread().name}"
                 )
-                AlfredManager.getCruiseConfig(cruiseApiSuccessful = { response ->
-                    AlfredRetrofitProvider.setNetworkCallback(this@MainApplication)
+                AlfredManager.getAlfredCruiseInfo(cruiseApiSuccessful = { response ->
                     Log.d(
                         "Alfred",
                         "Alfred - getAlfredCruiseInfo cruiseApiSuccessful h response = $response"
@@ -194,20 +168,4 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, N
             }
         }
     }
-
-    override fun onNetworkRequest(request: okhttp3.Request?) {
-        Log.d("Alfred", "Alfred - onNetworkRequest request = $request")
-    }
-
-    override fun onNetworkSuccess(response: Response?) {
-        Log.d("Alfred", "Alfred - onNetworkSuccess response = $response")
-    }
-
-    override fun onNetworkFailure(
-        exception: Exception,
-        errorMessage: ErrorMessage,
-        request: Request
-    ) {
-        Log.d("Alfred", "Alfred - onNetworkFailure exception = $exception request = $request")
-    }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/alfred/demo/activity/DemoActivity.kt b/app/src/main/java/com/alfred/demo/activity/DemoActivity.kt
deleted file mode 100644
index 1114b06..0000000
--- a/app/src/main/java/com/alfred/demo/activity/DemoActivity.kt
+++ /dev/null
@@ -1,23 +0,0 @@
-package com.alfred.demo.activity
-
-import android.os.Bundle
-import android.view.MotionEvent
-import androidx.appcompat.app.AppCompatActivity
-import com.alfred.demo.R
-import com.navi.alfred.AlfredManager
-
-class DemoActivity : AppCompatActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_demo)
-    }
-
-    override fun dispatchTouchEvent(ev: MotionEvent?): Boolean {
-        AlfredManager.handleTouchEvent(
-            ev,
-            screenName = "Demo Activity",
-            moduleName = "Alfred Demo App",
-        )
-        return super.dispatchTouchEvent(ev)
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/com/alfred/demo/activity/MainActivity.kt b/app/src/main/java/com/alfred/demo/activity/MainActivity.kt
index 8c12858..bbf2bd3 100644
--- a/app/src/main/java/com/alfred/demo/activity/MainActivity.kt
+++ b/app/src/main/java/com/alfred/demo/activity/MainActivity.kt
@@ -16,7 +16,7 @@ class MainActivity : AppCompatActivity() {
 
         val button = findViewById<Button>(R.id.button)
         button.setOnClickListener {
-            val intent = Intent(this, DemoActivity::class.java)
+            val intent = Intent(this, SWWActivity::class.java)
             startActivity(intent)
         }
     }
diff --git a/app/src/main/java/com/alfred/demo/activity/SWWActivity.kt b/app/src/main/java/com/alfred/demo/activity/SWWActivity.kt
new file mode 100644
index 0000000..ffa8312
--- /dev/null
+++ b/app/src/main/java/com/alfred/demo/activity/SWWActivity.kt
@@ -0,0 +1,57 @@
+package com.alfred.demo.activity
+
+import android.os.Bundle
+import android.view.MotionEvent
+import android.widget.Button
+import androidx.appcompat.app.AppCompatActivity
+import com.alfred.demo.R
+import com.navi.alfred.AlfredManager
+
+class SWWActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_sww)
+
+        val button = findViewById<Button>(R.id.sww_button)
+        button.setOnClickListener {
+            onSSWError(
+                "SWW Button Clicked",
+                "400",
+                "SWW Activity",
+                "Alfred Demo App",
+                400,
+                "WIFI"
+
+            )
+        }
+    }
+
+    override fun dispatchTouchEvent(ev: MotionEvent?): Boolean {
+        AlfredManager.handleTouchEvent(
+            ev,
+            screenName = "Demo Activity",
+            moduleName = "Alfred Demo App",
+        )
+        return super.dispatchTouchEvent(ev)
+    }
+
+    private fun onSSWError(
+        reason: String?,
+        code: String?,
+        screenName: String?,
+        moduleName: String,
+        statusCode: Int?,
+        networkType: String?
+    ) {
+        val swwEventProperties =
+            mapOf(
+                Pair("module", moduleName),
+                Pair("reason", reason.orEmpty()),
+                Pair("code", code.orEmpty()),
+                Pair("screen_name", screenName.orEmpty()),
+                Pair("status_code", statusCode.toString()),
+                Pair("network_type", networkType.orEmpty())
+            )
+        AlfredManager.handleSWWEvent(swwEventProperties)
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/res/layout/activity_demo.xml b/app/src/main/res/layout/activity_demo.xml
deleted file mode 100644
index 18e087c..0000000
--- a/app/src/main/res/layout/activity_demo.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent">
-
-    <TextView
-        android:layout_width="match_parent"
-        android:layout_height="100dp"
-        android:text="Alfred Demo!" />
-
-</LinearLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
index 6799cc5..6e1b983 100644
--- a/app/src/main/res/layout/activity_main.xml
+++ b/app/src/main/res/layout/activity_main.xml
@@ -15,6 +15,6 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_gravity="center"
-        android:text="Open Demo Activity" />
+        android:text="Open SWW Screen" />
 
 </LinearLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/activity_sww.xml b/app/src/main/res/layout/activity_sww.xml
new file mode 100644
index 0000000..5e27654
--- /dev/null
+++ b/app/src/main/res/layout/activity_sww.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/white">
+
+    <Button
+        android:id="@+id/sww_button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:padding="10dp"
+        android:text="Trigger SWW"
+        android:textColor="@color/black"
+        android:textSize="14sp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>
\ No newline at end of file
diff --git a/navi-alfred/build.gradle b/navi-alfred/build.gradle
index fb0ddc8..bd66284 100644
--- a/navi-alfred/build.gradle
+++ b/navi-alfred/build.gradle
@@ -3,9 +3,10 @@ plugins {
     id 'org.jetbrains.kotlin.android'
     id 'kotlin-kapt'
     id 'maven-publish'
+    id 'kotlin-parcelize'
 }
 
-def VERSION_NAME = "1.0.3"
+def VERSION_NAME = "1.0.4"
 
 android {
     namespace 'com.navi.alfred'
diff --git a/navi-alfred/src/main/java/com/navi/alfred/AlfredConfig.kt b/navi-alfred/src/main/java/com/navi/alfred/AlfredConfig.kt
index 7bc5367..4e930e8 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/AlfredConfig.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/AlfredConfig.kt
@@ -10,6 +10,9 @@ package com.navi.alfred
 import android.os.Build
 import android.provider.Settings
 import android.text.TextUtils
+import com.navi.alfred.AlfredManager.applicationContext
+import com.navi.alfred.model.CruiseAttributes
+import com.navi.alfred.model.DeviceAttributes
 import com.navi.alfred.utils.AlfredConstants
 import com.navi.alfred.utils.getCarrierName
 import com.navi.alfred.utils.getNetworkType
@@ -27,7 +30,6 @@ data class AlfredConfig(
     private var advertisingId: String? = null,
     private var latitude: Double? = null,
     private var longitude: Double? = null,
-    private var userId: String? = null,
     private var alfredEventId: String = "",
     private var eventStartRecordingTime: Long? = null,
     private var nextEventStartRecordingTime: Long? = null,
@@ -36,13 +38,9 @@ data class AlfredConfig(
     private var enableRecording: Boolean = false,
     private var enableAnr: Boolean = false,
     private var enableCrash: Boolean = false,
-    var cpuUsageBeforeEventStart: Float? = null,
-    var memoryUsageBeforeEventStart: Float? = null,
-    var storageUsageBeforeEventStart: Float? = null,
     private var cpuEnableStatus: Boolean = false,
     private var memoryEnableStatus: Boolean = false,
     private var metricsApiEnableStatus: Boolean = false,
-    var batteryPercentageBeforeEventStart: Float? = null,
     private var disableScreenList: List<String>? = null,
     private var maskingEnabledScreenList: List<String>? = null,
     private var disableModuleList: List<String>? = null,
@@ -55,7 +53,13 @@ data class AlfredConfig(
     private var phoneNumber: String? = null,
     private var agentEmailId: String? = null,
     private var codePushVersion: String? = null,
-    private var apiKey: String = ""
+    private var apiKey: String = "",
+    private var userId: String? = null,
+    internal var cpuUsageBeforeEventStart: Float? = null,
+    internal var memoryUsageBeforeEventStart: Float? = null,
+    internal var storageUsageBeforeEventStart: Float? = null,
+    internal var batteryPercentageBeforeEventStart: Float? = null,
+    internal var cruiseAttributes: CruiseAttributes = CruiseAttributes()
 ) {
     constructor(appName: String, appVersionCode: String, appVersionName: String, flavor: String, apiKey: String) : this(
         appVersionCode = appVersionCode,
@@ -149,6 +153,8 @@ data class AlfredConfig(
 
     fun getNetworkType(): String = getNetworkType(AlfredManager.applicationContext)
 
+    fun getNetworkStrength(): Float = com.navi.alfred.utils.getNetworkStrength(AlfredManager.applicationContext)
+
     fun getBatteryPercentage(): Float =
         com.navi.alfred.utils.getBatteryPercentage(AlfredManager.applicationContext)
 
@@ -191,6 +197,8 @@ data class AlfredConfig(
 
     fun getMemoryUsage(): Float = com.navi.alfred.utils.getMemoryUsage()
 
+    fun getMemoryUsagePercentage(): Float = com.navi.alfred.utils.getMemoryUsagePercentage()
+
     fun getStorageUsage(): Float {
         val (totalSize, freeSize) =
             com.navi.alfred.utils.getStorageUsage(
@@ -301,4 +309,18 @@ data class AlfredConfig(
     fun setApiKey(apiKey: String) {
         this.apiKey = apiKey
     }
+
+    fun getCruiseAttributes(): CruiseAttributes = this.cruiseAttributes
+
+    fun setCruiseAttributes() {
+        this.cruiseAttributes = CruiseAttributes(
+            networkType = getNetworkType(applicationContext),
+            networkStrength = getNetworkStrength(),
+            deviceAttributes = DeviceAttributes(
+                battery = getBatteryPercentage(),
+                storage = getStorageUsage(),
+                memory = getMemoryUsage()
+            )
+        )
+    }
 }
diff --git a/navi-alfred/src/main/java/com/navi/alfred/AlfredManager.kt b/navi-alfred/src/main/java/com/navi/alfred/AlfredManager.kt
index 0222b2c..05c11eb 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/AlfredManager.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/AlfredManager.kt
@@ -15,123 +15,99 @@ import android.graphics.Canvas
 import android.util.Log
 import android.view.KeyEvent.ACTION_DOWN
 import android.view.KeyEvent.ACTION_UP
+import android.view.LayoutInflater
 import android.view.MotionEvent
 import android.view.View
-import android.view.ViewGroup
-import androidx.annotation.WorkerThread
-import androidx.fragment.app.Fragment
-import androidx.fragment.app.FragmentActivity
-import androidx.work.*
-import com.google.gson.Gson
-import com.google.gson.reflect.TypeToken
-import com.navi.alfred.callbacks.NetworkCallback
+import androidx.appcompat.widget.AppCompatTextView
 import com.navi.alfred.db.AlfredDatabase
 import com.navi.alfred.db.AlfredDatabaseHelper
 import com.navi.alfred.db.dao.ApiMetricDao
 import com.navi.alfred.db.dao.ScreenShotDao
 import com.navi.alfred.db.dao.ZipDetailsDao
-import com.navi.alfred.db.model.AnalyticsEvent
-import com.navi.alfred.db.model.ApiMetricHelper
-import com.navi.alfred.db.model.ScreenShotPathHelper
 import com.navi.alfred.db.model.ZipDetailsHelper
 import com.navi.alfred.dispatcher.AlfredDispatcher
-import com.navi.alfred.model.AnalyticsRequest
-import com.navi.alfred.model.BaseAttribute
-import com.navi.alfred.model.DeviceAttributes
-import com.navi.alfred.model.EventAttribute
-import com.navi.alfred.model.EventMetricRequest
-import com.navi.alfred.model.MetricAttribute
 import com.navi.alfred.model.NaviMotionEvent
-import com.navi.alfred.model.SessionEventAttribute
-import com.navi.alfred.model.SessionRequest
 import com.navi.alfred.model.WorkManagerFailureInputData
 import com.navi.alfred.network.AlfredNetworkRepository
 import com.navi.alfred.network.AlfredRetrofitProvider
 import com.navi.alfred.network.model.CruiseResponse
 import com.navi.alfred.utils.AlfredConstants
 import com.navi.alfred.utils.AlfredConstants.API_METRICS
-import com.navi.alfred.utils.AlfredConstants.CODE_API_BAD_REQUEST
 import com.navi.alfred.utils.AlfredConstants.CODE_API_SUCCESS
-import com.navi.alfred.utils.AlfredConstants.FRAGMENT_SCREEN_NAME
 import com.navi.alfred.utils.AlfredConstants.THIRD_PARTY_MODULE
-import com.navi.alfred.utils.AlfredConstants.ZIP_FILE_EXTENSION
-import com.navi.alfred.utils.AlfredConstants.INCREMENT_OF_ONE_MINUTE
 import com.navi.alfred.utils.ScreenShotStorageHelper
+import com.navi.alfred.utils.buildAppPerformanceEvent
+import com.navi.alfred.utils.buildEvent
+import com.navi.alfred.utils.captureBottomSheet
 import com.navi.alfred.utils.captureScreen
 import com.navi.alfred.utils.captureScreenshotOfCustomView
-import com.navi.alfred.utils.checkFileExists
-import com.navi.alfred.utils.clearScreenShot
-import com.navi.alfred.utils.combineScreenshots
+import com.navi.alfred.utils.checkDbBeforeStartRecording
 import com.navi.alfred.utils.createBitmapForView
+import com.navi.alfred.utils.getCruiseConfig
 import com.navi.alfred.utils.getTouchEvent
+import com.navi.alfred.utils.handleDeviceAttributes
+import com.navi.alfred.utils.handleScreenShot
 import com.navi.alfred.utils.insertScreenShotPathInDb
 import com.navi.alfred.utils.log
-import com.navi.alfred.utils.zip
+import com.navi.alfred.utils.measureInflatedView
+import com.navi.alfred.utils.startAnrCrashZipUpload
+import com.navi.alfred.utils.startSyncEvents
 import com.navi.alfred.worker.AddEventTask
 import com.navi.alfred.worker.AddMetricTask
-import com.navi.alfred.worker.UploadFileWorker
 import kotlinx.coroutines.*
 import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import okhttp3.MediaType.Companion.toMediaTypeOrNull
 import okhttp3.Request
-import okhttp3.RequestBody.Companion.asRequestBody
 import okhttp3.Response
-import java.io.File
-import java.lang.reflect.Type
 import java.util.Timer
 import java.util.TimerTask
-import java.util.UUID
 import java.util.concurrent.Executors
-import kotlin.concurrent.fixedRateTimer
-import java.lang.Long.min
 import java.lang.ref.WeakReference
 
 object AlfredManager {
 
-    lateinit var config: AlfredConfig
-    lateinit var applicationContext: Context
-    private var previousTouchEvent: NaviMotionEvent = NaviMotionEvent()
-    private val mutex = Mutex()
     private val coroutineDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
-    private val repository = AlfredNetworkRepository()
     private val completableJob = Job()
-    private var hasUploadFlowStarted: Boolean = false
-    private lateinit var alfredDataBase: AlfredDatabase
-    private lateinit var screenShotDao: ScreenShotDao
-    private lateinit var zipDetailsDao: ZipDetailsDao
-    private lateinit var apiMetricDao: ApiMetricDao
-    private const val imageThreshHoldValue: Int = 60
-    private const val imageSecondThreshHoldValue: Int = 100
+    private val exceptionHandler = CoroutineExceptionHandler { _, _ -> }
+    private var previousTouchEvent: NaviMotionEvent = NaviMotionEvent()
     private var screenShotCaptureDelay: Long = 1000L
-    private var isAppInBackground: Boolean = false
-    private var hasRecordingStarted: Boolean = false
-    var dialog: Dialog? = null
     private var reactBottomSheetView: WeakReference<View>? = null
-    private var timer: Timer? = null
     private var screenShotTimer: Timer? = null
     private var viewLayoutDelay: Long = 1000
-    private var currentScreenName: String? = null
-    private var currentModuleName: String? = null
-    private var sessionIdForCrash: String? = null
-    private var sessionStartRecordingTimeForCrash: Long? = null
-    private var eventStartRecordingTimeForCrash: Long? = null
-    val workFailureData: MutableList<WorkManagerFailureInputData> = mutableListOf()
-    private lateinit var zipFileDetails: List<ZipDetailsHelper>
-    private val exceptionHandler = CoroutineExceptionHandler { _, _ -> }
-    private val coroutineScope = CoroutineScope(Dispatchers.IO + completableJob + exceptionHandler)
-    private var retryCount: Int = 0
-    private var currentActivity: WeakReference<Activity>? = null
+    internal val mutex = Mutex()
+    internal val repository = AlfredNetworkRepository()
+    internal val coroutineScope = CoroutineScope(Dispatchers.IO + completableJob + exceptionHandler)
+    internal val workFailureData: MutableList<WorkManagerFailureInputData> = mutableListOf()
+    internal var config = AlfredConfig()
+    internal var hasUploadFlowStarted: Boolean = false
+    internal var isAppInBackground: Boolean = false
+    internal var hasRecordingStarted: Boolean = false
+    internal var currentScreenName: String? = null
+    internal var currentModuleName: String? = null
+    internal var sessionIdForCrash: String? = null
+    internal var sessionStartRecordingTimeForCrash: Long? = null
+    internal var eventStartRecordingTimeForCrash: Long? = null
+    internal var timer: Timer? = null
+    internal var retryCount: Int = 0
+    internal var currentActivity: WeakReference<Activity>? = null
+    internal lateinit var alfredDataBase: AlfredDatabase
+    internal lateinit var screenShotDao: ScreenShotDao
+    internal lateinit var zipDetailsDao: ZipDetailsDao
+    internal lateinit var apiMetricDao: ApiMetricDao
+    internal lateinit var zipFileDetails: List<ZipDetailsHelper>
+    internal lateinit var applicationContext: Context
+    internal const val imageThreshHoldValue: Int = 60
+    internal const val imageSecondThreshHoldValue: Int = 100
+    var dialog: Dialog? = null
 
     fun init(config: AlfredConfig, context: Context) {
         this.config = config
         this.applicationContext = context
         AlfredRetrofitProvider.init(applicationContext)
-        startSyncEvents(context)
-        alfredDataBase = AlfredDatabaseHelper.getAnalyticsDatabase(applicationContext)
-        this.screenShotDao = alfredDataBase.screenShotDao()
-        this.zipDetailsDao = alfredDataBase.zipDetailsDao()
-        this.apiMetricDao = alfredDataBase.apiMetricDao()
+        config.setCruiseAttributes()
+    }
+
+    fun isAlfredRecordingEnabled(): Boolean {
+        return config.getAlfredStatus() && config.getEnableRecordingStatus()
     }
 
     fun startRecording(
@@ -139,11 +115,9 @@ object AlfredManager {
         view: View,
         screenName: String? = null,
         moduleName: String,
-        thirdPartyScreenView: View? = null,
         activity: Activity? = null,
         onSessionIdGenerated: (sessionId: String) -> Unit
     ) {
-        currentActivity = WeakReference(activity)
         if (config.getEnableRecordingStatus().not()) {
             return
         }
@@ -155,6 +129,7 @@ object AlfredManager {
             config.setEventStartRecordingTime()
             handleDeviceAttributes()
         }
+        currentActivity = WeakReference(activity)
         setCurrentScreenName(screenName)
         currentModuleName = moduleName
         hasRecordingStarted = true
@@ -167,7 +142,13 @@ object AlfredManager {
                 override fun run() {
                     coroutineScope.launch(Dispatchers.IO) {
                         if (moduleName == THIRD_PARTY_MODULE) {
+                            currentScreenName = AlfredConstants.THIRD_PARTY_SCREEN
                             if (bmpForThirdPartySdkScreen == null) {
+                                val thirdPartyScreenView = LayoutInflater.from(applicationContext)
+                                    .inflate(R.layout.third_party_screen, null)
+                                measureInflatedView(thirdPartyScreenView)
+                                thirdPartyScreenView.findViewById<AppCompatTextView>(R.id.tv_third_party_name).text =
+                                    activity?.localClassName.toString()
                                 bmpForThirdPartySdkScreen =
                                     thirdPartyScreenView?.let { captureScreenshotOfCustomView(it) }
                             }
@@ -217,76 +198,35 @@ object AlfredManager {
         screenShotTimer?.schedule(timerTask, 0, screenShotCaptureDelay)
     }
 
-    private suspend fun handleScreenShot() {
-        if (
-            ScreenShotStorageHelper.images.size == imageThreshHoldValue ||
-            ScreenShotStorageHelper.images.size == imageSecondThreshHoldValue
-        ) {
-            toZip(screenShotDao.fetchScreenShotsPath(imageThreshHoldValue))
-        } else {
-            if (ScreenShotStorageHelper.images.size == 1) {
-                checkToStartZipUpload()
+    fun stopRecording() {
+        if (config.getAlfredStatus() && config.getEnableRecordingStatus()) {
+            isAppInBackground = true
+            hasRecordingStarted = false
+            screenShotTimer?.cancel()
+            val appBackgroundView =
+                LayoutInflater.from(applicationContext)
+                    .inflate(R.layout.app_background_screen, null)
+            measureInflatedView(appBackgroundView)
+            if (ScreenShotStorageHelper.images.size > 0) {
+                startAnrCrashZipUpload(appBackgroundView)
             }
         }
     }
 
-    private suspend fun checkToStartZipUpload() {
-        val zipFileName = config.getZipFileName().toString()
-        if (zipFileName.isNotEmpty()) {
-            if (checkFileExists(zipFileName, applicationContext) != null) {
-                if (!hasUploadFlowStarted) {
-                    hasUploadFlowStarted = true
-                    getPreSignedUrl(zipFileName)
-                }
-            }
-        }
-    }
-
-    private suspend fun captureBottomSheet(
-        view: View,
-        bottomSheetView: View,
-        context: Context,
-        screenName: String? = null,
-        rootCanvas: Canvas? = null,
-        rootBmp: Bitmap? = null,
-        moduleName: String? = null
-    ) {
-        if (config.getDisableDialogScreenShot()) {
-            return
-        }
-        if (bottomSheetView != null) {
-            val bottomSheetCanvasForBitmap = createBitmapForView(bottomSheetView)
-            val bottomSheetScreenShot =
-                captureScreen(
-                    bottomSheetView,
-                    context,
-                    true,
-                    screenName,
-                    coroutineScope,
-                    bottomSheetCanvasForBitmap?.first,
-                    bottomSheetCanvasForBitmap?.second,
-                    moduleName = moduleName
-                )
-            val backgroundScreenShot =
-                captureScreen(
-                    view,
-                    context,
-                    true,
-                    screenName,
-                    coroutineScope,
-                    rootCanvas,
-                    rootBmp,
-                    moduleName = moduleName
-                )
-            if (bottomSheetScreenShot != null && backgroundScreenShot != null) {
-                combineScreenshots(
-                    backgroundScreenShot,
-                    bottomSheetScreenShot,
-                    context,
-                    screenName,
-                    moduleName = moduleName,
-                    scope = coroutineScope
-                )
+    fun getAlfredCruiseInfo(cruiseApiSuccessful: (response: CruiseResponse) -> Unit) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                getCruiseConfig(cruiseApiSuccessful = { response ->
+                    Log.d("Alfred", "getAlfredCruiseInfo cruiseApiSuccessfulresponse = $response")
+                    cruiseApiSuccessful(response)
+                    startSyncEvents(applicationContext)
+                    alfredDataBase = AlfredDatabaseHelper.getAnalyticsDatabase(applicationContext)
+                    screenShotDao = alfredDataBase.screenShotDao()
+                    zipDetailsDao = alfredDataBase.zipDetailsDao()
+                    apiMetricDao = alfredDataBase.apiMetricDao()
+                })
+            } catch (e: Exception) {
+                e.log()
             }
         }
     }
@@ -299,552 +239,6 @@ object AlfredManager {
         reactBottomSheetView?.clear()
     }
 
-    private fun checkDbBeforeStartRecording() {
-        coroutineScope.launch(Dispatchers.IO) {
-            if (screenShotDao.getScreenShotCount() > 0) {
-                screenShotDao.deleteAllScreenShot()
-            }
-
-            if (zipDetailsDao.getZipFilesDetailsCount() > 0) {
-                zipFileDetails = zipDetailsDao.fetchAllZipFilesDetails()
-                zipFileDetails.forEachIndexed { index, DumpZipDetailsHelper ->
-                    if (
-                        checkFileExists(
-                            fileName = DumpZipDetailsHelper.zipFileName,
-                            applicationContext
-                        ) != null
-                    ) {
-                        getPreSignedUrl(DumpZipDetailsHelper.zipFileName, true, index)
-                    } else {
-                        zipDetailsDao.deleteZipFileDetail(DumpZipDetailsHelper.id)
-                    }
-                }
-            }
-        }
-    }
-
-    @JvmOverloads
-    fun measureInflatedView(view: View, width: Int = 1080, height: Int = 1920) {
-        view.layoutParams = ViewGroup.LayoutParams(width, height)
-        view.measure(
-            View.MeasureSpec.makeMeasureSpec(view.layoutParams.width, View.MeasureSpec.EXACTLY),
-            View.MeasureSpec.makeMeasureSpec(view.layoutParams.height, View.MeasureSpec.EXACTLY)
-        )
-        view.layout(0, 0, view.measuredWidth, view.measuredHeight)
-    }
-
-    fun getAlfredCruiseInfo(cruiseApiSuccessful: (response: CruiseResponse) -> Unit) {
-        CoroutineScope(Dispatchers.IO).launch {
-            try {
-                getCruiseConfig(cruiseApiSuccessful = {response ->
-                    Log.d("Alfred","getAlfredCruiseInfo cruiseApiSuccessfulresponse = $response")
-                    cruiseApiSuccessful(response)
-                })
-            } catch (e: Exception) {
-                e.log()
-            }
-        }
-    }
-
-    suspend fun getCruiseConfig(cruiseApiSuccessful: (response: CruiseResponse) -> Unit) {
-        val response =
-            repository.cruiseConfig(
-                AlfredConstants.DEFAULT_CRUISE_CONFIG_URL,
-                config.getAppVersionName(),
-                config.getAppVersionCode(),
-                config.getOsVersion(),
-                config.getDeviceId(),
-                config.getApiKey()
-            )
-        if (response.isSuccessful && response.code() == CODE_API_SUCCESS) {
-            try {
-                response.body()?.let { cruiseResponse ->
-                    setCruiseConfig(cruiseResponse)
-                    cruiseApiSuccessful(cruiseResponse)
-                }
-            } catch (e: Exception) {
-                e.log()
-            }
-        }
-    }
-
-    private fun setCruiseConfig(cruiseResponse: CruiseResponse) {
-        cruiseResponse.data.let { responseList ->
-            if (responseList.isNotEmpty()) {
-                val cruiseConfig = responseList.first()
-
-                cruiseConfig.source.let { source ->
-                    source.enable?.let { sourceConfig -> config.setAlfredStatus(sourceConfig) }
-                    source.recordingsConfig?.let { recordingConfig ->
-                        recordingConfig.enable?.let { enable ->
-                            config.setEnableRecordingStatus(enable)
-                        }
-                        recordingConfig.videoQuality?.let { videoQuality ->
-                            config.setVideoQuality(videoQuality)
-                        }
-                        recordingConfig.disableAnrRecording?.let { anrStatus ->
-                            config.setAnrEnableStatus(!anrStatus)
-                        }
-                        recordingConfig.disableCrashRecording?.let { crashStatus ->
-                            config.setCrashEnableStatus(!crashStatus)
-                        }
-                        recordingConfig.disableScreens?.let { disableScreen ->
-                            config.setDisableScreenList(disableScreen)
-                        }
-                        recordingConfig.maskingEnabledScreens?.let { maskingEnabledScreens ->
-                            config.setMaskingEnabledScreenList(maskingEnabledScreens)
-                        }
-                        recordingConfig.disableModules?.let { disableModuleList ->
-                            config.setDisableModuleList(disableModuleList)
-                        }
-                        recordingConfig.snapshotPerSecond?.let { snapShotPerSecond ->
-                            config.setSnapshotPerSecond(snapShotPerSecond)
-                        }
-                    }
-                    source.metricsConfig?.let { metricsConfig ->
-                        metricsConfig.disableMemoryMonitoring?.let { memory_monitor_status ->
-                            config.setMemoryEnableStatus(!memory_monitor_status)
-                        }
-                        metricsConfig.disableCpuMonitoring?.let { cpu_monitor_status ->
-                            config.setCpuEnableStatus(!cpu_monitor_status)
-                        }
-                        metricsConfig.disableApiPerformance?.let { api_monitor_status ->
-                            config.setApiMetricsEnableStatus(!api_monitor_status)
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    private suspend fun getPreSignedUrl(
-        zipFileName: String,
-        dumpFlow: Boolean = false,
-        index: Int? = null,
-        workManagerFlow: Boolean? = false
-    ) {
-        config.setAlfredEventId()
-        val bucketKey = config.getAlfredEventId().plus(ZIP_FILE_EXTENSION)
-        val response = repository.getPreSignedUrl(bucketKey, config.getApiKey())
-        if (response.isSuccessful && response.code() == CODE_API_SUCCESS) {
-            checkFileExists(zipFileName, applicationContext)?.let { file ->
-                response.body()?.data?.let {
-                    uploadFile(
-                        file,
-                        it,
-                        dumpFlow,
-                        index,
-                        zipFileName,
-                        workManagerFlow = workManagerFlow
-                    )
-                }
-            }
-        } else {
-            if (!dumpFlow) {
-                hasUploadFlowStarted = false
-                config.getEventStartRecordingTime()?.let { eventStartRecordingTime ->
-                    insertZipDetailsToDbForDumpingLater(
-                        config.getAlfredSessionId(),
-                        config.getSessionStartRecordingTime(),
-                        eventStartRecordingTime,
-                        zipFileName
-                    )
-                }
-                config.setEventStartRecordingTime(true)
-            }
-            if (workManagerFlow == true) {
-                uploadWorkManagerFailedZip()
-            }
-        }
-    }
-
-    private fun uploadWorkManagerFailedZip() {
-        if (workFailureData.size > 0) {
-            val inputData = workFailureData[0]
-            if (retryCount < 3) {
-                WorkManager.getInstance(applicationContext).cancelWorkById(inputData.id)
-                val requestData =
-                    Data.Builder()
-                        .putString(AlfredConstants.ALFRED_SESSION_ID, inputData.alfredSessionId)
-                        .putLong(
-                            AlfredConstants.SESSION_START_RECORDING_TIME,
-                            inputData.sessionStartRecordingTime
-                        )
-                        .putLong(
-                            AlfredConstants.EVENT_START_RECORDING_TIME,
-                            inputData.eventStartRecordingTime
-                        )
-                        .putString(
-                            AlfredConstants.SCREENSHOT_LIST,
-                            Gson().toJson(inputData.screenShots)
-                        )
-                        .build()
-                buildWorkManager(requestData)
-                retryCount += 1
-                workFailureData.removeAt(0)
-            } else {
-                retryCount = 0
-                WorkManager.getInstance(applicationContext).cancelWorkById(inputData.id)
-                workFailureData.removeAt(0)
-                insertZipDetailsToDbForDumpingLater(
-                    alfredSessionId = inputData.alfredSessionId.toString(),
-                    eventStartRecordingTime = inputData.eventStartRecordingTime,
-                    sessionStartRecordingTime = inputData.sessionStartRecordingTime,
-                    zipFileName = inputData.zipFileName
-                )
-            }
-        }
-    }
-
-    private fun checkAndInitiateFileUploadWorkManager() {
-        val screenShotList = screenShotDao.fetchAllScreenShotsPath()
-        screenShotDao.deleteAllScreenShot()
-        ScreenShotStorageHelper.clearAll()
-        isAppInBackground = false
-        hasRecordingStarted = false
-        config.clearZipFileName()
-        val requestData =
-            Data.Builder()
-                .putString(AlfredConstants.ALFRED_SESSION_ID, config.getAlfredSessionId())
-                .putLong(
-                    AlfredConstants.SESSION_START_RECORDING_TIME,
-                    config.getSessionStartRecordingTime()
-                )
-                .putLong(
-                    AlfredConstants.EVENT_START_RECORDING_TIME,
-                    config.getEventStartRecordingTime() ?: 0L
-                )
-                .putString(AlfredConstants.SCREENSHOT_LIST, Gson().toJson(screenShotList))
-                .build()
-        buildWorkManager(requestData)
-    }
-
-    private fun buildWorkManager(requestData: Data) {
-        val constraints =
-            Constraints.Builder()
-                .setRequiresBatteryNotLow(false)
-                .setRequiredNetworkType(NetworkType.CONNECTED)
-                .build()
-        val uniqueWorkName = "YOUR_UNIQUE_WORK_NAME"
-        val uniqueWorkStatus =
-            WorkManager.getInstance(applicationContext)
-                .getWorkInfosForUniqueWork(uniqueWorkName)
-                .get()
-        if (uniqueWorkStatus.isNullOrEmpty()) {
-            val uniqueWorkRequest =
-                OneTimeWorkRequestBuilder<UploadFileWorker>()
-                    .setConstraints(constraints)
-                    .setInputData(requestData)
-                    .build()
-            WorkManager.getInstance(applicationContext)
-                .beginUniqueWork(uniqueWorkName, ExistingWorkPolicy.KEEP, uniqueWorkRequest)
-                .enqueue()
-        } else {
-            val workRequest =
-                OneTimeWorkRequestBuilder<UploadFileWorker>()
-                    .setConstraints(constraints)
-                    .setInputData(requestData)
-                    .build()
-            WorkManager.getInstance(applicationContext).enqueue(workRequest)
-        }
-    }
-
-    private suspend fun uploadFile(
-        uploadFile: File,
-        url: String,
-        dumpFlow: Boolean = false,
-        index: Int? = null,
-        zipFileName: String,
-        workManagerFlow: Boolean? = false
-    ) {
-        val requestBody = uploadFile.asRequestBody("application/zip".toMediaTypeOrNull())
-        val uploadResponse = repository.uploadZipToS3(url, requestBody)
-        if (uploadResponse.isSuccessful && uploadResponse.code() == CODE_API_SUCCESS) {
-            uploadFile.delete()
-            sendAlfredSessionEvent(dumpFlow, index)
-        } else {
-            if (!dumpFlow) {
-                config.getEventStartRecordingTime()?.let { eventStartRecordingTime ->
-                    insertZipDetailsToDbForDumpingLater(
-                        config.getAlfredSessionId(),
-                        config.getSessionStartRecordingTime(),
-                        eventStartRecordingTime,
-                        zipFileName
-                    )
-                }
-                config.setEventStartRecordingTime(true)
-            }
-            if (workManagerFlow == true) {
-                uploadWorkManagerFailedZip()
-            }
-        }
-        if (!dumpFlow) {
-            hasUploadFlowStarted = false
-        }
-    }
-
-    private fun insertZipDetailsToDbForDumpingLater(
-        alfredSessionId: String,
-        sessionStartRecordingTime: Long,
-        eventStartRecordingTime: Long,
-        zipFileName: String
-    ) {
-        zipDetailsDao.insert(
-            data =
-            ZipDetailsHelper(
-                alfredSessionId = alfredSessionId,
-                sessionStartRecordingTime = sessionStartRecordingTime,
-                eventStartRecordingTime = eventStartRecordingTime,
-                zipFileName = zipFileName
-            )
-        )
-    }
-
-    private fun deleteScreenShot() {
-        try {
-            val screenShotPathList: List<ScreenShotPathHelper> =
-                if (screenShotDao.getScreenShotCount() >= imageThreshHoldValue) {
-                    screenShotDao.fetchScreenShotsPath(imageThreshHoldValue)
-                } else {
-                    screenShotDao.fetchAllScreenShotsPath()
-                }
-            clearScreenShot(screenShotPathList)
-            try {
-                if (isAppInBackground) {
-                    ScreenShotStorageHelper.clearAll()
-                    screenShotDao.deleteAllScreenShot()
-                    isAppInBackground = false
-                    hasRecordingStarted = false
-                } else {
-                    val idList = screenShotPathList.map { it.id }
-                    screenShotDao.deleteScreenShot(idList)
-                    ScreenShotStorageHelper.deleteKItems(idList.size)
-                }
-            } catch (e: Exception) {
-                e.log()
-            }
-        } catch (e: Exception) {
-            e.log()
-        }
-    }
-
-    suspend fun sendIngestMetric(): Boolean {
-        if (config.getAlfredStatus() && config.getMetricsApiEnableStatus()) {
-            mutex.withLock {
-                val metricEventList = apiMetricDao.fetchApiMetric(config.getEventBatchSize())
-                if (metricEventList.isNotEmpty()) {
-                    try {
-                        val detailsList = metricEventList.map { it.metric }
-                        val listType: Type =
-                            object : TypeToken<ArrayList<MetricAttribute?>?>() {}.type
-                        val events: ArrayList<MetricAttribute> =
-                            Gson().fromJson(detailsList.toString(), listType)
-                        if (events.size > 0) {
-                            val sessionId = events.first().sessionId
-                            val request =
-                                EventMetricRequest(
-                                    baseAttribute = BaseAttribute(sessionId = sessionId),
-                                    metricsAttribute = events
-                                )
-                            val response =
-                                repository.eventMetric(
-                                    AlfredConstants.DEFAULT_INGEST_METRIC_URL,
-                                    config.getApiKey(),
-                                    metricRequestBody = request
-                                )
-                            return if (
-                                (response.isSuccessful && response.code() == CODE_API_SUCCESS) or
-                                (response.code() == CODE_API_BAD_REQUEST)
-                            ) {
-                                apiMetricDao.deleteApiMetric(metricEventList.map { it.id })
-                                true
-                            } else {
-                                false
-                            }
-                        }
-                    } catch (e: Exception) {
-                        return false
-                    }
-                } else {
-                    return false
-                }
-            }
-            return false
-        }
-        return false
-    }
-
-    private fun startSyncEvents(applicationContext: Context) {
-        timer =
-            fixedRateTimer(
-                AlfredConstants.TIMER_THREAD_NAME,
-                false,
-                AlfredConstants.DEFAULT_INITIAL_DELAY,
-                config.getEventsDelayInMilliseconds()
-            ) {
-                runBlocking {
-                    AddMetricTask.resetEventCount()
-                    sendIngestMetric()
-                    AddEventTask.resetEventCount()
-                    sendEventsToServer(applicationContext)
-                }
-            }
-    }
-
-    suspend fun sendEventsToServer(applicationContext: Context): Boolean {
-
-        if (config.getAlfredStatus() && config.getEnableRecordingStatus()) {
-            mutex.withLock {
-                val db = AlfredDatabaseHelper.getAnalyticsDatabase(applicationContext)
-                val analyticsDao = db.analyticsDao()
-                val analyticsEvents = analyticsDao.fetchEvents(config.getEventBatchSize())
-
-                if (analyticsEvents.isNotEmpty()) {
-                    try {
-                        val detailsList = analyticsEvents.map { it.details }
-                        val listType: Type =
-                            object : TypeToken<ArrayList<EventAttribute?>?>() {}.type
-                        val events: ArrayList<EventAttribute> =
-                            Gson().fromJson(detailsList.toString(), listType)
-                        if (events.size > 0) {
-                            val sessionId = events.first().sessionId
-                            val request =
-                                AnalyticsRequest(
-                                    baseAttribute = BaseAttribute(sessionId = sessionId),
-                                    events = events
-                                )
-                            val response = repository.sendEvents(
-                                config.getPostUrl(),
-                                config.getApiKey(),
-                                request
-                            )
-                            return if (
-                                (response.isSuccessful && response.code() == CODE_API_SUCCESS) or
-                                (response.code() == CODE_API_BAD_REQUEST)
-                            ) {
-                                analyticsDao.deleteEvents(analyticsEvents.map { it.eventId })
-                                true
-                            } else {
-                                false
-                            }
-                        } else {
-                            false
-                        }
-                    } catch (e: Exception) {
-                        return false
-                    }
-                } else {
-                    return false
-                }
-            }
-            return false
-        }
-        return false
-    }
-
-    private fun sendAlfredSessionEvent(dumpFlow: Boolean = false, index: Int? = null) {
-        var request: SessionRequest? = null
-        if (dumpFlow) {
-            var clientTs: Long? = null
-            var sessionTimeStamp: Long? = null
-            var sessionId: String? = null
-            var eventEndTimeStamp: Long? = null
-            if (index != null) {
-                val zipFileDetail = zipFileDetails[index]
-                clientTs = zipFileDetail.eventStartRecordingTime
-                sessionTimeStamp = zipFileDetail.sessionStartRecordingTime
-                sessionId = zipFileDetail.alfredSessionId
-            } else {
-                clientTs = eventStartRecordingTimeForCrash
-                sessionTimeStamp = sessionStartRecordingTimeForCrash
-                sessionId = sessionIdForCrash
-            }
-
-            clientTs?.let {
-                eventEndTimeStamp =
-                    min(it.plus(INCREMENT_OF_ONE_MINUTE), config.getEventTimeStamp())
-            }
-
-            request =
-                SessionRequest(
-                    base_attribute =
-                    BaseAttribute(
-                        sessionId = sessionId,
-                        eventTimeStamp = config.getEventTimeStamp(),
-                        clientTs = clientTs,
-                        sessionTimeStamp = sessionTimeStamp,
-                        eventEndTimeStamp = eventEndTimeStamp
-                    ),
-                    session_upload_event_attributes =
-                    SessionEventAttribute(
-                        beginningDeviceAttributes = DeviceAttributes(),
-                        endDeviceAttributes = DeviceAttributes()
-                    )
-                )
-        } else {
-            val eventEndTimeStamp = config.getEventStartRecordingTime()
-                ?.let { min(it.plus(INCREMENT_OF_ONE_MINUTE), config.getEventTimeStamp()) }
-            request =
-                SessionRequest(
-                    base_attribute =
-                    BaseAttribute(
-                        sessionId = config.getAlfredSessionId(),
-                        eventTimeStamp = config.getEventTimeStamp(),
-                        clientTs = config.getEventStartRecordingTime(),
-                        eventEndTimeStamp = eventEndTimeStamp
-                    ),
-                    session_upload_event_attributes =
-                    SessionEventAttribute(
-                        beginningDeviceAttributes =
-                        DeviceAttributes(
-                            battery = config.batteryPercentageBeforeEventStart,
-                            cpu = config.cpuUsageBeforeEventStart,
-                            memory = config.memoryUsageBeforeEventStart,
-                            storage = config.storageUsageBeforeEventStart
-                        ),
-                        endDeviceAttributes =
-                        DeviceAttributes(
-                            battery = config.getBatteryPercentage(),
-                            cpu = config.getCpuUsage(),
-                            memory = config.getMemoryUsage(),
-                            storage = config.getStorageUsage()
-                        )
-                    )
-                )
-        }
-        coroutineScope.launch {
-            val response = repository.sendSession(
-                AlfredConstants.DEFAULT_SEND_SESSION_POST_URL,
-                config.getApiKey(),
-                request
-            )
-            if (!dumpFlow) {
-                config.setEventStartRecordingTime(true)
-                handleDeviceAttributes()
-            } else {
-                index?.let { index -> zipDetailsDao.deleteZipFileDetail(zipFileDetails[index].id) }
-                if (workFailureData.size > 0) {
-                    workFailureData.removeAt(0)
-                }
-            }
-        }
-    }
-
-    private fun handleDeviceAttributes() {
-        coroutineScope.launch(Dispatchers.IO) {
-            if (config.getAlfredStatus()) {
-                if (config.getCpuEnableStatus()) {
-                    config.setCpuUsageBeforeEventStart()
-                }
-                if (config.getMemoryEnableStatus()) {
-                    config.setMemoryUsageBeforeEventStart()
-                }
-            }
-            config.setStorageUsageBeforeEventStart()
-            config.setBatteryPercentageBeforeEventStart()
-        }
-    }
-
     fun saveApiLog(
         byteReceived: Long,
         byteSent: Long,
@@ -853,7 +247,9 @@ object AlfredManager {
         startTime: Long,
         endTime: Long
     ) {
-        if (config.getAlfredSessionId().isNotEmpty()) {
+        if (config.getAlfredStatus() && config.getMetricsApiEnableStatus() && config.getAlfredSessionId()
+                .isNotEmpty()
+        ) {
             coroutineDispatcher.executor.execute {
                 val duration: Long = endTime - startTime
                 val errorType: String? = null
@@ -889,61 +285,6 @@ object AlfredManager {
         }
     }
 
-    fun stopRecording(appBackgroundView: View) {
-        isAppInBackground = true
-        hasRecordingStarted = false
-        screenShotTimer?.cancel()
-        if (config.getAlfredStatus() && config.getEnableRecordingStatus()) {
-            if (ScreenShotStorageHelper.images.size > 0) {
-                startAnrCrashZipUpload(appBackgroundView)
-            }
-        }
-    }
-
-    suspend fun toZipForWorkManager(
-        imagePathList: List<ScreenShotPathHelper>,
-        zipFileName: String,
-        sessionStartRecordingTime: Long? = null,
-        alfredSessionId: String? = null,
-        eventStartRecordingTime: Long? = null,
-        index: Int? = null
-    ) {
-        sessionIdForCrash = alfredSessionId
-        sessionStartRecordingTimeForCrash = sessionStartRecordingTime
-        eventStartRecordingTimeForCrash = eventStartRecordingTime
-        val fileList = ArrayList<String>()
-        imagePathList.forEach { screenShotPathHelper ->
-            screenShotPathHelper.screenShotPath?.let { screenShotPath ->
-                if (!fileList.contains(screenShotPath)) {
-                    fileList.add(screenShotPath)
-                }
-            }
-        }
-        val zipFilePath = applicationContext.filesDir.path + "/" + zipFileName
-        if (zip(fileList, zipFilePath) == true) {
-            clearScreenShot(imagePathList)
-            getPreSignedUrl(zipFileName, index = index, workManagerFlow = true, dumpFlow = true)
-        }
-    }
-
-    private fun toZip(imagePathList: List<ScreenShotPathHelper>) {
-        val zipFileName = config.getAlfredSessionId() + UUID.randomUUID().toString()
-        config.setZipFileName(zipFileName)
-        val zipFilePath: String = applicationContext.filesDir.path + "/" + zipFileName
-        val fileList = ArrayList<String>()
-        imagePathList.forEach { screenShotPathHelper ->
-            screenShotPathHelper.screenShotPath?.let { screenShotPath ->
-                if (!fileList.contains(screenShotPath)) {
-                    fileList.add(screenShotPath)
-                }
-            }
-        }
-        if (zip(fileList, zipFilePath) == true) {
-            deleteScreenShot()
-            config.setNextEventStartRecordingTime()
-        }
-    }
-
     fun handleTouchEvent(
         currentTouchEvent: MotionEvent?,
         screenName: String? = null,
@@ -978,36 +319,49 @@ object AlfredManager {
         }
     }
 
-    private fun startAnrCrashZipUpload(view: View) {
-        if (ScreenShotStorageHelper.images.size > 0) {
-            coroutineScope.launch(Dispatchers.IO) {
-                var bmp: Bitmap? = null
-                val screenShotCapture = async { bmp = captureScreenshotOfCustomView(view) }
-                screenShotCapture.await()
-                val insertScreenShotInDb = async {
-                    insertScreenShotPathInDb(this, applicationContext, bmp)
+    fun handleAnrEvent(anrEventProperties: Map<String, String>) {
+        if (config.getAlfredStatus() && config.getAnrEnableStatus()) {
+            val anrView =
+                LayoutInflater.from(applicationContext).inflate(R.layout.anr_screen, null)
+            measureInflatedView(anrView)
+            startAnrCrashZipUpload(anrView)
+            if (config.getAlfredSessionId().isNotEmpty()) {
+                coroutineDispatcher.executor.execute {
+                    val event =
+                        buildEvent(
+                            AlfredConstants.ANR_EVENT,
+                            anrEventProperties as HashMap<String, String>,
+                            screenName = currentScreenName,
+                            moduleName = currentModuleName
+                        )
+                    AlfredDispatcher.addTaskToQueue(
+                        AddEventTask(
+                            event,
+                            this.applicationContext
+                        )
+                    )
                 }
-                insertScreenShotInDb.await()
-                checkAndInitiateFileUploadWorkManager()
             }
         }
     }
 
-    fun handleAnrEvent(
-        anrEventProperties: Map<String, String>,
-        anrView: View
-    ) {
-        startAnrCrashZipUpload(anrView)
-        if (config.getAlfredSessionId().isNotEmpty()) {
-            coroutineDispatcher.executor.execute {
-                val event =
-                    buildEvent(
-                        AlfredConstants.ANR_EVENT,
-                        anrEventProperties as HashMap<String, String>,
-                        screenName = currentScreenName,
-                        moduleName = currentModuleName
-                    )
-                AlfredDispatcher.addTaskToQueue(AddEventTask(event, this.applicationContext))
+    fun handleCrashEvent(crashEventProperties: Map<String, String>) {
+        if (config.getAlfredStatus() && config.getCrashEnableStatus()) {
+            val crashView =
+                LayoutInflater.from(applicationContext).inflate(R.layout.crash_screen, null)
+            measureInflatedView(crashView)
+            startAnrCrashZipUpload(crashView)
+            if (config.getAlfredSessionId().isNotEmpty()) {
+                coroutineDispatcher.executor.execute {
+                    val event =
+                        buildEvent(
+                            AlfredConstants.CRASH_ANALYTICS_EVENT,
+                            crashEventProperties as HashMap<String, String>,
+                            screenName = currentScreenName,
+                            moduleName = currentModuleName
+                        )
+                    AlfredDispatcher.addTaskToQueue(AddEventTask(event, applicationContext))
+                }
             }
         }
     }
@@ -1029,103 +383,23 @@ object AlfredManager {
         }
     }
 
-    fun handleCrashEvent(
-        crashEventProperties: Map<String, String>,
-        crashView: View
-    ) {
-        startAnrCrashZipUpload(crashView)
-        if (config.getAlfredSessionId().isNotEmpty()) {
-            coroutineDispatcher.executor.execute {
-                val event =
-                    buildEvent(
-                        AlfredConstants.CRASH_ANALYTICS_EVENT,
-                        crashEventProperties as HashMap<String, String>,
-                        screenName = currentScreenName,
-                        moduleName = currentModuleName
-                    )
-                AlfredDispatcher.addTaskToQueue(AddEventTask(event, applicationContext))
-            }
-        }
-    }
-
-    @WorkerThread
-    fun buildEvent(
-        eventName: String,
-        properties: HashMap<String, String>? = null,
-        screenName: String? = null,
-        moduleName: String? = null
-    ): AnalyticsEvent {
-        val timeStamp = System.currentTimeMillis()
-        val eventData =
-            EventAttribute(
-                eventName = eventName,
-                eventType = eventName,
-                eventTimestamp = timeStamp,
-                attributes = properties,
-                sessionId = config.getAlfredSessionId(),
-                screenName = screenName,
-                moduleName = moduleName,
-                fragmentList = getFragmentList()
-            )
-        return AnalyticsEvent(timeStamp, Gson().toJson(eventData))
-    }
-
-    @WorkerThread
-    fun buildAppPerformanceEvent(
-        eventName: String,
-        eventType: String,
-        attribute: HashMap<String, Any>? = null
-    ): ApiMetricHelper {
-        val timeStamp = System.currentTimeMillis()
-        val metricData =
-            MetricAttribute(
-                eventId = config.getAlfredEventId(),
-                eventName = eventName,
-                eventType = eventType,
-                sessionId = config.getAlfredSessionId(),
-                attributes = attribute,
-                screenName = currentScreenName,
-                moduleName = currentModuleName,
-                fragmentList = getFragmentList()
-            )
-        return ApiMetricHelper(timeStamp, Gson().toJson(metricData))
-    }
-
     fun setCurrentScreenName(screenName: String?) {
         currentScreenName = screenName
     }
 
-    fun getCurrentScreenName(): String? {
-        return currentScreenName
+    fun setUserId(userId: String?) {
+        config.setUserId(userId)
     }
 
-
-    private fun getFragmentList(): List<String> {
-        val activity = currentActivity?.get()
-        try {
-            val fragmentList = mutableListOf<String>()
-            if (activity is FragmentActivity) {
-                val fragments = activity.supportFragmentManager.fragments
-                fragments.forEach { fragment ->
-                    if (!fragment.isHidden) {
-                        val fragmentName = getFragmentName(fragment)
-                        fragmentName?.let { fragmentList.add(it) }
-                    }
-                }
-            }
-            return fragmentList
-        } catch (e: Exception) {
-            e.log()
-        }
-        return emptyList()
+    fun setUserLocation(latitude: Double, longitude: Double) {
+        config.setLocation(latitude, longitude)
     }
 
-    private fun getFragmentName(fragment: Fragment): String? {
-        fragment.arguments?.let { bundle ->
-            if (bundle.containsKey(FRAGMENT_SCREEN_NAME)) {
-                return bundle.getString(FRAGMENT_SCREEN_NAME).toString()
-            }
-        }
-        return null
+    fun setDisableDialogScreenShot(status: Boolean) {
+        config.setDisableDialogScreenShot(status)
+    }
+
+    fun setPhoneNumber(phoneNumber: String?) {
+        phoneNumber?.let { config.setPhoneNumber(it) }
     }
 }
diff --git a/navi-alfred/src/main/java/com/navi/alfred/callbacks/NetworkCallback.kt b/navi-alfred/src/main/java/com/navi/alfred/callbacks/NetworkCallback.kt
deleted file mode 100644
index b807086..0000000
--- a/navi-alfred/src/main/java/com/navi/alfred/callbacks/NetworkCallback.kt
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.navi.alfred.callbacks
-
-import com.navi.alfred.model.ErrorMessage
-import okhttp3.Request
-import okhttp3.Response
-
-interface NetworkCallback {
-    fun onNetworkRequest(request: Request?) {}
-    fun onNetworkSuccess(response: Response?) {}
-    fun onNetworkFailure(exception: Exception, errorMessage: ErrorMessage, request: Request) {}
-}
\ No newline at end of file
diff --git a/navi-alfred/src/main/java/com/navi/alfred/model/ErrorMessage.kt b/navi-alfred/src/main/java/com/navi/alfred/model/ErrorMessage.kt
index e9b3ab4..e605407 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/model/ErrorMessage.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/model/ErrorMessage.kt
@@ -7,10 +7,16 @@
 
 package com.navi.alfred.model
 
+import android.os.Parcelable
 import com.navi.alfred.db.model.ScreenShotPathHelper
+import kotlinx.parcelize.Parcelize
 import java.util.*
 
-data class ErrorMessage(var statusCode: Int? = null, var message: String? = null)
+@Parcelize
+data class ErrorMessage(
+    var statusCode: Int? = null,
+    var message: String? = null
+) : Parcelable
 
 data class WorkManagerFailureInputData(
     var alfredSessionId: String? = "",
diff --git a/navi-alfred/src/main/java/com/navi/alfred/model/SessionRequest.kt b/navi-alfred/src/main/java/com/navi/alfred/model/SessionRequest.kt
index 06b3f6d..533f6b5 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/model/SessionRequest.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/model/SessionRequest.kt
@@ -9,6 +9,9 @@ package com.navi.alfred.model
 
 import com.google.gson.annotations.SerializedName
 import com.navi.alfred.AlfredManager
+import com.navi.alfred.utils.AlfredConstants.DEVICE_ATTRIBUTES
+import com.navi.alfred.utils.AlfredConstants.NETWORK_STRENGTH
+import com.navi.alfred.utils.AlfredConstants.NETWORK_TYPE
 
 data class AnalyticsRequest(
     @SerializedName("base_attributes") val baseAttribute: BaseAttribute? = null,
@@ -64,7 +67,9 @@ data class BaseAttribute(
     val eventEndTimeStamp: Long? = AlfredManager.config.getEventTimeStamp(),
     @SerializedName("timezone")
     val timezone: String? = AlfredManager.config.getCurrentTimeZone(),
-    @SerializedName("metadata") val metaData: MetaData = MetaData()
+    @SerializedName("metadata") val metaData: MetaData = MetaData(),
+    @SerializedName("snapshot_per_second") val snapshotPerSecond: Int? = AlfredManager.config.getSnapshotPerSecond(),
+    @SerializedName("phone_number") val phoneNumber: String? = AlfredManager.config.getPhoneNumber()
     )
 
 data class SessionEventAttribute(
@@ -86,3 +91,9 @@ data class MetaData(
     @SerializedName("agent_email_id") val agentEmailId: String? = AlfredManager.config.getAgentEmailId(),
     @SerializedName("code_push_version") val codePushVersion: String? = AlfredManager.config.getCodePushVersion()
 )
+
+data class CruiseAttributes(
+    @SerializedName(NETWORK_TYPE) val networkType: String? = null,
+    @SerializedName(NETWORK_STRENGTH) val networkStrength: Float? = null,
+    @SerializedName(DEVICE_ATTRIBUTES) val deviceAttributes: DeviceAttributes? = null
+)
diff --git a/navi-alfred/src/main/java/com/navi/alfred/network/AlfredNetworkRepository.kt b/navi-alfred/src/main/java/com/navi/alfred/network/AlfredNetworkRepository.kt
index 2cc8720..ae8561c 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/network/AlfredNetworkRepository.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/network/AlfredNetworkRepository.kt
@@ -8,6 +8,7 @@
 package com.navi.alfred.network
 
 import com.navi.alfred.model.AnalyticsRequest
+import com.navi.alfred.model.CruiseAttributes
 import com.navi.alfred.model.EventMetricRequest
 import com.navi.alfred.model.SessionRequest
 import com.navi.alfred.network.model.CruiseResponse
@@ -15,6 +16,7 @@ import com.navi.alfred.network.model.PreSignedUrlResponse
 import com.navi.alfred.utils.AlfredConstants.ALFRED
 import okhttp3.RequestBody
 import retrofit2.Response
+import timber.log.Timber
 
 class AlfredNetworkRepository {
     suspend fun sendEvents(
@@ -47,21 +49,27 @@ class AlfredNetworkRepository {
     suspend fun cruiseConfig(
         url: String,
         appVersionName: String,
-        appVersinoCode: String,
+        appVersionCode: String,
         osVersionCode: String,
         deviceId: String,
-        apiKey: String
+        apiKey: String,
+        cruiseAttributes: CruiseAttributes
     ): Response<CruiseResponse> {
+        Timber.d("Alfred cruiseAttributes: $cruiseAttributes")
         return AlfredRetrofitProvider.getApiService()
             .getCruiseConfig(
                 url,
                 ALFRED,
                 contentType = "application/json",
                 appVersionName = appVersionName,
-                appVersionCode = appVersinoCode,
+                appVersionCode = appVersionCode,
                 osVersion = osVersionCode,
                 deviceId = deviceId,
-                apiKey = apiKey
+                apiKey = apiKey,
+                networkType = cruiseAttributes.networkType,
+                networkStrength = cruiseAttributes.networkStrength.toString(),
+                battery = cruiseAttributes.deviceAttributes?.battery.toString(),
+                memory = cruiseAttributes.deviceAttributes?.memory.toString(),
             )
     }
 }
diff --git a/navi-alfred/src/main/java/com/navi/alfred/network/AlfredRetrofitProvider.kt b/navi-alfred/src/main/java/com/navi/alfred/network/AlfredRetrofitProvider.kt
index fd3fa14..64cc264 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/network/AlfredRetrofitProvider.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/network/AlfredRetrofitProvider.kt
@@ -7,18 +7,26 @@
 
 package com.navi.alfred.network
 import android.content.Context
+import android.content.Intent
 import android.util.Log
 import com.chuckerteam.chucker.api.ChuckerCollector
 import com.chuckerteam.chucker.api.ChuckerInterceptor
 import com.google.gson.GsonBuilder
 import com.navi.alfred.AlfredManager
 import com.navi.alfred.BuildConfig
-import com.navi.alfred.callbacks.NetworkCallback
 import com.navi.alfred.deserializer.AnalyticsDataDeserializer
 import com.navi.alfred.deserializer.MetricsDataDeserializer
 import com.navi.alfred.deserializer.SessionDataDeserializer
+import com.navi.alfred.model.ErrorMessage
 import com.navi.alfred.model.EventMetricRequest
 import com.navi.alfred.model.SessionRequest
+import com.navi.alfred.network.model.RequestInfo
+import com.navi.alfred.utils.AlfredConstants.BROADCAST_ACTION_TYPE
+import com.navi.alfred.utils.AlfredConstants.BROADCAST_ERROR_MESSAGE
+import com.navi.alfred.utils.AlfredConstants.BROADCAST_EXCEPTION
+import com.navi.alfred.utils.AlfredConstants.BROADCAST_REQUEST
+import com.navi.alfred.utils.AlfredConstants.HEADER_APP_REQUEST_ID
+import com.navi.alfred.utils.AlfredConstants.HEADER_X_TARGET
 import com.navi.alfred.utils.handleException
 import com.navi.alfred.utils.orZero
 import okhttp3.*
@@ -34,18 +42,16 @@ object AlfredRetrofitProvider {
     private const val BASE_URL_QA = "https://qa-alfred-ingester.np.navi-sa.in/"
     private lateinit var apiService: AlfredRetrofitService
     private lateinit var okHttpClient: OkHttpClient
-    private var callback: NetworkCallback? = null
 
     private val headerInterceptor: Interceptor
         get() = Interceptor { chain ->
             val request = chain.request()
-            callback?.onNetworkRequest(request)
             val response =
                 try {
                     chain.proceed(request).newBuilder().build()
                 } catch (e: Exception) {
                     val errorMessage = handleException(e)
-                    callback?.onNetworkFailure(e, errorMessage, request)
+                    setNetworkFailureBroadcast(e, errorMessage, request)
                     // A mocked response in case of n/w exception
                     Response.Builder()
                         .request(request)
@@ -111,8 +117,18 @@ object AlfredRetrofitProvider {
         return apiService
     }
 
-    fun setNetworkCallback(callback: NetworkCallback) {
-        this.callback = callback
+    private fun setNetworkFailureBroadcast(e: Exception, errorMessage: ErrorMessage, request: Request) {
+        Log.d("Alfred", "AlfredRetrofitProvider setNetworkFailureBroadcast - sending Broadcast")
+        val intent = Intent(BROADCAST_ACTION_TYPE)
+        val requestInfo = RequestInfo(
+            request.url.toString(),
+            request.headers[HEADER_X_TARGET],
+            request.headers[HEADER_APP_REQUEST_ID]
+        )
+        intent.putExtra(BROADCAST_EXCEPTION, e)
+        intent.putExtra(BROADCAST_ERROR_MESSAGE, errorMessage)
+        intent.putExtra(BROADCAST_REQUEST, requestInfo)
+        AlfredManager.applicationContext.sendBroadcast(intent)
     }
 
     private fun loggingInterceptor() =
diff --git a/navi-alfred/src/main/java/com/navi/alfred/network/AlfredRetrofitService.kt b/navi-alfred/src/main/java/com/navi/alfred/network/AlfredRetrofitService.kt
index cb533a3..5fd8e90 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/network/AlfredRetrofitService.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/network/AlfredRetrofitService.kt
@@ -14,8 +14,13 @@ import com.navi.alfred.network.model.CruiseResponse
 import com.navi.alfred.network.model.PreSignedUrlResponse
 import com.navi.alfred.utils.AlfredConstants.APP_VERSION_CODE
 import com.navi.alfred.utils.AlfredConstants.APP_VERSION_NAME
+import com.navi.alfred.utils.AlfredConstants.BATTERY
 import com.navi.alfred.utils.AlfredConstants.CONTENT_TYPE
+import com.navi.alfred.utils.AlfredConstants.CPU
 import com.navi.alfred.utils.AlfredConstants.DEVICE_ID
+import com.navi.alfred.utils.AlfredConstants.MEMORY
+import com.navi.alfred.utils.AlfredConstants.NETWORK_STRENGTH
+import com.navi.alfred.utils.AlfredConstants.NETWORK_TYPE
 import com.navi.alfred.utils.AlfredConstants.OS_VERSION
 import com.navi.alfred.utils.AlfredConstants.SESSION_ID
 import com.navi.alfred.utils.AlfredConstants.X_API_KEY
@@ -75,6 +80,10 @@ interface AlfredRetrofitService {
         @Header(OS_VERSION) osVersion: String,
         @Header(DEVICE_ID) deviceId: String,
         @Header(X_API_KEY) apiKey: String = "",
-        @Header(CONTENT_TYPE) contentType: String
+        @Header(CONTENT_TYPE) contentType: String,
+        @Header(NETWORK_TYPE) networkType: String?,
+        @Header(NETWORK_STRENGTH) networkStrength: String?,
+        @Header(MEMORY) memory: String?,
+        @Header(BATTERY) battery: String?
     ): Response<CruiseResponse>
 }
diff --git a/navi-alfred/src/main/java/com/navi/alfred/network/model/RequestInfo.kt b/navi-alfred/src/main/java/com/navi/alfred/network/model/RequestInfo.kt
new file mode 100644
index 0000000..71e9318
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/network/model/RequestInfo.kt
@@ -0,0 +1,11 @@
+package com.navi.alfred.network.model
+
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+data class RequestInfo(
+    val url: String? = "",
+    val xTarget: String? = "",
+    val appRequestId: String? = ""
+) : Parcelable
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/AlfredConstants.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/AlfredConstants.kt
index 8f5c58c..af61db9 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/utils/AlfredConstants.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/AlfredConstants.kt
@@ -75,4 +75,17 @@ object AlfredConstants {
     const val SYNC_EVENT_TASK = "SyncEventTask"
     const val INCREMENT_OF_ONE_MINUTE = 60000L
     const val FRAGMENT_SCREEN_NAME = "fragmentScreenName"
-}
+    const val HEADER_X_TARGET = "X-Target"
+    const val HEADER_APP_REQUEST_ID = "appRequestId"
+    const val BROADCAST_EXCEPTION = "exception"
+    const val BROADCAST_ERROR_MESSAGE = "errorMessage"
+    const val BROADCAST_REQUEST = "request"
+    const val BROADCAST_ACTION_TYPE = "com.navi.alfred.NetworkFailure"
+    const val NETWORK_TYPE = "network_type"
+    const val NETWORK_STRENGTH = "network_strength"
+    const val CPU = "cpu"
+    const val MEMORY = "memory"
+    const val STORAGE = "storage"
+    const val BATTERY = "battery"
+    const val DEVICE_ATTRIBUTES = "device_attributes"
+}
\ No newline at end of file
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/CommonUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/CommonUtils.kt
new file mode 100644
index 0000000..3558f12
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/CommonUtils.kt
@@ -0,0 +1,32 @@
+/*
+ *
+ *  * Copyright © 2023 by Navi Technologies Limited
+ *  * All rights reserved. Strictly confidential
+ *
+ */
+
+package com.navi.alfred.utils
+
+import com.google.firebase.crashlytics.FirebaseCrashlytics
+import com.navi.alfred.AlfredManager
+import timber.log.Timber
+
+
+private fun Any.tag(): String {
+    return try {
+        this::class.java.simpleName.ifEmpty { "Empty" }
+    } catch (e: Exception) {
+        "EmptyTag"
+    }
+}
+
+fun java.lang.Exception.log() {
+    if (AlfredManager.config.isQa()) {
+        Timber.tag(tag()).e(this)
+    }
+    recordException(this)
+}
+
+fun recordException(e: Throwable) {
+    FirebaseCrashlytics.getInstance().recordException(e)
+}
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/CruiseConfigUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/CruiseConfigUtils.kt
new file mode 100644
index 0000000..ae5cabb
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/CruiseConfigUtils.kt
@@ -0,0 +1,81 @@
+package com.navi.alfred.utils
+
+import com.navi.alfred.AlfredManager
+import com.navi.alfred.model.CruiseAttributes
+import com.navi.alfred.network.model.CruiseResponse
+
+internal suspend fun getCruiseConfig(cruiseApiSuccessful: (response: CruiseResponse) -> Unit) {
+    val response =
+        AlfredManager.repository.cruiseConfig(
+            AlfredConstants.DEFAULT_CRUISE_CONFIG_URL,
+            AlfredManager.config.getAppVersionName(),
+            AlfredManager.config.getAppVersionCode(),
+            AlfredManager.config.getOsVersion(),
+            AlfredManager.config.getDeviceId(),
+            AlfredManager.config.getApiKey(),
+            AlfredManager.config.getCruiseAttributes()
+        )
+    if (response.isSuccessful && response.code() == AlfredConstants.CODE_API_SUCCESS) {
+        try {
+            response.body()?.let { cruiseResponse ->
+                setCruiseConfig(cruiseResponse)
+                cruiseApiSuccessful(cruiseResponse)
+            }
+        } catch (e: Exception) {
+            e.log()
+        }
+    }
+}
+
+private fun setCruiseConfig(cruiseResponse: CruiseResponse) {
+    cruiseResponse.data.let { responseList ->
+        if (responseList.isNotEmpty()) {
+            val cruiseConfig = responseList.first()
+
+            cruiseConfig.source.let { source ->
+                source.enable?.let { sourceConfig ->
+                    AlfredManager.config.setAlfredStatus(
+                        sourceConfig
+                    )
+                }
+                source.recordingsConfig?.let { recordingConfig ->
+                    recordingConfig.enable?.let { enable ->
+                        AlfredManager.config.setEnableRecordingStatus(enable)
+                    }
+                    recordingConfig.videoQuality?.let { videoQuality ->
+                        AlfredManager.config.setVideoQuality(videoQuality)
+                    }
+                    recordingConfig.disableAnrRecording?.let { anrStatus ->
+                        AlfredManager.config.setAnrEnableStatus(!anrStatus)
+                    }
+                    recordingConfig.disableCrashRecording?.let { crashStatus ->
+                        AlfredManager.config.setCrashEnableStatus(!crashStatus)
+                    }
+                    recordingConfig.disableScreens?.let { disableScreen ->
+                        AlfredManager.config.setDisableScreenList(disableScreen)
+                    }
+                    recordingConfig.maskingEnabledScreens?.let { maskingEnabledScreens ->
+                        AlfredManager.config.setMaskingEnabledScreenList(maskingEnabledScreens)
+                    }
+                    recordingConfig.disableModules?.let { disableModuleList ->
+                        AlfredManager.config.setDisableModuleList(disableModuleList)
+                    }
+                    recordingConfig.snapshotPerSecond?.let { snapShotPerSecond ->
+                        AlfredManager.config.setSnapshotPerSecond(snapShotPerSecond)
+                    }
+                }
+                source.metricsConfig?.let { metricsConfig ->
+                    metricsConfig.disableMemoryMonitoring?.let { memory_monitor_status ->
+                        AlfredManager.config.setMemoryEnableStatus(!memory_monitor_status)
+                    }
+                    metricsConfig.disableCpuMonitoring?.let { cpu_monitor_status ->
+                        AlfredManager.config.setCpuEnableStatus(!cpu_monitor_status)
+                    }
+                    metricsConfig.disableApiPerformance?.let { api_monitor_status ->
+                        AlfredManager.config.setApiMetricsEnableStatus(!api_monitor_status)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/DeviceMetricsUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/DeviceMetricsUtils.kt
new file mode 100644
index 0000000..50ae8db
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/DeviceMetricsUtils.kt
@@ -0,0 +1,146 @@
+/*
+ *
+ *  * Copyright © 2023 by Navi Technologies Limited
+ *  * All rights reserved. Strictly confidential
+ *
+ */
+
+package com.navi.alfred.utils
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.net.ConnectivityManager
+import android.os.BatteryManager
+import android.os.Build
+import android.os.Debug
+import android.os.StatFs
+import android.telephony.TelephonyManager
+import com.navi.alfred.AlfredManager
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.io.BufferedReader
+import java.io.InputStreamReader
+
+internal fun handleDeviceAttributes() {
+    AlfredManager.coroutineScope.launch(Dispatchers.IO) {
+        if (AlfredManager.config.getAlfredStatus()) {
+            if (AlfredManager.config.getCpuEnableStatus()) {
+                AlfredManager.config.setCpuUsageBeforeEventStart()
+            }
+            if (AlfredManager.config.getMemoryEnableStatus()) {
+                AlfredManager.config.setMemoryUsageBeforeEventStart()
+            }
+        }
+        AlfredManager.config.setStorageUsageBeforeEventStart()
+        AlfredManager.config.setBatteryPercentageBeforeEventStart()
+    }
+}
+
+@SuppressLint("MissingPermission")
+internal fun getNetworkType(context: Context): String {
+    try {
+        val connManager =
+            context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        val mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
+        if (mWifi != null && mWifi.isConnected) return "Wifi"
+        val mTelephonyManager =
+            context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
+        return when (mTelephonyManager.networkType) {
+            TelephonyManager.NETWORK_TYPE_GPRS,
+            TelephonyManager.NETWORK_TYPE_EDGE,
+            TelephonyManager.NETWORK_TYPE_CDMA,
+            TelephonyManager.NETWORK_TYPE_1xRTT,
+            TelephonyManager.NETWORK_TYPE_IDEN -> "2G"
+            TelephonyManager.NETWORK_TYPE_UMTS,
+            TelephonyManager.NETWORK_TYPE_EVDO_0,
+            TelephonyManager.NETWORK_TYPE_EVDO_A,
+            TelephonyManager.NETWORK_TYPE_HSDPA,
+            TelephonyManager.NETWORK_TYPE_HSUPA,
+            TelephonyManager.NETWORK_TYPE_HSPA,
+            TelephonyManager.NETWORK_TYPE_EVDO_B,
+            TelephonyManager.NETWORK_TYPE_EHRPD,
+            TelephonyManager.NETWORK_TYPE_HSPAP -> "3G"
+            TelephonyManager.NETWORK_TYPE_LTE -> "4G"
+            TelephonyManager.NETWORK_TYPE_NR -> "5G"
+            else -> "Unknown" + AlfredConstants.UNDERSCORE + mTelephonyManager.networkType
+        }
+    } catch (e: Exception) {
+        e.log()
+    }
+    return "Unknown"
+}
+
+fun getNetworkStrength(context: Context): Float {
+    try {
+        val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        val netInfo = cm.activeNetworkInfo ?: return 0f
+        val nc = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            cm.getNetworkCapabilities(cm.activeNetwork)
+        } else {
+            return 0f
+        }
+        return nc?.linkUpstreamBandwidthKbps?.toFloat() ?: 0f
+
+    } catch (e: Exception) {
+        e.log()
+    }
+    return 0f
+}
+
+internal fun getCarrierName(context: Context): String? {
+    return try {
+        (context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager)
+            .networkOperatorName
+    } catch (e: Exception) {
+        e.log()
+        null
+    }
+}
+
+internal fun getBatteryPercentage(context: Context): Float {
+    val batteryManager = context.getSystemService(Context.BATTERY_SERVICE) as BatteryManager
+    return batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY).toFloat()
+}
+
+internal fun getMemoryUsage(): Float {
+    val runtime = Runtime.getRuntime()
+    val usedMemory = runtime.totalMemory() - runtime.freeMemory()
+    return usedMemory / (1024f * 1024f)
+}
+
+internal fun getMemoryUsagePercentage(): Float {
+    val runtime = Runtime.getRuntime()
+    val usedMemory = runtime.totalMemory() - runtime.freeMemory()
+    val maxMemory = runtime.maxMemory()
+    return usedMemory.toFloat() / maxMemory.toFloat() * 100
+}
+
+internal fun getCpuUsage(): Float {
+    val command = "top -n 1 -d 1"
+    val process = Runtime.getRuntime().exec(command)
+    val reader = BufferedReader(InputStreamReader(process.inputStream))
+    var line: String? = reader.readLine()
+    var cpuUsage = 0f
+    while (line != null) {
+        if (line.contains("% cpu")) {
+            val regex = "\\s+".toRegex()
+            val tokens = regex.split(line)
+            cpuUsage = tokens[0].toFloat()
+            break
+        }
+        line = reader.readLine()
+    }
+    reader.close()
+    return cpuUsage
+}
+
+internal fun getStorageUsage(context: Context): Pair<Long, Long> {
+    val path = context.filesDir.path
+    val stat = StatFs(path)
+    val blockSize = stat.blockSizeLong
+    val totalBlocks = stat.blockCountLong
+    val freeBlocks = stat.availableBlocksLong
+    val totalSize = blockSize * totalBlocks
+    val freeSize = blockSize * freeBlocks
+    return Pair(totalSize, freeSize)
+}
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/EventUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/EventUtils.kt
new file mode 100644
index 0000000..5184a17
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/EventUtils.kt
@@ -0,0 +1,278 @@
+package com.navi.alfred.utils
+
+import android.content.Context
+import androidx.annotation.WorkerThread
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import com.navi.alfred.AlfredManager
+import com.navi.alfred.db.AlfredDatabaseHelper
+import com.navi.alfred.db.model.AnalyticsEvent
+import com.navi.alfred.db.model.ApiMetricHelper
+import com.navi.alfred.model.AnalyticsRequest
+import com.navi.alfred.model.BaseAttribute
+import com.navi.alfred.model.DeviceAttributes
+import com.navi.alfred.model.EventAttribute
+import com.navi.alfred.model.EventMetricRequest
+import com.navi.alfred.model.MetricAttribute
+import com.navi.alfred.model.SessionEventAttribute
+import com.navi.alfred.model.SessionRequest
+import com.navi.alfred.worker.AddEventTask
+import com.navi.alfred.worker.AddMetricTask
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.withLock
+import java.lang.reflect.Type
+import kotlin.concurrent.fixedRateTimer
+
+internal suspend fun sendEventsToServer(applicationContext: Context): Boolean {
+    if (AlfredManager.config.getAlfredStatus() && AlfredManager.config.getEnableRecordingStatus()) {
+        AlfredManager.mutex.withLock {
+            val db = AlfredDatabaseHelper.getAnalyticsDatabase(applicationContext)
+            val analyticsDao = db.analyticsDao()
+            val analyticsEvents = analyticsDao.fetchEvents(AlfredManager.config.getEventBatchSize())
+
+            if (analyticsEvents.isNotEmpty()) {
+                try {
+                    val detailsList = analyticsEvents.map { it.details }
+                    val listType: Type =
+                        object : TypeToken<ArrayList<EventAttribute?>?>() {}.type
+                    val events: ArrayList<EventAttribute> =
+                        Gson().fromJson(detailsList.toString(), listType)
+                    if (events.size > 0) {
+                        val sessionId = events.first().sessionId
+                        val request =
+                            AnalyticsRequest(
+                                baseAttribute = BaseAttribute(sessionId = sessionId),
+                                events = events
+                            )
+                        val response = AlfredManager.repository.sendEvents(
+                            AlfredManager.config.getPostUrl(),
+                            AlfredManager.config.getApiKey(),
+                            request
+                        )
+                        return if (
+                            (response.isSuccessful && response.code() == AlfredConstants.CODE_API_SUCCESS) or
+                            (response.code() == AlfredConstants.CODE_API_BAD_REQUEST)
+                        ) {
+                            analyticsDao.deleteEvents(analyticsEvents.map { it.eventId })
+                            true
+                        } else {
+                            false
+                        }
+                    } else {
+                        false
+                    }
+                } catch (e: Exception) {
+                    return false
+                }
+            } else {
+                return false
+            }
+        }
+        return false
+    }
+    return false
+}
+
+internal fun sendAlfredSessionEvent(dumpFlow: Boolean = false, index: Int? = null) {
+    var request: SessionRequest? = null
+    if (dumpFlow) {
+        var clientTs: Long? = null
+        var sessionTimeStamp: Long? = null
+        var sessionId: String? = null
+        var eventEndTimeStamp: Long? = null
+        if (index != null) {
+            val zipFileDetail = AlfredManager.zipFileDetails[index]
+            clientTs = zipFileDetail.eventStartRecordingTime
+            sessionTimeStamp = zipFileDetail.sessionStartRecordingTime
+            sessionId = zipFileDetail.alfredSessionId
+        } else {
+            clientTs = AlfredManager.eventStartRecordingTimeForCrash
+            sessionTimeStamp = AlfredManager.sessionStartRecordingTimeForCrash
+            sessionId = AlfredManager.sessionIdForCrash
+        }
+
+        clientTs?.let {
+            eventEndTimeStamp =
+                java.lang.Long.min(
+                    it.plus(AlfredConstants.INCREMENT_OF_ONE_MINUTE),
+                    AlfredManager.config.getEventTimeStamp()
+                )
+        }
+
+        request =
+            SessionRequest(
+                base_attribute =
+                BaseAttribute(
+                    sessionId = sessionId,
+                    eventTimeStamp = AlfredManager.config.getEventTimeStamp(),
+                    clientTs = clientTs,
+                    sessionTimeStamp = sessionTimeStamp,
+                    eventEndTimeStamp = eventEndTimeStamp
+                ),
+                session_upload_event_attributes =
+                SessionEventAttribute(
+                    beginningDeviceAttributes = DeviceAttributes(),
+                    endDeviceAttributes = DeviceAttributes()
+                )
+            )
+    } else {
+        val eventEndTimeStamp = AlfredManager.config.getEventStartRecordingTime()
+            ?.let {
+                java.lang.Long.min(
+                    it.plus(AlfredConstants.INCREMENT_OF_ONE_MINUTE),
+                    AlfredManager.config.getEventTimeStamp()
+                )
+            }
+        request =
+            SessionRequest(
+                base_attribute =
+                BaseAttribute(
+                    sessionId = AlfredManager.config.getAlfredSessionId(),
+                    eventTimeStamp = AlfredManager.config.getEventTimeStamp(),
+                    clientTs = AlfredManager.config.getEventStartRecordingTime(),
+                    eventEndTimeStamp = eventEndTimeStamp
+                ),
+                session_upload_event_attributes =
+                SessionEventAttribute(
+                    beginningDeviceAttributes =
+                    DeviceAttributes(
+                        battery = AlfredManager.config.batteryPercentageBeforeEventStart,
+                        cpu = AlfredManager.config.cpuUsageBeforeEventStart,
+                        memory = AlfredManager.config.memoryUsageBeforeEventStart,
+                        storage = AlfredManager.config.storageUsageBeforeEventStart
+                    ),
+                    endDeviceAttributes =
+                    DeviceAttributes(
+                        battery = AlfredManager.config.getBatteryPercentage(),
+                        cpu = AlfredManager.config.getCpuUsage(),
+                        memory = AlfredManager.config.getMemoryUsagePercentage(),
+                        storage = AlfredManager.config.getStorageUsage()
+                    )
+                )
+            )
+    }
+    AlfredManager.coroutineScope.launch {
+        val response = AlfredManager.repository.sendSession(
+            AlfredConstants.DEFAULT_SEND_SESSION_POST_URL,
+            AlfredManager.config.getApiKey(),
+            request
+        )
+        if (!dumpFlow) {
+            AlfredManager.config.setEventStartRecordingTime(true)
+            handleDeviceAttributes()
+        } else {
+            index?.let { index -> AlfredManager.zipDetailsDao.deleteZipFileDetail(AlfredManager.zipFileDetails[index].id) }
+            if (AlfredManager.workFailureData.size > 0) {
+                AlfredManager.workFailureData.removeAt(0)
+            }
+        }
+    }
+}
+
+internal suspend fun sendIngestMetric(): Boolean {
+    if (AlfredManager.config.getAlfredStatus() && AlfredManager.config.getMetricsApiEnableStatus()) {
+        AlfredManager.mutex.withLock {
+            val metricEventList =
+                AlfredManager.apiMetricDao.fetchApiMetric(AlfredManager.config.getEventBatchSize())
+            if (metricEventList.isNotEmpty()) {
+                try {
+                    val detailsList = metricEventList.map { it.metric }
+                    val listType: Type =
+                        object : TypeToken<ArrayList<MetricAttribute?>?>() {}.type
+                    val events: ArrayList<MetricAttribute> =
+                        Gson().fromJson(detailsList.toString(), listType)
+                    if (events.size > 0) {
+                        val sessionId = events.first().sessionId
+                        val request =
+                            EventMetricRequest(
+                                baseAttribute = BaseAttribute(sessionId = sessionId),
+                                metricsAttribute = events
+                            )
+                        val response =
+                            AlfredManager.repository.eventMetric(
+                                AlfredConstants.DEFAULT_INGEST_METRIC_URL,
+                                AlfredManager.config.getApiKey(),
+                                metricRequestBody = request
+                            )
+                        return if (
+                            (response.isSuccessful && response.code() == AlfredConstants.CODE_API_SUCCESS) or
+                            (response.code() == AlfredConstants.CODE_API_BAD_REQUEST)
+                        ) {
+                            AlfredManager.apiMetricDao.deleteApiMetric(metricEventList.map { it.id })
+                            true
+                        } else {
+                            false
+                        }
+                    }
+                } catch (e: Exception) {
+                    return false
+                }
+            } else {
+                return false
+            }
+        }
+        return false
+    }
+    return false
+}
+
+internal fun startSyncEvents(applicationContext: Context) {
+    AlfredManager.timer =
+        fixedRateTimer(
+            AlfredConstants.TIMER_THREAD_NAME,
+            false,
+            AlfredConstants.DEFAULT_INITIAL_DELAY,
+            AlfredManager.config.getEventsDelayInMilliseconds()
+        ) {
+            runBlocking {
+                AddMetricTask.resetEventCount()
+                sendIngestMetric()
+                AddEventTask.resetEventCount()
+                sendEventsToServer(applicationContext)
+            }
+        }
+}
+
+@WorkerThread
+internal fun buildEvent(
+    eventName: String,
+    properties: HashMap<String, String>? = null,
+    screenName: String? = null,
+    moduleName: String? = null
+): AnalyticsEvent {
+    val timeStamp = System.currentTimeMillis()
+    val eventData =
+        EventAttribute(
+            eventName = eventName,
+            eventType = eventName,
+            eventTimestamp = timeStamp,
+            attributes = properties,
+            sessionId = AlfredManager.config.getAlfredSessionId(),
+            screenName = screenName,
+            moduleName = moduleName,
+            fragmentList = getFragmentList()
+        )
+    return AnalyticsEvent(timeStamp, Gson().toJson(eventData))
+}
+
+@WorkerThread
+internal fun buildAppPerformanceEvent(
+    eventName: String,
+    eventType: String,
+    attribute: HashMap<String, Any>? = null
+): ApiMetricHelper {
+    val timeStamp = System.currentTimeMillis()
+    val metricData =
+        MetricAttribute(
+            eventId = AlfredManager.config.getAlfredEventId(),
+            eventName = eventName,
+            eventType = eventType,
+            sessionId = AlfredManager.config.getAlfredSessionId(),
+            attributes = attribute,
+            screenName = AlfredManager.currentScreenName,
+            moduleName = AlfredManager.currentModuleName,
+            fragmentList = getFragmentList()
+        )
+    return ApiMetricHelper(timeStamp, Gson().toJson(metricData))
+}
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/MaskingUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/MaskingUtils.kt
new file mode 100644
index 0000000..7eaeafb
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/MaskingUtils.kt
@@ -0,0 +1,25 @@
+/*
+ *
+ *  * Copyright © 2023 by Navi Technologies Limited
+ *  * All rights reserved. Strictly confidential
+ *
+ */
+
+package com.navi.alfred.utils
+
+import android.view.View
+import android.view.ViewGroup
+
+internal fun findViewWithTagRecursive(view: View, tag: String, maskedViews: MutableList<View>): List<View> {
+    if (view.tag == tag) {
+        maskedViews.add(view)
+    }
+
+    if (view is ViewGroup) {
+        for (i in 0 until view.childCount) {
+            val childView = view.getChildAt(i)
+            findViewWithTagRecursive(childView, tag, maskedViews)
+        }
+    }
+    return maskedViews
+}
\ No newline at end of file
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/NetworkUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/NetworkUtils.kt
index 6d1db1e..077014b 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/utils/NetworkUtils.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/NetworkUtils.kt
@@ -7,6 +7,8 @@
 
 package com.navi.alfred.utils
 
+import android.content.Context
+import android.net.ConnectivityManager
 import com.google.gson.JsonParseException
 import com.navi.alfred.AlfredManager
 import com.navi.alfred.model.ErrorMessage
@@ -15,7 +17,7 @@ import java.net.SocketException
 import java.net.SocketTimeoutException
 import java.net.UnknownHostException
 
-fun handleException(e: Throwable): ErrorMessage {
+internal fun handleException(e: Throwable): ErrorMessage {
     val errorMessage = ErrorMessage()
     if (!isNetworkAvailable(AlfredManager.applicationContext)) {
         errorMessage.statusCode = ApiConstants.NO_INTERNET
@@ -35,3 +37,9 @@ fun handleException(e: Throwable): ErrorMessage {
     errorMessage.message = e.message.toString()
     return errorMessage
 }
+
+internal fun isNetworkAvailable(context: Context): Boolean {
+    val connectivityManager =
+        context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+    return connectivityManager?.activeNetworkInfo?.isConnected.orFalse()
+}
\ No newline at end of file
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/ScreenNameUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/ScreenNameUtils.kt
new file mode 100644
index 0000000..5609600
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/ScreenNameUtils.kt
@@ -0,0 +1,59 @@
+package com.navi.alfred.utils
+
+
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import com.navi.alfred.AlfredManager
+
+internal fun isScreenDisabled(screenName: String? = null, moduleName: String? = null): Boolean {
+    if (
+        moduleName != null &&
+        AlfredManager.config.getDisableModuleList()?.contains(moduleName) == true
+    ) {
+        return true
+    } else {
+        if (
+            screenName != null &&
+            AlfredManager.config.getDisableScreenList()?.contains(screenName) == true
+        ) {
+            return true
+        }
+    }
+    return false
+}
+
+internal fun isMaskingEnabled(screenName: String? = null): Boolean {
+    if (AlfredManager.config.getMaskingEnabledScreenList()?.contains(screenName) == true) {
+        return true
+    }
+    return false
+}
+
+internal fun getFragmentList(): List<String> {
+    val activity = AlfredManager.currentActivity?.get()
+    try {
+        val fragmentList = mutableListOf<String>()
+        if (activity is FragmentActivity) {
+            val fragments = activity.supportFragmentManager.fragments
+            fragments.forEach { fragment ->
+                if (!fragment.isHidden) {
+                    val fragmentName = getFragmentName(fragment)
+                    fragmentName?.let { fragmentList.add(it) }
+                }
+            }
+        }
+        return fragmentList
+    } catch (e: Exception) {
+        e.log()
+    }
+    return emptyList()
+}
+
+private fun getFragmentName(fragment: Fragment): String? {
+    fragment.arguments?.let { bundle ->
+        if (bundle.containsKey(AlfredConstants.FRAGMENT_SCREEN_NAME)) {
+            return bundle.getString(AlfredConstants.FRAGMENT_SCREEN_NAME).toString()
+        }
+    }
+    return null
+}
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/ScreenShotUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/ScreenShotUtils.kt
new file mode 100644
index 0000000..ee4f0ea
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/ScreenShotUtils.kt
@@ -0,0 +1,312 @@
+package com.navi.alfred.utils
+
+import android.content.Context
+import android.content.res.Resources
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.view.View
+import android.view.ViewGroup
+import com.navi.alfred.AlfredManager
+import com.navi.alfred.db.AlfredDatabaseHelper
+import com.navi.alfred.db.model.ScreenShotPathHelper
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+
+internal suspend fun handleScreenShot() {
+    if (
+        ScreenShotStorageHelper.images.size == AlfredManager.imageThreshHoldValue ||
+        ScreenShotStorageHelper.images.size == AlfredManager.imageSecondThreshHoldValue
+    ) {
+        toZip(AlfredManager.screenShotDao.fetchScreenShotsPath(AlfredManager.imageThreshHoldValue))
+    } else {
+        if (ScreenShotStorageHelper.images.size == 1) {
+            checkToStartZipUpload()
+        }
+    }
+}
+
+internal fun combineScreenshots(
+    backgroundScreenshot: Bitmap?,
+    bottomSheetScreenshot: Bitmap?,
+    context: Context,
+    screenName: String? = null,
+    moduleName: String? = null,
+    scope: CoroutineScope
+): Bitmap? {
+    if (
+        backgroundScreenshot == null ||
+        bottomSheetScreenshot == null ||
+        isScreenDisabled(screenName, moduleName)
+    ) {
+        return null
+    }
+    var screenWidth = Resources.getSystem().displayMetrics.widthPixels / 2
+    var screenHeight = Resources.getSystem().displayMetrics.heightPixels / 2
+    if (!isResolutionEven(screenWidth, screenHeight)) {
+        screenHeight += 1
+        screenWidth += 1
+    }
+    val combinedBitmap = Bitmap.createBitmap(screenWidth, screenHeight, Bitmap.Config.ARGB_8888)
+    val canvas = Canvas(combinedBitmap)
+    canvas.drawBitmap(backgroundScreenshot, 0f, 0f, null)
+    var bottomSheetLeft = (screenWidth - bottomSheetScreenshot.width) / 2f
+    var bottomSheetTop = screenHeight - bottomSheetScreenshot.height.toFloat()
+    if (!isResolutionEven(bottomSheetLeft.toInt(), bottomSheetTop.toInt())) {
+        bottomSheetLeft = (bottomSheetLeft.toInt() + 1).toFloat()
+        bottomSheetTop = (bottomSheetTop.toInt() + 1).toFloat()
+    }
+    canvas.drawBitmap(bottomSheetScreenshot, bottomSheetLeft, bottomSheetTop, null)
+    insertScreenShotPathInDb(scope, context, combinedBitmap)
+    return combinedBitmap
+}
+
+internal fun insertScreenShotPathInDb(
+    scope: CoroutineScope,
+    context: Context,
+    bitmap: Bitmap?,
+    bottomSheetFlow: Boolean? = false
+) {
+    scope.launch(Dispatchers.IO) {
+        try {
+            val fileDir = context.filesDir
+            val fileName =
+                System.currentTimeMillis().toString() + AlfredConstants.IMAGE_FILE_EXTENSION
+            val path = fileDir.path.plus("/").plus(fileName)
+            val imageUrl = File(path)
+            val fos = FileOutputStream(imageUrl)
+            val videoQuality: Int =
+                when (AlfredManager.config.getVideoQuality()) {
+                    VideoQuality.HIGH.name -> {
+                        10
+                    }
+
+                    VideoQuality.LOW.name -> {
+                        6
+                    }
+
+                    VideoQuality.MEDIUM.name -> {
+                        8
+                    }
+
+                    else -> {
+                        10
+                    }
+                }
+            bitmap?.compress(Bitmap.CompressFormat.JPEG, videoQuality, fos)
+            fos.flush()
+            fos.close()
+            if (bottomSheetFlow == false) {
+                val db = AlfredDatabaseHelper.getAnalyticsDatabase(context)
+                val screenShotDao = db.screenShotDao()
+                try {
+                    screenShotDao.insertScreenShotPath(
+                        ScreenShotPathHelper(System.currentTimeMillis(), path)
+                    )
+                    ScreenShotStorageHelper.addImage(path)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+        } catch (e: Exception) {
+            e.log()
+        } catch (e: IOException) {
+            e.log()
+        }
+    }
+}
+
+internal fun captureScreenshotOfCustomView(view: View): Bitmap? {
+    view.draw(Canvas())
+    val bitmapForCanvas = createBitmapForView(view)
+    try {
+        view.draw(bitmapForCanvas?.first)
+    } catch (e: Exception) {
+        e.log()
+    }
+    return bitmapForCanvas?.second
+}
+
+internal fun deleteScreenShot() {
+    try {
+        val screenShotPathList: List<ScreenShotPathHelper> =
+            if (AlfredManager.screenShotDao.getScreenShotCount() >= AlfredManager.imageThreshHoldValue) {
+                AlfredManager.screenShotDao.fetchScreenShotsPath(AlfredManager.imageThreshHoldValue)
+            } else {
+                AlfredManager.screenShotDao.fetchAllScreenShotsPath()
+            }
+        clearScreenShot(screenShotPathList)
+        try {
+            if (AlfredManager.isAppInBackground) {
+                ScreenShotStorageHelper.clearAll()
+                AlfredManager.screenShotDao.deleteAllScreenShot()
+                AlfredManager.isAppInBackground = false
+                AlfredManager.hasRecordingStarted = false
+            } else {
+                val idList = screenShotPathList.map { it.id }
+                AlfredManager.screenShotDao.deleteScreenShot(idList)
+                ScreenShotStorageHelper.deleteKItems(idList.size)
+            }
+        } catch (e: Exception) {
+            e.log()
+        }
+    } catch (e: Exception) {
+        e.log()
+    }
+}
+
+internal fun clearScreenShot(path: List<ScreenShotPathHelper>) {
+    path.forEach { data ->
+        val file = data.screenShotPath?.let { File(it) }
+        if (file?.exists() == true) {
+            file.delete()
+        }
+    }
+}
+
+enum class VideoQuality {
+    LOW,
+    HIGH,
+    MEDIUM
+}
+
+
+internal suspend fun captureScreen(
+    v: View,
+    context: Context,
+    bottomSheetFlow: Boolean? = false,
+    screenName: String? = null,
+    scope: CoroutineScope,
+    canvas: Canvas? = null,
+    bmp: Bitmap? = null,
+    moduleName: String? = null
+): Bitmap? {
+    if (isScreenDisabled(screenName, moduleName)) {
+        return null
+    }
+    if (canvas != null && bmp != null) {
+        if (isMaskingEnabled(screenName) || (v.tag == AlfredConstants.SENSITIVE_VIEW_TAG)) {
+            val maskedViewsList = findViewWithTagRecursive(
+                v,
+                AlfredConstants.SENSITIVE_VIEW_TAG, mutableListOf()
+            )
+            withContext(Dispatchers.Main) {
+                try {
+                    if (maskedViewsList.isEmpty()) {
+                        v.draw(canvas)
+                    } else {
+                        val alphaList = mutableListOf<Pair<View, Float>>()
+
+                        for (maskedView in maskedViewsList) {
+                            alphaList.add(Pair(maskedView, maskedView.alpha))
+                            maskedView.alpha = 0.0f
+                        }
+
+                        v.draw(canvas)
+
+                        for (alphaView in alphaList) {
+                            val view = alphaView.first
+                            view.alpha = alphaView.second
+                        }
+                        alphaList.clear()
+                    }
+                } catch (e: Exception) {
+                    e.log()
+                }
+            }
+        } else {
+            withContext(Dispatchers.Main) {
+                try {
+                    v.draw(canvas)
+                } catch (e: Exception) {
+                    e.log()
+                }
+            }
+        }
+        insertScreenShotPathInDb(scope, context, bmp, bottomSheetFlow)
+    }
+    return bmp
+}
+
+internal suspend fun captureBottomSheet(
+    view: View,
+    bottomSheetView: View,
+    context: Context,
+    screenName: String? = null,
+    rootCanvas: Canvas? = null,
+    rootBmp: Bitmap? = null,
+    moduleName: String? = null
+) {
+    if (AlfredManager.config.getDisableDialogScreenShot()) {
+        return
+    }
+    if (bottomSheetView != null) {
+        val bottomSheetCanvasForBitmap = createBitmapForView(bottomSheetView)
+        val bottomSheetScreenShot =
+            captureScreen(
+                bottomSheetView,
+                context,
+                true,
+                screenName,
+                AlfredManager.coroutineScope,
+                bottomSheetCanvasForBitmap?.first,
+                bottomSheetCanvasForBitmap?.second,
+                moduleName = moduleName
+            )
+        val backgroundScreenShot =
+            captureScreen(
+                view,
+                context,
+                true,
+                screenName,
+                AlfredManager.coroutineScope,
+                rootCanvas,
+                rootBmp,
+                moduleName = moduleName
+            )
+        if (bottomSheetScreenShot != null && backgroundScreenShot != null) {
+            combineScreenshots(
+                backgroundScreenShot,
+                bottomSheetScreenShot,
+                context,
+                screenName,
+                moduleName = moduleName,
+                scope = AlfredManager.coroutineScope
+            )
+        }
+    }
+}
+
+@JvmOverloads
+internal fun measureInflatedView(view: View, width: Int = 1080, height: Int = 1920) {
+    view.layoutParams = ViewGroup.LayoutParams(width, height)
+    view.measure(
+        View.MeasureSpec.makeMeasureSpec(view.layoutParams.width, View.MeasureSpec.EXACTLY),
+        View.MeasureSpec.makeMeasureSpec(view.layoutParams.height, View.MeasureSpec.EXACTLY)
+    )
+    view.layout(0, 0, view.measuredWidth, view.measuredHeight)
+}
+
+internal fun createBitmapForView(view: View): Pair<Canvas, Bitmap>? {
+    var width = view.width / 2
+    var height = view.height / 2
+    if (width > 0 && height > 0) {
+        if (!isResolutionEven(width, height)) {
+            width += 1
+            height += 1
+        }
+        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bitmap)
+        canvas.scale(0.5f, 0.5f)
+        return Pair(canvas, bitmap)
+    }
+    return null
+}
+
+internal fun isResolutionEven(width: Int, height: Int): Boolean {
+    return width.mod(2) == 0 && height.mod(2) == 0
+}
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/UploadUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/UploadUtils.kt
new file mode 100644
index 0000000..3baa60f
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/UploadUtils.kt
@@ -0,0 +1,144 @@
+package com.navi.alfred.utils
+
+import androidx.work.Constraints
+import androidx.work.Data
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import com.google.gson.Gson
+import com.navi.alfred.AlfredManager
+import com.navi.alfred.worker.UploadFileWorker
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.RequestBody.Companion.asRequestBody
+import java.io.File
+
+
+internal suspend fun getPreSignedUrl(
+    zipFileName: String,
+    dumpFlow: Boolean = false,
+    index: Int? = null,
+    workManagerFlow: Boolean? = false
+) {
+    AlfredManager.config.setAlfredEventId()
+    val bucketKey = AlfredManager.config.getAlfredEventId().plus(AlfredConstants.ZIP_FILE_EXTENSION)
+    val response =
+        AlfredManager.repository.getPreSignedUrl(bucketKey, AlfredManager.config.getApiKey())
+    if (response.isSuccessful && response.code() == AlfredConstants.CODE_API_SUCCESS) {
+        checkFileExists(zipFileName, AlfredManager.applicationContext)?.let { file ->
+            response.body()?.data?.let {
+                uploadFile(
+                    file,
+                    it,
+                    dumpFlow,
+                    index,
+                    zipFileName,
+                    workManagerFlow = workManagerFlow
+                )
+            }
+        }
+    } else {
+        if (!dumpFlow) {
+            AlfredManager.hasUploadFlowStarted = false
+            AlfredManager.config.getEventStartRecordingTime()?.let { eventStartRecordingTime ->
+                insertZipDetailsToDbForDumpingLater(
+                    AlfredManager.config.getAlfredSessionId(),
+                    AlfredManager.config.getSessionStartRecordingTime(),
+                    eventStartRecordingTime,
+                    zipFileName
+                )
+            }
+            AlfredManager.config.setEventStartRecordingTime(true)
+        }
+        if (workManagerFlow == true) {
+            uploadWorkManagerFailedZip()
+        }
+    }
+}
+
+internal fun checkAndInitiateFileUploadWorkManager() {
+    val screenShotList = AlfredManager.screenShotDao.fetchAllScreenShotsPath()
+    AlfredManager.screenShotDao.deleteAllScreenShot()
+    ScreenShotStorageHelper.clearAll()
+    AlfredManager.isAppInBackground = false
+    AlfredManager.hasRecordingStarted = false
+    AlfredManager.config.clearZipFileName()
+    val requestData =
+        Data.Builder()
+            .putString(AlfredConstants.ALFRED_SESSION_ID, AlfredManager.config.getAlfredSessionId())
+            .putLong(
+                AlfredConstants.SESSION_START_RECORDING_TIME,
+                AlfredManager.config.getSessionStartRecordingTime()
+            )
+            .putLong(
+                AlfredConstants.EVENT_START_RECORDING_TIME,
+                AlfredManager.config.getEventStartRecordingTime() ?: 0L
+            )
+            .putString(AlfredConstants.SCREENSHOT_LIST, Gson().toJson(screenShotList))
+            .build()
+    buildWorkManager(requestData)
+}
+
+internal fun buildWorkManager(requestData: Data) {
+    val constraints =
+        Constraints.Builder()
+            .setRequiresBatteryNotLow(false)
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .build()
+    val uniqueWorkName = "YOUR_UNIQUE_WORK_NAME"
+    val uniqueWorkStatus =
+        WorkManager.getInstance(AlfredManager.applicationContext)
+            .getWorkInfosForUniqueWork(uniqueWorkName)
+            .get()
+    if (uniqueWorkStatus.isNullOrEmpty()) {
+        val uniqueWorkRequest =
+            OneTimeWorkRequestBuilder<UploadFileWorker>()
+                .setConstraints(constraints)
+                .setInputData(requestData)
+                .build()
+        WorkManager.getInstance(AlfredManager.applicationContext)
+            .beginUniqueWork(uniqueWorkName, ExistingWorkPolicy.KEEP, uniqueWorkRequest)
+            .enqueue()
+    } else {
+        val workRequest =
+            OneTimeWorkRequestBuilder<UploadFileWorker>()
+                .setConstraints(constraints)
+                .setInputData(requestData)
+                .build()
+        WorkManager.getInstance(AlfredManager.applicationContext).enqueue(workRequest)
+    }
+}
+
+internal suspend fun uploadFile(
+    uploadFile: File,
+    url: String,
+    dumpFlow: Boolean = false,
+    index: Int? = null,
+    zipFileName: String,
+    workManagerFlow: Boolean? = false
+) {
+    val requestBody = uploadFile.asRequestBody("application/zip".toMediaTypeOrNull())
+    val uploadResponse = AlfredManager.repository.uploadZipToS3(url, requestBody)
+    if (uploadResponse.isSuccessful && uploadResponse.code() == AlfredConstants.CODE_API_SUCCESS) {
+        uploadFile.delete()
+        sendAlfredSessionEvent(dumpFlow, index)
+    } else {
+        if (!dumpFlow) {
+            AlfredManager.config.getEventStartRecordingTime()?.let { eventStartRecordingTime ->
+                insertZipDetailsToDbForDumpingLater(
+                    AlfredManager.config.getAlfredSessionId(),
+                    AlfredManager.config.getSessionStartRecordingTime(),
+                    eventStartRecordingTime,
+                    zipFileName
+                )
+            }
+            AlfredManager.config.setEventStartRecordingTime(true)
+        }
+        if (workManagerFlow == true) {
+            uploadWorkManagerFailedZip()
+        }
+    }
+    if (!dumpFlow) {
+        AlfredManager.hasUploadFlowStarted = false
+    }
+}
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/UserBehaviourUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/UserBehaviourUtils.kt
new file mode 100644
index 0000000..54ce0c9
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/UserBehaviourUtils.kt
@@ -0,0 +1,47 @@
+/*
+ *
+ *  * Copyright © 2023 by Navi Technologies Limited
+ *  * All rights reserved. Strictly confidential
+ *
+ */
+
+package com.navi.alfred.utils
+
+
+import android.view.MotionEvent
+import com.navi.alfred.model.NaviMotionEvent
+import java.lang.Math.subtractExact
+import java.util.*
+import kotlin.math.abs
+
+internal fun getTouchEvent(
+    currentTouchEvent: MotionEvent?,
+    previousTouchEvent: NaviMotionEvent?
+): Pair<String, HashMap<String, String>> {
+    val properties = HashMap<String, String>()
+    val pointerIndex = currentTouchEvent?.actionIndex ?: 0
+    val eventName =
+        if (
+            difference(currentTouchEvent?.getX(pointerIndex), previousTouchEvent?.positionX) &&
+            difference(currentTouchEvent?.getY(pointerIndex), previousTouchEvent?.positionY)
+        ) {
+            properties[AlfredConstants.START_X] = previousTouchEvent?.positionX.toString()
+            properties[AlfredConstants.START_Y] = previousTouchEvent?.positionY.toString()
+            AlfredConstants.TOUCH_EVENT
+        } else {
+            properties[AlfredConstants.START_X] = previousTouchEvent?.positionX.toString()
+            properties[AlfredConstants.START_Y] = previousTouchEvent?.positionY.toString()
+            properties[AlfredConstants.END_X] = currentTouchEvent?.rawX.toString()
+            properties[AlfredConstants.END_Y] = currentTouchEvent?.rawY.toString()
+            AlfredConstants.SCROLL_EVENT
+        }
+    return Pair(eventName, properties)
+}
+
+internal fun difference(value1: Float? = 0F, value2: Float? = 0F, threshold: Int = 100): Boolean {
+    return try {
+        abs(subtractExact(value1?.toInt().orZero(), value2?.toInt().orZero())) <= threshold
+    } catch (e: Exception) {
+        false
+    }
+}
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/Utils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/Utils.kt
deleted file mode 100644
index fe4357e..0000000
--- a/navi-alfred/src/main/java/com/navi/alfred/utils/Utils.kt
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
- *
- *  * Copyright © 2023 by Navi Technologies Limited
- *  * All rights reserved. Strictly confidential
- *
- */
-
-package com.navi.alfred.utils
-
-import android.annotation.SuppressLint
-import android.content.Context
-import android.content.res.Resources
-import android.graphics.Bitmap
-import android.graphics.Bitmap.CompressFormat
-import android.graphics.Canvas
-import android.net.ConnectivityManager
-import android.os.BatteryManager
-import android.os.StatFs
-import android.telephony.TelephonyManager
-import android.view.MotionEvent
-import android.view.View
-import android.view.ViewGroup
-import com.google.firebase.crashlytics.FirebaseCrashlytics
-import com.navi.alfred.AlfredManager
-import com.navi.alfred.db.AlfredDatabaseHelper
-import com.navi.alfred.db.model.ScreenShotPathHelper
-import com.navi.alfred.model.NaviMotionEvent
-import com.navi.alfred.utils.AlfredConstants.IMAGE_FILE_EXTENSION
-import com.navi.alfred.utils.AlfredConstants.SENSITIVE_VIEW_TAG
-import com.navi.alfred.utils.AlfredConstants.UNDERSCORE
-import java.io.*
-import java.lang.Math.subtractExact
-import java.util.*
-import java.util.zip.ZipEntry
-import java.util.zip.ZipOutputStream
-import kotlin.math.abs
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import timber.log.Timber
-
-suspend fun captureScreen(
-    v: View,
-    context: Context,
-    bottomSheetFlow: Boolean? = false,
-    screenName: String? = null,
-    scope: CoroutineScope,
-    canvas: Canvas? = null,
-    bmp: Bitmap? = null,
-    moduleName: String? = null
-): Bitmap? {
-    if (isScreenDisabled(screenName, moduleName)) {
-        return null
-    }
-    if (canvas != null && bmp != null) {
-        if (isMaskingEnabled(screenName) || (v.tag == SENSITIVE_VIEW_TAG)) {
-            val maskedViewsList = findViewWithTagRecursive(v, SENSITIVE_VIEW_TAG, mutableListOf())
-            withContext(Dispatchers.Main) {
-                try {
-                    if (maskedViewsList.isEmpty()) {
-                        v.draw(canvas)
-                    } else {
-                        val alphaList = mutableListOf<Pair<View, Float>>()
-
-                        for (maskedView in maskedViewsList) {
-                            alphaList.add(Pair(maskedView, maskedView.alpha))
-                            maskedView.alpha = 0.0f
-                        }
-
-                        v.draw(canvas)
-
-                        for (alphaView in alphaList) {
-                            val view = alphaView.first
-                            view.alpha = alphaView.second
-                        }
-                        alphaList.clear()
-                    }
-                } catch (e: Exception) {
-                    e.log()
-                }
-            }
-        } else {
-            withContext(Dispatchers.Main) {
-                try {
-                    v.draw(canvas)
-                } catch (e: Exception) {
-                    e.log()
-                }
-            }
-        }
-        insertScreenShotPathInDb(scope, context, bmp, bottomSheetFlow)
-    }
-    return bmp
-}
-
-fun findViewWithTagRecursive(view: View, tag: String, maskedViews: MutableList<View>): List<View> {
-    if (view.tag == tag) {
-        maskedViews.add(view)
-    }
-
-    if (view is ViewGroup) {
-        for (i in 0 until view.childCount) {
-            val childView = view.getChildAt(i)
-            findViewWithTagRecursive(childView, tag, maskedViews)
-        }
-    }
-    return maskedViews
-}
-
-fun combineScreenshots(
-    backgroundScreenshot: Bitmap?,
-    bottomSheetScreenshot: Bitmap?,
-    context: Context,
-    screenName: String? = null,
-    moduleName: String? = null,
-    scope: CoroutineScope
-): Bitmap? {
-    if (
-        backgroundScreenshot == null ||
-        bottomSheetScreenshot == null ||
-        isScreenDisabled(screenName, moduleName)
-    ) {
-        return null
-    }
-    var screenWidth = Resources.getSystem().displayMetrics.widthPixels / 2
-    var screenHeight = Resources.getSystem().displayMetrics.heightPixels / 2
-    if (!isResolutionEven(screenWidth, screenHeight)) {
-        screenHeight += 1
-        screenWidth += 1
-    }
-    val combinedBitmap = Bitmap.createBitmap(screenWidth, screenHeight, Bitmap.Config.ARGB_8888)
-    val canvas = Canvas(combinedBitmap)
-    canvas.drawBitmap(backgroundScreenshot, 0f, 0f, null)
-    var bottomSheetLeft = (screenWidth - bottomSheetScreenshot.width) / 2f
-    var bottomSheetTop = screenHeight - bottomSheetScreenshot.height.toFloat()
-    if (!isResolutionEven(bottomSheetLeft.toInt(), bottomSheetTop.toInt())) {
-        bottomSheetLeft = (bottomSheetLeft.toInt() + 1).toFloat()
-        bottomSheetTop = (bottomSheetTop.toInt() + 1).toFloat()
-    }
-    canvas.drawBitmap(bottomSheetScreenshot, bottomSheetLeft, bottomSheetTop, null)
-    insertScreenShotPathInDb(scope, context, combinedBitmap)
-    return combinedBitmap
-}
-
-fun insertScreenShotPathInDb(
-    scope: CoroutineScope,
-    context: Context,
-    bitmap: Bitmap?,
-    bottomSheetFlow: Boolean? = false
-) {
-    scope.launch(Dispatchers.IO) {
-        try {
-            val fileDir = context.filesDir
-            val fileName = System.currentTimeMillis().toString() + IMAGE_FILE_EXTENSION
-            val path = fileDir.path.plus("/").plus(fileName)
-            val imageUrl = File(path)
-            val fos = FileOutputStream(imageUrl)
-            val videoQuality: Int =
-                when (AlfredManager.config.getVideoQuality()) {
-                    VideoQuality.HIGH.name -> {
-                        10
-                    }
-                    VideoQuality.LOW.name -> {
-                        6
-                    }
-                    VideoQuality.MEDIUM.name -> {
-                        8
-                    }
-                    else -> {
-                        10
-                    }
-                }
-            bitmap?.compress(CompressFormat.JPEG, videoQuality, fos)
-            fos.flush()
-            fos.close()
-            if (bottomSheetFlow == false) {
-                val db = AlfredDatabaseHelper.getAnalyticsDatabase(context)
-                val screenShotDao = db.screenShotDao()
-                try {
-                    screenShotDao.insertScreenShotPath(
-                        ScreenShotPathHelper(System.currentTimeMillis(), path)
-                    )
-                    ScreenShotStorageHelper.addImage(path)
-                } catch (e: Exception) {
-                    e.printStackTrace()
-                }
-            }
-        } catch (e: Exception) {
-            e.log()
-        } catch (e: IOException) {
-            e.log()
-        }
-    }
-}
-
-fun captureScreenshotOfCustomView(view: View): Bitmap? {
-    view.draw(Canvas())
-    val bitmapForCanvas = createBitmapForView(view)
-    try {
-        view.draw(bitmapForCanvas?.first)
-    } catch (e: Exception) {
-        e.log()
-    }
-    return bitmapForCanvas?.second
-}
-
-fun createBitmapForView(view: View): Pair<Canvas, Bitmap>? {
-    var width = view.width / 2
-    var height = view.height / 2
-    if (width > 0 && height > 0) {
-        if (!isResolutionEven(width, height)) {
-            width += 1
-            height += 1
-        }
-        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
-        val canvas = Canvas(bitmap)
-        canvas.scale(0.5f, 0.5f)
-        return Pair(canvas, bitmap)
-    }
-    return null
-}
-
-fun zip(_files: ArrayList<String>, zipFilePath: String?): Boolean? {
-    val buffer = 1000
-    try {
-        zipFilePath?.let { path ->
-            if (File(path).exists()) return true
-            else {
-                File(path)
-            }
-        }
-        var origin: BufferedInputStream? = null
-        val dest = FileOutputStream(zipFilePath)
-        val out = ZipOutputStream(BufferedOutputStream(dest))
-        val data = ByteArray(buffer)
-        for (i in _files.indices) {
-            try {
-                val fi = FileInputStream(_files[i])
-                origin = BufferedInputStream(fi, buffer)
-                val entry = ZipEntry(_files[i].substring(_files[i].lastIndexOf("/") + 1))
-                out.putNextEntry(entry)
-                var count: Int
-                while (origin.read(data, 0, buffer).also { count = it } != -1) {
-                    out.write(data, 0, count)
-                }
-                origin.close()
-            } catch (e: Exception) {
-                e.log()
-            }
-        }
-        out.close()
-        return true
-    } catch (e: java.lang.Exception) {
-        e.log()
-    }
-    return null
-}
-
-fun clearScreenShot(path: List<ScreenShotPathHelper>) {
-    path.forEach { data ->
-        val file = data.screenShotPath?.let { File(it) }
-        if (file?.exists() == true) {
-            file.delete()
-        }
-    }
-}
-
-fun isScreenDisabled(screenName: String? = null, moduleName: String? = null): Boolean {
-    if (
-        moduleName != null &&
-            AlfredManager.config.getDisableModuleList()?.contains(moduleName) == true
-    ) {
-        return true
-    } else {
-        if (
-            screenName != null &&
-                AlfredManager.config.getDisableScreenList()?.contains(screenName) == true
-        ) {
-            return true
-        }
-    }
-    return false
-}
-
-fun isMaskingEnabled(screenName: String? = null): Boolean {
-    if (AlfredManager.config.getMaskingEnabledScreenList()?.contains(screenName) == true) {
-        return true
-    }
-    return false
-}
-
-fun checkFileExists(fileName: String, context: Context): File? {
-    val file = File(context.filesDir, fileName)
-    return if (file.exists()) {
-        file
-    } else {
-        null
-    }
-}
-
-fun getTouchEvent(
-    currentTouchEvent: MotionEvent?,
-    previousTouchEvent: NaviMotionEvent?
-): Pair<String, HashMap<String, String>> {
-    val properties = HashMap<String, String>()
-    val pointerIndex = currentTouchEvent?.actionIndex ?: 0
-    val eventName =
-        if (
-            difference(currentTouchEvent?.getX(pointerIndex), previousTouchEvent?.positionX) &&
-                difference(currentTouchEvent?.getY(pointerIndex), previousTouchEvent?.positionY)
-        ) {
-            properties[AlfredConstants.START_X] = previousTouchEvent?.positionX.toString()
-            properties[AlfredConstants.START_Y] = previousTouchEvent?.positionY.toString()
-            AlfredConstants.TOUCH_EVENT
-        } else {
-            properties[AlfredConstants.START_X] = previousTouchEvent?.positionX.toString()
-            properties[AlfredConstants.START_Y] = previousTouchEvent?.positionY.toString()
-            properties[AlfredConstants.END_X] = currentTouchEvent?.rawX.toString()
-            properties[AlfredConstants.END_Y] = currentTouchEvent?.rawY.toString()
-            AlfredConstants.SCROLL_EVENT
-        }
-    return Pair(eventName, properties)
-}
-
-fun difference(value1: Float? = 0F, value2: Float? = 0F, threshold: Int = 100): Boolean {
-    return try {
-        abs(subtractExact(value1?.toInt().orZero(), value2?.toInt().orZero())) <= threshold
-    } catch (e: Exception) {
-        false
-    }
-}
-
-@SuppressLint("MissingPermission")
-fun getNetworkType(context: Context): String {
-    try {
-        val connManager =
-            context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-        val mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
-        if (mWifi != null && mWifi.isConnected) return "Wifi"
-        val mTelephonyManager =
-            context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
-        return when (mTelephonyManager.networkType) {
-            TelephonyManager.NETWORK_TYPE_GPRS,
-            TelephonyManager.NETWORK_TYPE_EDGE,
-            TelephonyManager.NETWORK_TYPE_CDMA,
-            TelephonyManager.NETWORK_TYPE_1xRTT,
-            TelephonyManager.NETWORK_TYPE_IDEN -> "2G"
-            TelephonyManager.NETWORK_TYPE_UMTS,
-            TelephonyManager.NETWORK_TYPE_EVDO_0,
-            TelephonyManager.NETWORK_TYPE_EVDO_A,
-            TelephonyManager.NETWORK_TYPE_HSDPA,
-            TelephonyManager.NETWORK_TYPE_HSUPA,
-            TelephonyManager.NETWORK_TYPE_HSPA,
-            TelephonyManager.NETWORK_TYPE_EVDO_B,
-            TelephonyManager.NETWORK_TYPE_EHRPD,
-            TelephonyManager.NETWORK_TYPE_HSPAP -> "3G"
-            TelephonyManager.NETWORK_TYPE_LTE -> "4G"
-            TelephonyManager.NETWORK_TYPE_NR -> "5G"
-            else -> "Unknown" + UNDERSCORE + mTelephonyManager.networkType
-        }
-    } catch (e: Exception) {
-        e.log()
-    }
-    return "Unknown"
-}
-
-fun getCarrierName(context: Context): String? {
-    return try {
-        (context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager)
-            .networkOperatorName
-    } catch (e: Exception) {
-        e.log()
-        null
-    }
-}
-
-fun getBatteryPercentage(context: Context): Float {
-    val batteryManager = context.getSystemService(Context.BATTERY_SERVICE) as BatteryManager
-    return batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY).toFloat()
-}
-
-fun getMemoryUsage(): Float {
-    val runtime = Runtime.getRuntime()
-    val usedMemory = runtime.totalMemory() - runtime.freeMemory()
-    return usedMemory / (1024f * 1024f)
-}
-
-fun getCpuUsage(): Float {
-    val command = "top -n 1 -d 1"
-    val process = Runtime.getRuntime().exec(command)
-    val reader = BufferedReader(InputStreamReader(process.inputStream))
-    var line: String? = reader.readLine()
-    var cpuUsage = 0f
-    while (line != null) {
-        if (line.contains("% cpu")) {
-            val regex = "\\s+".toRegex()
-            val tokens = regex.split(line)
-            cpuUsage = tokens[0].toFloat()
-            break
-        }
-        line = reader.readLine()
-    }
-    reader.close()
-    return cpuUsage
-}
-
-fun getStorageUsage(context: Context): Pair<Long, Long> {
-    val path = context.filesDir.path
-    val stat = StatFs(path)
-    val blockSize = stat.blockSizeLong
-    val totalBlocks = stat.blockCountLong
-    val freeBlocks = stat.availableBlocksLong
-    val totalSize = blockSize * totalBlocks
-    val freeSize = blockSize * freeBlocks
-    return Pair(totalSize, freeSize)
-}
-
-enum class VideoQuality {
-    LOW,
-    HIGH,
-    MEDIUM
-}
-
-private fun Any.tag(): String {
-    return try {
-        this::class.java.simpleName.ifEmpty { "Empty" }
-    } catch (e: Exception) {
-        "EmptyTag"
-    }
-}
-
-fun java.lang.Exception.log() {
-    if (AlfredManager.config.isQa()) {
-        Timber.tag(tag()).e(this)
-    }
-    recordException(this)
-}
-
-fun isNetworkAvailable(context: Context): Boolean {
-    val connectivityManager =
-        context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
-    return connectivityManager?.activeNetworkInfo?.isConnected.orFalse()
-}
-
-private fun isResolutionEven(width: Int, height: Int): Boolean {
-    return width.mod(2) == 0 && height.mod(2) == 0
-}
-
-fun recordException(e: Throwable) {
-    FirebaseCrashlytics.getInstance().recordException(e)
-}
\ No newline at end of file
diff --git a/navi-alfred/src/main/java/com/navi/alfred/utils/ZipUtils.kt b/navi-alfred/src/main/java/com/navi/alfred/utils/ZipUtils.kt
new file mode 100644
index 0000000..80010aa
--- /dev/null
+++ b/navi-alfred/src/main/java/com/navi/alfred/utils/ZipUtils.kt
@@ -0,0 +1,222 @@
+package com.navi.alfred.utils
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.view.View
+import androidx.work.Data
+import androidx.work.WorkManager
+import com.google.gson.Gson
+import com.navi.alfred.AlfredManager
+import com.navi.alfred.db.model.ScreenShotPathHelper
+import com.navi.alfred.db.model.ZipDetailsHelper
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+import java.io.BufferedInputStream
+import java.io.BufferedOutputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.util.UUID
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
+
+internal fun toZip(imagePathList: List<ScreenShotPathHelper>) {
+    val zipFileName = AlfredManager.config.getAlfredSessionId() + UUID.randomUUID().toString()
+    AlfredManager.config.setZipFileName(zipFileName)
+    val zipFilePath: String = AlfredManager.applicationContext.filesDir.path + "/" + zipFileName
+    val fileList = ArrayList<String>()
+    imagePathList.forEach { screenShotPathHelper ->
+        screenShotPathHelper.screenShotPath?.let { screenShotPath ->
+            if (!fileList.contains(screenShotPath)) {
+                fileList.add(screenShotPath)
+            }
+        }
+    }
+    if (zip(fileList, zipFilePath) == true) {
+        deleteScreenShot()
+        AlfredManager.config.setNextEventStartRecordingTime()
+    }
+}
+
+internal fun zip(_files: java.util.ArrayList<String>, zipFilePath: String?): Boolean? {
+    val buffer = 1000
+    try {
+        zipFilePath?.let { path ->
+            if (File(path).exists()) return true
+            else {
+                File(path)
+            }
+        }
+        var origin: BufferedInputStream? = null
+        val dest = FileOutputStream(zipFilePath)
+        val out = ZipOutputStream(BufferedOutputStream(dest))
+        val data = ByteArray(buffer)
+        for (i in _files.indices) {
+            try {
+                val fi = FileInputStream(_files[i])
+                origin = BufferedInputStream(fi, buffer)
+                val entry = ZipEntry(_files[i].substring(_files[i].lastIndexOf("/") + 1))
+                out.putNextEntry(entry)
+                var count: Int
+                while (origin.read(data, 0, buffer).also { count = it } != -1) {
+                    out.write(data, 0, count)
+                }
+                origin.close()
+            } catch (e: Exception) {
+                e.log()
+            }
+        }
+        out.close()
+        return true
+    } catch (e: java.lang.Exception) {
+        e.log()
+    }
+    return null
+}
+
+internal fun checkDbBeforeStartRecording() {
+    AlfredManager.coroutineScope.launch(Dispatchers.IO) {
+        if (AlfredManager.screenShotDao.getScreenShotCount() > 0) {
+            AlfredManager.screenShotDao.deleteAllScreenShot()
+        }
+
+        if (AlfredManager.zipDetailsDao.getZipFilesDetailsCount() > 0) {
+            AlfredManager.zipFileDetails = AlfredManager.zipDetailsDao.fetchAllZipFilesDetails()
+            AlfredManager.zipFileDetails.forEachIndexed { index, DumpZipDetailsHelper ->
+                if (
+                    checkFileExists(
+                        fileName = DumpZipDetailsHelper.zipFileName,
+                        AlfredManager.applicationContext
+                    ) != null
+                ) {
+                    getPreSignedUrl(DumpZipDetailsHelper.zipFileName, true, index)
+                } else {
+                    AlfredManager.zipDetailsDao.deleteZipFileDetail(DumpZipDetailsHelper.id)
+                }
+            }
+        }
+    }
+}
+
+internal suspend fun checkToStartZipUpload() {
+    val zipFileName = AlfredManager.config.getZipFileName().toString()
+    if (zipFileName.isNotEmpty()) {
+        if (checkFileExists(zipFileName, AlfredManager.applicationContext) != null) {
+            if (!AlfredManager.hasUploadFlowStarted) {
+                AlfredManager.hasUploadFlowStarted = true
+                getPreSignedUrl(zipFileName)
+            }
+        }
+    }
+}
+
+internal suspend fun toZipForWorkManager(
+    imagePathList: List<ScreenShotPathHelper>,
+    zipFileName: String,
+    sessionStartRecordingTime: Long? = null,
+    alfredSessionId: String? = null,
+    eventStartRecordingTime: Long? = null,
+    index: Int? = null
+) {
+    AlfredManager.sessionIdForCrash = alfredSessionId
+    AlfredManager.sessionStartRecordingTimeForCrash = sessionStartRecordingTime
+    AlfredManager.eventStartRecordingTimeForCrash = eventStartRecordingTime
+    val fileList = ArrayList<String>()
+    imagePathList.forEach { screenShotPathHelper ->
+        screenShotPathHelper.screenShotPath?.let { screenShotPath ->
+            if (!fileList.contains(screenShotPath)) {
+                fileList.add(screenShotPath)
+            }
+        }
+    }
+    val zipFilePath = AlfredManager.applicationContext.filesDir.path + "/" + zipFileName
+    if (zip(fileList, zipFilePath) == true) {
+        clearScreenShot(imagePathList)
+        getPreSignedUrl(
+            zipFileName,
+            index = index,
+            workManagerFlow = true,
+            dumpFlow = true
+        )
+    }
+}
+
+internal fun insertZipDetailsToDbForDumpingLater(
+    alfredSessionId: String,
+    sessionStartRecordingTime: Long,
+    eventStartRecordingTime: Long,
+    zipFileName: String
+) {
+    AlfredManager.zipDetailsDao.insert(
+        data =
+        ZipDetailsHelper(
+            alfredSessionId = alfredSessionId,
+            sessionStartRecordingTime = sessionStartRecordingTime,
+            eventStartRecordingTime = eventStartRecordingTime,
+            zipFileName = zipFileName
+        )
+    )
+}
+
+internal fun startAnrCrashZipUpload(view: View) {
+    if (ScreenShotStorageHelper.images.size > 0) {
+        AlfredManager.coroutineScope.launch(Dispatchers.IO) {
+            var bmp: Bitmap? = null
+            val screenShotCapture = async { bmp = captureScreenshotOfCustomView(view) }
+            screenShotCapture.await()
+            val insertScreenShotInDb = async {
+                insertScreenShotPathInDb(this, AlfredManager.applicationContext, bmp)
+            }
+            insertScreenShotInDb.await()
+            checkAndInitiateFileUploadWorkManager()
+        }
+    }
+}
+
+internal fun uploadWorkManagerFailedZip() {
+    if (AlfredManager.workFailureData.size > 0) {
+        val inputData = AlfredManager.workFailureData[0]
+        if (AlfredManager.retryCount < 3) {
+            WorkManager.getInstance(AlfredManager.applicationContext).cancelWorkById(inputData.id)
+            val requestData =
+                Data.Builder()
+                    .putString(AlfredConstants.ALFRED_SESSION_ID, inputData.alfredSessionId)
+                    .putLong(
+                        AlfredConstants.SESSION_START_RECORDING_TIME,
+                        inputData.sessionStartRecordingTime
+                    )
+                    .putLong(
+                        AlfredConstants.EVENT_START_RECORDING_TIME,
+                        inputData.eventStartRecordingTime
+                    )
+                    .putString(
+                        AlfredConstants.SCREENSHOT_LIST,
+                        Gson().toJson(inputData.screenShots)
+                    )
+                    .build()
+            buildWorkManager(requestData)
+            AlfredManager.retryCount += 1
+            AlfredManager.workFailureData.removeAt(0)
+        } else {
+            AlfredManager.retryCount = 0
+            WorkManager.getInstance(AlfredManager.applicationContext).cancelWorkById(inputData.id)
+            AlfredManager.workFailureData.removeAt(0)
+            insertZipDetailsToDbForDumpingLater(
+                alfredSessionId = inputData.alfredSessionId.toString(),
+                eventStartRecordingTime = inputData.eventStartRecordingTime,
+                sessionStartRecordingTime = inputData.sessionStartRecordingTime,
+                zipFileName = inputData.zipFileName
+            )
+        }
+    }
+}
+
+internal fun checkFileExists(fileName: String, context: Context): File? {
+    val file = File(context.filesDir, fileName)
+    return if (file.exists()) {
+        file
+    } else {
+        null
+    }
+}
diff --git a/navi-alfred/src/main/java/com/navi/alfred/worker/SyncDataTask.kt b/navi-alfred/src/main/java/com/navi/alfred/worker/SyncDataTask.kt
index de4c279..f8768cd 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/worker/SyncDataTask.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/worker/SyncDataTask.kt
@@ -9,16 +9,17 @@ package com.navi.alfred.worker
 
 import android.content.Context
 import androidx.annotation.WorkerThread
-import com.navi.alfred.AlfredManager
 import com.navi.alfred.utils.AlfredConstants.SYNC_EVENT_TASK
+import com.navi.alfred.utils.sendEventsToServer
+import com.navi.alfred.utils.sendIngestMetric
 import kotlinx.coroutines.runBlocking
 
 class SyncDataTask(private val context: Context) : AnalyticsTask {
     @WorkerThread
     override fun execute(): Boolean {
         return runBlocking {
-            AlfredManager.sendIngestMetric()
-            AlfredManager.sendEventsToServer(context)
+            sendIngestMetric()
+            sendEventsToServer(context)
         }
     }
 
diff --git a/navi-alfred/src/main/java/com/navi/alfred/worker/UploadFileWorker.kt b/navi-alfred/src/main/java/com/navi/alfred/worker/UploadFileWorker.kt
index d5a8146..a154e14 100644
--- a/navi-alfred/src/main/java/com/navi/alfred/worker/UploadFileWorker.kt
+++ b/navi-alfred/src/main/java/com/navi/alfred/worker/UploadFileWorker.kt
@@ -17,6 +17,7 @@ import com.navi.alfred.AlfredManager.workFailureData
 import com.navi.alfred.db.model.ScreenShotPathHelper
 import com.navi.alfred.model.WorkManagerFailureInputData
 import com.navi.alfred.utils.AlfredConstants
+import com.navi.alfred.utils.toZipForWorkManager
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import java.lang.reflect.Type
@@ -57,7 +58,7 @@ class UploadFileWorker(context: Context, workerParams: WorkerParameters) :
                 ) {
                     Result.failure()
                 } else {
-                    AlfredManager.toZipForWorkManager(
+                    toZipForWorkManager(
                         screenShots,
                         zipFileName,
                         sessionStartRecordingTime,
diff --git a/navi-alfred/src/main/res/layout/anr_screen.xml b/navi-alfred/src/main/res/layout/anr_screen.xml
new file mode 100644
index 0000000..082299a
--- /dev/null
+++ b/navi-alfred/src/main/res/layout/anr_screen.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/white">
+
+    <androidx.appcompat.widget.AppCompatTextView
+        android:id="@+id/tv_anr"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="@string/anr"
+        android:textColor="@color/black"
+        android:textSize="20sp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/navi-alfred/src/main/res/layout/app_background_screen.xml b/navi-alfred/src/main/res/layout/app_background_screen.xml
new file mode 100644
index 0000000..d3d3ea6
--- /dev/null
+++ b/navi-alfred/src/main/res/layout/app_background_screen.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout android:id="@+id/root_view"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/white"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+
+        <androidx.appcompat.widget.AppCompatTextView
+            android:id="@+id/tv_app_background"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/app_background"
+            android:textColor="@color/black"
+            android:textSize="20sp"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintEnd_toEndOf="parent"
+            app:layout_constraintStart_toStartOf="parent"
+            app:layout_constraintTop_toTopOf="parent" />
+
+    </androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/navi-alfred/src/main/res/layout/crash_screen.xml b/navi-alfred/src/main/res/layout/crash_screen.xml
new file mode 100644
index 0000000..f3ebb8b
--- /dev/null
+++ b/navi-alfred/src/main/res/layout/crash_screen.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/white">
+
+    <TextView
+        android:id="@+id/tv_crash"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="@string/crash"
+        android:textColor="@color/black"
+        android:textSize="20sp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/navi-alfred/src/main/res/layout/third_party_screen.xml b/navi-alfred/src/main/res/layout/third_party_screen.xml
new file mode 100644
index 0000000..a33cefd
--- /dev/null
+++ b/navi-alfred/src/main/res/layout/third_party_screen.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/white">
+
+    <androidx.appcompat.widget.AppCompatTextView
+        android:id="@+id/tv_third_party"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="@string/third_party_screen"
+        android:textColor="@color/black"
+        android:textSize="20sp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+
+    <androidx.appcompat.widget.AppCompatTextView
+        android:id="@+id/tv_third_party_name"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_marginHorizontal="16dp"
+        android:layout_marginTop="10sp"
+        android:gravity="center"
+        android:lines="3"
+        android:textColor="@color/black"
+        android:textSize="20sp"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toBottomOf="@id/tv_third_party"
+        tools:text="@string/third_party_screen" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/navi-alfred/src/main/res/values/colors.xml b/navi-alfred/src/main/res/values/colors.xml
new file mode 100644
index 0000000..768b058
--- /dev/null
+++ b/navi-alfred/src/main/res/values/colors.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="black">#FF000000</color>
+    <color name="white">#FFFFFFFF</color>
+</resources>
diff --git a/navi-alfred/src/main/res/values/strings.xml b/navi-alfred/src/main/res/values/strings.xml
new file mode 100644
index 0000000..fa2ffb3
--- /dev/null
+++ b/navi-alfred/src/main/res/values/strings.xml
@@ -0,0 +1,7 @@
+<resources>
+    <string name="app_name">Alfred Android</string>
+    <string name="crash">Crash Occurred</string>
+    <string name="anr">Anr Occurred</string>
+    <string name="app_background">App In Background</string>
+    <string name="third_party_screen">Third Party Screen</string>
+</resources>