react-native-mytatva-rn-sdk 1.2.96 → 1.2.98

package/android/src/main/java/com/mytatvarnsdk/activity/VideoActivity.kt

@@ -1,23 +1,24 @@
 package com.mytatvarnsdk.activity
 
+import android.annotation.SuppressLint
 import android.os.Bundle
 import android.view.View
+import android.webkit.WebChromeClient
+import android.webkit.WebView
+import android.webkit.WebViewClient
 import androidx.activity.OnBackPressedCallback
 import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
+import androidx.constraintlayout.widget.ConstraintLayout
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import com.mytatvarnsdk.R
 import com.mytatvarnsdk.databinding.ActivityVideoBinding
-import com.pierfrancescosoffritti.androidyoutubeplayer.core.player.YouTubePlayer
-import com.pierfrancescosoffritti.androidyoutubeplayer.core.player.listeners.AbstractYouTubePlayerListener
-import com.pierfrancescosoffritti.androidyoutubeplayer.core.player.listeners.FullscreenListener
-import com.pierfrancescosoffritti.androidyoutubeplayer.core.player.options.IFramePlayerOptions
+import com.mytatvarnsdk.utils.CustomerSupportConfig
 
 class VideoActivity : AppCompatActivity() {
     private lateinit var binding: ActivityVideoBinding
-    private var isFullscreen = false
-    private lateinit var youTubePlayer: YouTubePlayer
+    private var webView: WebView? = null
     private var videoId = ""
 
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -34,66 +35,111 @@ class VideoActivity : AppCompatActivity() {
         init()
     }
 
+    @SuppressLint("SetJavaScriptEnabled")
     private fun init() {
-        videoId = intent.getStringExtra("VideoId").toString()
+        videoId = resolveVideoId(intent.getStringExtra("VideoId"))
 
         onBackPressedDispatcher.addCallback(onBackPressedCallback)
 
-        val iFramePlayerOptions = IFramePlayerOptions.Builder()
-            .controls(1)
-            .fullscreen(1)
-            .build()
-        binding.youtubePlayerView.enableAutomaticInitialization = false
+        binding.youtubePlayerView.visibility = View.GONE
+        binding.fullScreenViewContainer.visibility = View.GONE
 
         binding.ivClose.setOnClickListener {
-            handleBackPressedManually()
+            finish()
         }
 
-        binding.youtubePlayerView.addFullscreenListener(object : FullscreenListener {
-            override fun onEnterFullscreen(fullscreenView: View, exitFullscreen: () -> Unit) {
-                isFullscreen = true
-
-                // the video will continue playing in fullscreenView
-                binding.youtubePlayerView.visibility = View.GONE
-                binding.fullScreenViewContainer.visibility = View.VISIBLE
-                binding.fullScreenViewContainer.addView(fullscreenView)
-
-                // optionally request landscape orientation
-                // requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
-            }
-
-            override fun onExitFullscreen() {
-                isFullscreen = false
-
-                // the video will continue playing in the player
-                binding.youtubePlayerView.visibility = View.VISIBLE
-                binding.fullScreenViewContainer.visibility = View.GONE
-                binding.fullScreenViewContainer.removeAllViews()
-            }
-        })
-
-        binding.youtubePlayerView.initialize(object : AbstractYouTubePlayerListener() {
-            override fun onReady(youTubePlayer: YouTubePlayer) {
-                this@VideoActivity.youTubePlayer = youTubePlayer
-                youTubePlayer.loadVideo(videoId, 0f)
+        val playerWebView = WebView(this)
+        webView = playerWebView
+        playerWebView.settings.apply {
+            javaScriptEnabled = true
+            domStorageEnabled = true
+            mediaPlaybackRequiresUserGesture = false
+        }
+        playerWebView.webViewClient = WebViewClient()
+        playerWebView.webChromeClient = WebChromeClient()
+
+        val layoutParams = ConstraintLayout.LayoutParams(
+            ConstraintLayout.LayoutParams.MATCH_PARENT,
+            ConstraintLayout.LayoutParams.MATCH_CONSTRAINT
+        ).apply {
+            topToBottom = R.id.ivClose
+            bottomToBottom = R.id.main
+            startToStart = R.id.main
+            endToEnd = R.id.main
+        }
+        (binding.root as ConstraintLayout).addView(playerWebView, layoutParams)
+        binding.ivClose.bringToFront()
+        binding.ivClose.elevation = 12f
+
+        val html = buildYouTubeEmbedHtml(videoId)
+        // Base URL + referrer meta are required by YouTube (errors 152-4 / 153).
+        playerWebView.loadDataWithBaseURL(
+            EMBED_BASE_URL,
+            html,
+            "text/html",
+            "UTF-8",
+            null
+        )
+    }
 
-            }
-        }, iFramePlayerOptions)
+    private fun resolveVideoId(raw: String?): String {
+        val value = raw?.trim().orEmpty()
+        if (value.isEmpty() || value == "null") {
+            return CustomerSupportConfig.DEFAULT_DEMO_VIDEO_ID
+        }
+        return CustomerSupportConfig.extractYouTubeVideoId(value) ?: value
+    }
 
-        lifecycle.addObserver(binding.youtubePlayerView)
+    private fun buildYouTubeEmbedHtml(videoId: String): String {
+        return """
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta name="viewport" content="width=device-width, initial-scale=1">
+                <meta name="referrer" content="strict-origin-when-cross-origin">
+                <style>
+                    html, body { margin: 0; padding: 0; background: #000; height: 100%; }
+                    .video-container { position: relative; width: 100%; height: 100%; }
+                    iframe {
+                        position: absolute;
+                        top: 0;
+                        left: 0;
+                        width: 100%;
+                        height: 100%;
+                        border: 0;
+                    }
+                </style>
+            </head>
+            <body>
+                <div class="video-container">
+                    <iframe
+                        src="https://www.youtube-nocookie.com/embed/$videoId?playsinline=1&rel=0&modestbranding=1"
+                        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+                        allowfullscreen
+                        referrerpolicy="strict-origin-when-cross-origin">
+                    </iframe>
+                </div>
+            </body>
+            </html>
+        """.trimIndent()
     }
 
     private val onBackPressedCallback = object : OnBackPressedCallback(true) {
         override fun handleOnBackPressed() {
-            handleBackPressedManually()
+            finish()
         }
     }
 
-    private fun handleBackPressedManually() {
-        if (isFullscreen) {
-            youTubePlayer.toggleFullscreen()
-        } else {
-            finish()
+    override fun onDestroy() {
+        webView?.apply {
+            stopLoading()
+            destroy()
         }
+        webView = null
+        super.onDestroy()
+    }
+
+    companion object {
+        private const val EMBED_BASE_URL = "https://www.mytatva.in/"
     }
-}
+}

package/android/src/main/java/com/mytatvarnsdk/network/AuthenticateSDKService.kt

@@ -1,12 +1,15 @@
 package com.mytatvarnsdk.network
 
 import android.util.Log
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.logModuleEvent
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.safeLogModuleEvent
 import com.mytatvarnsdk.utils.EncryptionUtil.getDecryptedData
 import com.mytatvarnsdk.utils.EncryptionUtil.getEncryptedText
 import com.mytatvarnsdk.utils.EncryptionUtil.getEncryptionIv
 import com.mytatvarnsdk.utils.EncryptionUtil.getEncryptionKey
 import com.mytatvarnsdk.utils.RetrofitInstance
 import com.mytatvarnsdk.utils.TATVA_ENVIRONMENT
+import io.sentry.SentryLogLevel
 import com.mytatvarnsdk.utils.TatvaEncryptionConfig.PROD_API_KEY
 import com.mytatvarnsdk.utils.TatvaEncryptionConfig.PROD_BASE_URL
 import com.mytatvarnsdk.utils.TatvaEncryptionConfig.PROD_ENC_IV
@@ -159,7 +162,29 @@ class AuthenticateSDKService(val scope: CoroutineScope) {
 
                 Log.d("API Response", "API response: $decryptedResponse")
 
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "AuthenticateSDKService.postDeviceData.success",
+                        message = "POST /cgm/connection succeeded",
+                        level = SentryLogLevel.INFO,
+                        jsonPayload = "request=$data | response=$decryptedResponse",
+                        attributes = mapOf("endpoint" to "/cgm/connection"),
+                        logsOnly = true,
+                    )
+                }
+
             } catch (e: HttpException) {
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "AuthenticateSDKService.postDeviceData.httpError",
+                        message = "POST /cgm/connection HTTP ${e.code()}",
+                        level = SentryLogLevel.WARN,
+                        jsonPayload = "request=$data",
+                        throwable = e,
+                        attributes = mapOf("http_code" to e.code().toString()),
+                        logsOnly = true,
+                    )
+                }
                 if (e.code() == 401) {
                     Log.d("API Error", "401 Unauthorized - Token: $token")
                     // Further handling if necessary
@@ -167,6 +192,17 @@ class AuthenticateSDKService(val scope: CoroutineScope) {
                     throw e
                 }
             } catch (e: Exception) {
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "AuthenticateSDKService.postDeviceData.fail",
+                        message = "POST /cgm/connection failed",
+                        level = SentryLogLevel.WARN,
+                        jsonPayload = "request=$data",
+                        throwable = e,
+                        attributes = mapOf("endpoint" to "/cgm/connection"),
+                        logsOnly = true,
+                    )
+                }
                 e.printStackTrace()
                 Log.d("API Response", "Exception: ${e.message}")
             } finally {
@@ -224,6 +260,56 @@ class AuthenticateSDKService(val scope: CoroutineScope) {
         }
     }
 
