react-native-mytatva-rn-sdk 1.2.4 → 1.2.5

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

@@ -0,0 +1,367 @@
+package com.mytatvarnsdk.activity
+
+import android.Manifest
+import android.app.AlertDialog
+import android.app.Dialog
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.graphics.Color
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.view.Window
+import androidx.activity.OnBackPressedCallback
+import androidx.activity.enableEdgeToEdge
+import androidx.annotation.RequiresApi
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.drawable.toDrawable
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import cgmblelib.utils.ConstantsLibrary
+import com.mytatvarnsdk.base.BasePermissionActivity
+import com.mytatvarnsdk.databinding.ActivityPermissionBinding
+import com.mytatvarnsdk.databinding.ExitDialogBottomsheetBinding
+
+
+class PermissionActivity : BasePermissionActivity() {
+  private lateinit var binding: ActivityPermissionBinding
+  private val LOCATION_REQUEST_CODE = 101
+  private val BLUETOOTH_REQUEST_CODE = 102
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    binding = ActivityPermissionBinding.inflate(layoutInflater)
+
+    enableEdgeToEdge()
+    ViewCompat.setOnApplyWindowInsetsListener(binding.rlPopBottom) { v, insets ->
+      val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+      v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
+      insets
+    }
+    setContentView(binding.root)
+
+    initialize()
+  }
+
+  override fun getPermission(): Array<out Array<out String?>?>? {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      return arrayOf<Array<String?>?>(ConstantsLibrary.BLUETOOTH_S)
+    } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      return arrayOf<Array<String?>?>(
+        ConstantsLibrary.LOCAL_PERMISSION,
+        ConstantsLibrary.BACKGROUND_LOCATION_Q
+      )
+    } else {
+      return arrayOf<Array<String?>?>(ConstantsLibrary.LOCAL_PERMISSION)
+    }
+  }
+
+  override fun onPermissionRequestSuccess() {
+  }
+
+  override fun onPermissionRequestFail(vararg permission: String?) {
+  }
+
+  override fun onPermissionRequestFailForever(vararg permission: String?) {
+  }
+
+  fun isBluetoothPermissionGranted(context: Context): Boolean {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      val connectPermission = ContextCompat.checkSelfPermission(
+        context,
+        android.Manifest.permission.BLUETOOTH_CONNECT
+      ) == PackageManager.PERMISSION_GRANTED
+
+      val scanPermission = ContextCompat.checkSelfPermission(
+        context,
+        android.Manifest.permission.BLUETOOTH_SCAN
+      ) == PackageManager.PERMISSION_GRANTED
+
+      connectPermission && scanPermission
+    } else {
+      // For Android 11 and below, permission is granted at install time
+      true
+    }
+  }
+
+  fun isLocationPermissionGranted(context: Context): Boolean {
+    val fineLocationGranted = ContextCompat.checkSelfPermission(
+      context,
+      android.Manifest.permission.ACCESS_FINE_LOCATION
+    ) == PackageManager.PERMISSION_GRANTED
+
+    val coarseLocationGranted = ContextCompat.checkSelfPermission(
+      context,
+      android.Manifest.permission.ACCESS_COARSE_LOCATION
+    ) == PackageManager.PERMISSION_GRANTED
+
+    return fineLocationGranted || coarseLocationGranted
+  }
+
+
+  private fun initialize() {
+    binding.switchBluetooth.isChecked = isBluetoothPermissionGranted(this)
+    binding.switchLocation.isChecked = isLocationPermissionGranted(this)
+
+    binding.switchBluetooth.setOnCheckedChangeListener { _, isChecked ->
+      if (isChecked) {
+        requestBluetoothPermission()
+      }
+    }
+
+    binding.switchLocation.setOnCheckedChangeListener { _, isChecked ->
+      if (isChecked) {
+        requestLocationPermission()
+      }
+    }
+
+    binding.commonButton.btnProceed.setOnClickListener {
+      startActivity(
+        Intent(this@PermissionActivity, SearchTransmitterActivity::class.java).putExtra(
+          "IsForReconnect",
+          intent.getBooleanExtra("IsForReconnect", false)
+        )
+      )
+      finish()
+    }
+
+    binding.toolbar.btnWhatsapp.setOnClickListener {
+      startActivity(Intent(this, HelpActivity::class.java))
+    }
+
+    binding.toolbar.btnClose.setOnClickListener {
+      openExitDialog()
+    }
+
+    val callback: OnBackPressedCallback = object : OnBackPressedCallback(true) {
+      override fun handleOnBackPressed() {
+        openExitDialog()
+      }
+    }
+    onBackPressedDispatcher.addCallback(this, callback)
+  }
+
+
+  private fun openExitDialog() {
+    val binding = ExitDialogBottomsheetBinding.inflate(layoutInflater)
+
+    val dialog = Dialog(this)
+    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE)
+    dialog.setContentView(binding.root)
+
+    val window = dialog.window
+    window?.setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+    window?.setGravity(Gravity.BOTTOM)
+    window?.setBackgroundDrawable(Color.TRANSPARENT.toDrawable())
+
+    binding.btnExit.tvProceed.text = "Exit"
+
+    binding.btnExit.root.setOnClickListener(View.OnClickListener { v: View? ->
+      finish()
+      dialog.dismiss()
+    })
+
+    binding.btnCancel.root.setOnClickListener(View.OnClickListener { v: View? ->
+      dialog.dismiss()
+    })
+
+    binding.closeButton.setOnClickListener(View.OnClickListener { v: View? ->
+      dialog.dismiss()
+    })
+
+    dialog.show()
+  }
+
+
+  private fun requestForegroundLocationPermission() {
+    val locationPermissions = PermissionUtils.LOCAL_PERMISSION
+
+    if (hasPermissions(locationPermissions)) {
+      onForegroundLocationGranted()
+    } else {
+      ActivityCompat.requestPermissions(
+        this,
+        locationPermissions,
+        LOCATION_REQUEST_CODE
+      )
+    }
+  }
+
+  private fun requestLocationPermission() {
+    val permissions = mutableListOf(*PermissionUtils.LOCAL_PERMISSION)
+
+    val permissionArray = permissions.toTypedArray()
+
+    if (hasPermissions(permissionArray)) {
+      onLocationPermissionGranted()
+    } else {
+      val rationaleNeeded = permissionArray.any {
+        ActivityCompat.shouldShowRequestPermissionRationale(this, it)
+      }
+
+      if (rationaleNeeded) {
+        showPermissionRationale(
+          title = "Location Permission Needed",
+          message = "We need location access for Bluetooth scanning.",
+          onProceed = {
+            ActivityCompat.requestPermissions(this, permissionArray, LOCATION_REQUEST_CODE)
+          }
+        )
+      } else {
+        ActivityCompat.requestPermissions(this, permissionArray, LOCATION_REQUEST_CODE)
+      }
+    }
+  }
+
+  private fun requestBluetoothPermission() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      val permissions = PermissionUtils.BLUETOOTH_S
+
+      if (hasPermissions(permissions)) {
+        onBluetoothPermissionGranted()
+      } else {
+        val rationaleNeeded = permissions.any {
+          ActivityCompat.shouldShowRequestPermissionRationale(this, it)
+        }
+
+        if (rationaleNeeded) {
+          showPermissionRationale(
+            title = "Bluetooth Permission Needed",
+            message = "We need Bluetooth access to connect your device.",
+            onProceed = {
+              ActivityCompat.requestPermissions(this, permissions, BLUETOOTH_REQUEST_CODE)
+            }
+          )
+        } else {
+          ActivityCompat.requestPermissions(this, permissions, BLUETOOTH_REQUEST_CODE)
+        }
+      }
+    } else {
+      onBluetoothPermissionGranted()
+    }
+  }
+
+  private fun showPermissionRationale(title: String, message: String, onProceed: () -> Unit) {
+    AlertDialog.Builder(this)
+      .setTitle(title)
+      .setMessage(message)
+      .setPositiveButton("OK") { _, _ -> onProceed() }
+      .setNegativeButton("Cancel", null)
+      .show()
+  }
+
+
+  private fun hasPermissions(permissions: Array<String>): Boolean {
+    return permissions.all {
+      ContextCompat.checkSelfPermission(this, it) == PackageManager.PERMISSION_GRANTED
+    }
+  }
+
+  private fun areAllPermissionsGranted(): Boolean {
+    val requiredPermissions = mutableListOf<String>()
+
+    // Add Bluetooth permissions
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      requiredPermissions.addAll(PermissionUtils.BLUETOOTH_S)
+    }
+
+    // Add location permissions
+    requiredPermissions.addAll(PermissionUtils.LOCAL_PERMISSION)
+
+    return requiredPermissions.all {
+      ContextCompat.checkSelfPermission(this, it) == PackageManager.PERMISSION_GRANTED
+    }
+  }
+
+  private fun updateProceedButtonState() {
+    binding.commonButton.btnProceed.isEnabled = areAllPermissionsGranted()
+    if (areAllPermissionsGranted()) {
+      binding.commonButton.btnProceed.alpha = 1f
+    } else {
+      binding.commonButton.btnProceed.alpha = 0.5f
+    }
+  }
+
+  private fun onForegroundLocationGranted() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q &&
+      ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+      != PackageManager.PERMISSION_GRANTED
+    ) {
+      onLocationPermissionGranted()
+    } else {
+      Log.d("Permission", "All location permissions granted")
+    }
+  }
+
+  override fun onRequestPermissionsResult(
+    requestCode: Int,
+    permissions: Array<out String>,
+    grantResults: IntArray
+  ) {
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    val allGranted = grantResults.all { it == PackageManager.PERMISSION_GRANTED }
+
+    when (requestCode) {
+//      LOCATION_REQUEST_CODE -> {
+//        if (grantResults.all { it == PackageManager.PERMISSION_GRANTED }) {
+//          onForegroundLocationGranted()
+//        } else {
+//          Log.d("Permission", "Foreground location denied")
+//        }
+//      }
+
+      LOCATION_REQUEST_CODE -> {
+        if (allGranted) {
+          onLocationPermissionGranted()
+        }
+      }
+
+      BLUETOOTH_REQUEST_CODE -> {
+        if (allGranted) {
+          onBluetoothPermissionGranted()
+        }
+      }
+    }
+    updateProceedButtonState()
+  }
+
+  private fun onLocationPermissionGranted() {
+    updateProceedButtonState()
+    // Start location-based action
+  }
+
+  private fun onBluetoothPermissionGranted() {
+    updateProceedButtonState()
+    // Start Bluetooth device scan or connect
+  }
+
+  override fun onResume() {
+    super.onResume()
+    updateProceedButtonState()
+  }
+
+}
+
+object PermissionUtils {
+  @RequiresApi(Build.VERSION_CODES.S)
+  val BLUETOOTH_S = arrayOf(
+    Manifest.permission.BLUETOOTH_ADVERTISE,
+    Manifest.permission.BLUETOOTH_CONNECT,
+    Manifest.permission.BLUETOOTH_SCAN
+  )
+
+  val LOCAL_PERMISSION = arrayOf(
+    Manifest.permission.ACCESS_FINE_LOCATION,
+    Manifest.permission.ACCESS_COARSE_LOCATION
+  )
+
+
+  val CAMERA_PERMISSION = arrayOf(
+    Manifest.permission.CAMERA
+  )
+}

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

@@ -0,0 +1,103 @@
+package com.mytatvarnsdk.activity
+
+import android.app.Dialog
+import android.content.Intent
+import android.graphics.Color
+import android.os.Bundle
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.view.Window
+import androidx.activity.OnBackPressedCallback
+import androidx.activity.enableEdgeToEdge
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.graphics.drawable.toDrawable
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.resource.bitmap.RoundedCorners
+import com.mytatvarnsdk.R
+import com.mytatvarnsdk.databinding.ActivityPlaceSensorBinding
+import com.mytatvarnsdk.databinding.ExitDialogBottomsheetBinding
+
+class PlaceSensorActivity : AppCompatActivity() {
+  private lateinit var binding: ActivityPlaceSensorBinding
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    binding = ActivityPlaceSensorBinding.inflate(layoutInflater)
+    enableEdgeToEdge()
+    setContentView(binding.root)
+    ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
+      val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+      v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
+      insets
+    }
+    init()
+  }
+
+  private fun init() {
+    Glide.with(this)
+      .load(R.drawable.img_male)
+      .transform(RoundedCorners(50))
+      .into(binding.ivTransmitter)
+
+    Glide.with(this)
+      .asGif()
+      .load(R.drawable.ic_play_gif)
+      .into(binding.ivPlay)
+
+    binding.toolbar.btnWhatsapp.setOnClickListener {
+      startActivity(Intent(this, HelpActivity::class.java))
+    }
+
+    binding.commonButton.tvProceed.text = "I Have Placed The Sensor"
+    binding.commonButton.btnProceed.setOnClickListener {
+      startActivity(Intent(this, PlaceTransmitterActivity::class.java))
+      finish()
+    }
+
+    binding.toolbar.btnClose.setOnClickListener {
+      openExitDialog()
+    }
+
+    val callback: OnBackPressedCallback = object : OnBackPressedCallback(true) {
+      override fun handleOnBackPressed() {
+        openExitDialog()
+      }
+    }
+    onBackPressedDispatcher.addCallback(this, callback)
+  }
+
+  private fun openExitDialog() {
+    val binding = ExitDialogBottomsheetBinding.inflate(layoutInflater)
+
+    val dialog = Dialog(this)
+    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE)
+    dialog.setContentView(binding.root)
+
+    val window = dialog.window
+    window?.setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+    window?.setGravity(Gravity.BOTTOM)
+    window?.setBackgroundDrawable(Color.TRANSPARENT.toDrawable())
+
+    binding.btnExit.tvProceed.text = "Exit"
+
+    binding.btnExit.root.setOnClickListener(View.OnClickListener { v: View? ->
+      finish()
+      dialog.dismiss()
+    })
+
+    binding.btnCancel.root.setOnClickListener(View.OnClickListener { v: View? ->
+      dialog.dismiss()
+    })
+
+    binding.closeButton.setOnClickListener(View.OnClickListener { v: View? ->
+      dialog.dismiss()
+    })
+
+    dialog.show()
+  }
+
+
+}

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