+    fun fetchCustomerSupportDetails(
+        environment: TATVA_ENVIRONMENT,
+        token: String,
+        onSuccess: (String) -> Unit = {},
+        onFailure: () -> Unit = {}
+    ) {
+        scope.launch {
+            try {
+                val apiServiceInterface = RetrofitInstance.getRetroInstance().create(
+                    ApiServiceInterface::class.java
+                )
+
+                val encryptionKey = getEncryptionKey(
+                    env = TATVA_ENVIRONMENT.PROD,
+                    prodEncKey = PROD_ENC_KEY,
+                    stagEncKey = STAGE_ENC_KEY
+                )
+
+                val encryptionIv = getEncryptionIv(
+                    env = TATVA_ENVIRONMENT.PROD, prodEncIv = PROD_ENC_IV, stagEncIv = STAGE_ENC_IV
+                )
+
+                val headers = mapOf(
+                    "api-key" to if (environment == TATVA_ENVIRONMENT.PROD) PROD_API_KEY else STAGE_API_KEY,
+                    "token" to token
+                )
+
+                val baseUrl = if (environment == TATVA_ENVIRONMENT.PROD) PROD_BASE_URL else STAGE_BASE_URL
+                val url = "$baseUrl/helper/customer_support_details"
+
+                Log.d("API Response", "Customer Support Details URL: $url")
+
+                val response = apiServiceInterface.getCgmStatus(url, headers).string()
+
+                val decryptedResponse = getDecryptedData(
+                    cipherText = response.toString(),
+                    encryptionKey = encryptionKey,
+                    encryptionIv = encryptionIv
+                ) ?: response.toString()
+
+                Log.d("API Response", "Customer Support Details Response: $decryptedResponse")
+                onSuccess(decryptedResponse)
+            } catch (e: Exception) {
+                Log.d("API Response", "Customer Support Details Exception: ${e.message}")
+                e.printStackTrace()
+                onFailure()
+            }
+        }
+    }
+
     fun verifyDevice(
         environment: TATVA_ENVIRONMENT,
         token: String,
@@ -267,8 +353,35 @@ class AuthenticateSDKService(val scope: CoroutineScope) {
 
                 Log.d("API Response", "Device Verification API Response: $decryptedResponse")
 
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "AuthenticateSDKService.verifyDevice.success",
+                        message = "GET device_verification succeeded | sensorId=$sensorId",
+                        level = SentryLogLevel.INFO,
+                        jsonPayload = "response=$decryptedResponse",
+                        attributes = mapOf("sensor_id" to sensorId),
+                        logsOnly = true,
+                    )
+                }
+
                 responseListener.onResponseSuccess(decryptedResponse)
             } catch (e: Exception) {
+                safeLogModuleEvent {
+                    val errorMessage =
+                        e.message ?: "GET device_verification failed | sensorId=$sensorId"
+                    logModuleEvent(
+                        where = "AuthenticateSDKService.verifyDevice.fail",
+                        message = "CGM journey error | screen=AuthenticateSDKService | $errorMessage",
+                        level = SentryLogLevel.WARN,
+                        throwable = e,
+                        attributes = mapOf(
+                            "error_message" to errorMessage,
+                            "screen" to "AuthenticateSDKService",
+                            "sensor_id" to sensorId,
+                        ),
+                        logsOnly = true,
+                    )
+                }
                 responseListener.onResponseFail()
                 e.printStackTrace()
                 Log.d("API Response", "Device Verification Exception: ${e.message}")

package/android/src/main/java/com/mytatvarnsdk/utils/CgmModuleSentryLog.kt

@@ -0,0 +1,205 @@
+package com.mytatvarnsdk.utils
+
+import android.util.Log
+import com.mytatvarnsdk.CgmTrackyLibModule
+import io.sentry.ScopeCallback
+import io.sentry.Sentry
+import io.sentry.SentryAttributes
+import io.sentry.SentryLevel
+import io.sentry.SentryLogLevel
+import io.sentry.logger.SentryLogParameters
+
+/**
+ * Shared Sentry logging for [com.mytatvarnsdk.CgmTrackyLibModule] and journey activities.
+ *
+ * Use:
+ * ```
+ * safeLogModuleEvent {
+ *     logModuleEvent("MyLocation", message = "...", level = SentryLogLevel.INFO)
+ * }
+ * ```
+ *
+ * Never throws — CGM flows must continue if logging fails.
+ */
+object CgmModuleSentryLog {
+    private const val MAX_SENTRY_DATA_EXTRA_CHARS = 16_384
+    private const val MAX_SENTRY_MESSAGE_DATA_CHARS = 2_000
+
+    private fun clipForSentry(text: String, maxChars: Int = MAX_SENTRY_DATA_EXTRA_CHARS): String =
+        try {
+            if (text.length <= maxChars) text else text.take(maxChars) + "…"
+        } catch (_: Throwable) {
+            ""
+        }
+
+    /** Wraps log preparation + emission so a bad payload cannot break CGM flows. */
+    inline fun safeLogModuleEvent(block: () -> Unit) {
+        try {
+            block()
+        } catch (t: Throwable) {
+            try {
+                Log.w("logModuleEvent", "Failed to prepare Sentry log: ${t.message}", t)
+            } catch (_: Throwable) {
+            }
+        }
+    }
+
+    /**
+     * Structured Sentry log (like RN `Sentry.logger.info/warn/error`).
+     * Uses the host app's Sentry client (never call Sentry.init here).
+     *
+     * @param logsOnly When true, writes to Sentry Logs only — never creates Issues
+     *   (use for journey QR/bind/scan errors shown to the user).
+     */
+    fun logModuleEvent(
+        where: String,
+        message: String = "",
+        level: SentryLogLevel = SentryLogLevel.INFO,
+        jsonPayload: String? = null,
+        throwable: Throwable? = null,
+        attributes: Map<String, String> = emptyMap(),
+        logsOnly: Boolean = false,
+    ) {
+        try {
+            if (!Sentry.isEnabled()) {
+                Log.w("logModuleEvent", "Sentry not initialized — skipping [$where]")
+                return
+            }
+
+            val resolvedMessage = when {
+                message.isNotEmpty() -> message
+                throwable != null -> {
+                    val typeName = throwable.javaClass.simpleName ?: "Throwable"
+                    "$typeName: ${throwable.message ?: ""}"
+                }
+                else -> where
+            }
+            val mergedAttributes = try {
+                attributes.toMutableMap()
+            } catch (_: Throwable) {
+                mutableMapOf()
+            }
+            throwable?.let {
+                mergedAttributes["exception"] = it.javaClass.simpleName ?: "Throwable"
+                mergedAttributes["exception_message"] = it.message ?: ""
+            }
+
+            val clippedJson = jsonPayload?.let { clipForSentry(it) }
+            val logMessage = clipForSentry(
+                "CgmTrackyLib: $where | $resolvedMessage",
+                MAX_SENTRY_MESSAGE_DATA_CHARS
+            )
+
+            val env = CgmTrackyLibModule.env
+            val sentryAttributes = mutableMapOf<String, Any>(
+                "cgm_tracky_lib" to "true",
+                "location" to where,
+            )
+            if (env.isNotEmpty()) {
+                sentryAttributes["tatva_env"] = env
+            }
+            clippedJson?.let { sentryAttributes["json"] = it }
+            mergedAttributes.forEach { (key, value) ->
+                try {
+                    sentryAttributes[key] = clipForSentry(value, 500)
+                } catch (_: Throwable) {
+                    sentryAttributes[key] = ""
+                }
+            }
+
+            val logsEnabled = try {
+                Sentry.getCurrentScopes()?.options?.logs?.isEnabled == true
+            } catch (_: Throwable) {
+                false
+            }
+
+            if (logsEnabled) {
+                val logParams = SentryLogParameters.create(
+                    SentryAttributes.fromMap(sentryAttributes)
+                )
+                logParams.origin = "cgm-tracky-lib"
+                Sentry.logger().log(level, logParams, logMessage)
+                if (!logsOnly && throwable != null && level >= SentryLogLevel.ERROR) {
+                    captureModuleException(where, throwable, sentryAttributes)
+                }
+            } else if (!logsOnly) {
+                captureModuleEventFallback(where, logMessage, level, throwable, sentryAttributes)
+            } else {
+                Log.w("logModuleEvent", "[$where] $logMessage (native Sentry Logs disabled)")
+            }
+        } catch (sentryEx: Throwable) {
+            try {
+                Log.w(
+                    "logModuleEvent",
+                    "Sentry logger failed for [$where]: ${sentryEx.message}",
+                    sentryEx
+                )
+                Log.e("CgmTrackyLib", "[$where]", throwable ?: sentryEx)
+            } catch (_: Throwable) {
+            }
+        }
+    }
+
+    private fun mapLogLevelToEventLevel(level: SentryLogLevel): SentryLevel = when (level) {
+        SentryLogLevel.TRACE, SentryLogLevel.DEBUG -> SentryLevel.DEBUG
+        SentryLogLevel.INFO -> SentryLevel.INFO
+        SentryLogLevel.WARN -> SentryLevel.WARNING
+        SentryLogLevel.ERROR -> SentryLevel.ERROR
+        SentryLogLevel.FATAL -> SentryLevel.FATAL
+    }
+
+    private fun applyModuleScopeExtras(
+        where: String,
+        attributes: Map<String, Any>
+    ): ScopeCallback = ScopeCallback { scope ->
+        scope.setTag("cgm_tracky_lib", "true")
+        scope.setTag("location", where)
+        val env = CgmTrackyLibModule.env
+        if (env.isNotEmpty()) {
+            scope.setTag("tatva_env", env)
+        }
+        attributes.forEach { (key, value) ->
+            try {
+                scope.setExtra(key, value.toString())
+            } catch (_: Throwable) {
+            }
+        }
+    }
+
+    private fun captureModuleEventFallback(
+        where: String,
+        message: String,
+        level: SentryLogLevel,
+        throwable: Throwable?,
+        attributes: Map<String, Any>
+    ) {
+        try {
+            val scopeCallback = applyModuleScopeExtras(where, attributes)
+            if (throwable != null) {
+                Sentry.captureException(throwable, scopeCallback)
+            } else {
+                Sentry.captureMessage(message, mapLogLevelToEventLevel(level), scopeCallback)
+            }
+        } catch (t: Throwable) {
+            try {
+                Log.w("logModuleEvent", "Sentry fallback capture failed for [$where]: ${t.message}", t)
+            } catch (_: Throwable) {
+            }
+        }
+    }
+
+    private fun captureModuleException(
+        where: String,
+        throwable: Throwable,
+        attributes: Map<String, Any>
+    ) {
+        try {
+            Sentry.captureException(throwable, applyModuleScopeExtras(where, attributes))
+        } catch (t: Throwable) {
+            try {
+                Log.w("logModuleEvent", "Sentry captureException failed for [$where]: ${t.message}", t)
+            } catch (_: Throwable) {
+            }
+        }
+    }
+}

package/android/src/main/java/com/mytatvarnsdk/utils/CgmSentryLog.kt

@@ -0,0 +1,28 @@
+package com.mytatvarnsdk.utils
+
+import io.sentry.SentryLogLevel
+
+/**
+ * Thin compatibility wrapper for [com.mytatvarnsdk.CgmTrackyLibModule] journey launch calls.
+ * Journey activities should use [CgmModuleSentryLog.safeLogModuleEvent] + [CgmModuleSentryLog.logModuleEvent] directly.
+ */
+object CgmSentryLog {
+    fun logJourneyLaunch(where: String, isReconnect: Boolean, envType: String) {
+        try {
+            CgmModuleSentryLog.safeLogModuleEvent {
+                CgmModuleSentryLog.logModuleEvent(
+                    where = where,
+                    message = "CGM journey launched | isReconnect=$isReconnect | env=$envType",
+                    level = SentryLogLevel.INFO,
+                    attributes = mapOf(
+                        "is_reconnect" to isReconnect.toString(),
+                        "env_type" to envType,
+                    ),
+                    logsOnly = true,
+                )
+            }
+        } catch (_: Throwable) {
+            // Never propagate — CGM launch must continue.
+        }
+    }
+}