@@ -0,0 +1,145 @@
+package com.mytatvarnsdk.activity
+
+import android.app.Dialog
+import android.content.Intent
+import android.graphics.Color
+import android.os.Bundle
+import android.util.Log
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.view.Window
+import androidx.activity.OnBackPressedCallback
+import androidx.activity.enableEdgeToEdge
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.graphics.drawable.toDrawable
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.resource.bitmap.RoundedCorners
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.CatalystInstance
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.mytatvarnsdk.CgmTrackyLibModule
+import com.mytatvarnsdk.R
+import com.mytatvarnsdk.databinding.ActivityPlaceTransmitterBinding
+import com.mytatvarnsdk.databinding.ExitDialogBottomsheetBinding
+
+class PlaceTransmitterActivity : AppCompatActivity() {
+  private lateinit var binding: ActivityPlaceTransmitterBinding
+  private val reactContext = CgmTrackyLibModule.mReactContext
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    binding = ActivityPlaceTransmitterBinding.inflate(layoutInflater)
+    enableEdgeToEdge()
+    setContentView(binding.root)
+    ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
+      val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+      v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
+      insets
+    }
+    init()
+  }
+
+  private fun init() {
+    Glide.with(this)
+      .load(R.drawable.img_female)
+      .transform(RoundedCorners(50))
+      .into(binding.ivTransmitter)
+
+    Glide.with(this)
+      .asGif()
+      .load(R.drawable.ic_play_gif)
+      .into(binding.ivPlay)
+
+    binding.commonButton.tvProceed.text = "Complete"
+
+    binding.commonButton.btnProceed.setOnClickListener {
+      sendDataToRN("")
+      finish()
+    }
+
+    binding.toolbar.btnWhatsapp.setOnClickListener {
+      startActivity(Intent(this, HelpActivity::class.java))
+    }
+
+    binding.toolbar.btnClose.setOnClickListener {
+      openExitDialog()
+    }
+
+    val callback: OnBackPressedCallback = object : OnBackPressedCallback(true) {
+      override fun handleOnBackPressed() {
+        openExitDialog()
+      }
+    }
+    onBackPressedDispatcher.addCallback(this, callback)
+  }
+
+  private fun openExitDialog() {
+    val binding = ExitDialogBottomsheetBinding.inflate(layoutInflater)
+
+    val dialog = Dialog(this)
+    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE)
+    dialog.setContentView(binding.root)
+
+    val window = dialog.window
+    window?.setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+    window?.setGravity(Gravity.BOTTOM)
+    window?.setBackgroundDrawable(Color.TRANSPARENT.toDrawable())
+
+    binding.btnExit.tvProceed.text = "Exit"
+
+    binding.btnExit.root.setOnClickListener(View.OnClickListener { v: View? ->
+      finish()
+      dialog.dismiss()
+    })
+
+    binding.btnCancel.root.setOnClickListener(View.OnClickListener { v: View? ->
+      dialog.dismiss()
+    })
+
+    binding.closeButton.setOnClickListener(View.OnClickListener { v: View? ->
+      dialog.dismiss()
+    })
+
+    dialog.show()
+  }
+
+  private fun sendDataToRN(data: String) {
+    if (reactContext != null) {
+      try {
+        val catalystInstance: CatalystInstance = reactContext.catalystInstance
+        val module = catalystInstance.getNativeModule(CgmTrackyLibModule::class.java)
+
+        if (module == null) {
+          sendDataToRNDirectly("", "WARM_PERIOD_STARTED")
+          Log.d("sendDataToRN: ", "Module null")
+        } else {
+          module.sendDataToReact(data, "WARM_PERIOD_STARTED", "cgmDeviceEvent")
+          Log.d("sendDataToRN: ", "Module is not null")
+        }
+      } catch (e: Exception) {
+        Log.e("sendDataToRN: Error ", e.message.toString())
+      }
+    } else {
+      Log.e("TrackyActivity", "ReactApplicationContext is null")
+    }
+  }
+
+
+  private fun sendDataToRNDirectly(data: String, status: String) {
+    try {
+      val map: WritableMap = Arguments.createMap().apply {
+        putString("data", data)
+        putString("status", status)
+      }
+
+      reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        ?.emit("cgmDeviceEvent", map)
+    } catch (e: Exception) {
+      Log.e("sendDataToRNDirectly", "Error sending data to React", e)
+    }
+  }
+}