@rentlydev/rently-tuya 0.1.0

package/android/src/main/java/com/rentlytuya/tuya/ScreenCapture.kt

@@ -0,0 +1,244 @@
+package com.rentlytuya.tuya
+
+import android.Manifest
+import android.app.Activity
+import android.content.ContentValues
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import android.util.Log
+import com.rentlytuya.tuya.Tuya.TAG
+import com.rentlytuya.util.Airbrake
+import com.rentlytuya.util.PermissionHandler
+import com.thingclips.smart.camera.camerasdk.thingplayer.callback.OperationDelegateCallBack
+import kotlinx.coroutines.suspendCancellableCoroutine
+import java.io.File
+import kotlin.coroutines.resume
+
+object ScreenCapture {
+
+  private var videoFilePath: String? = null
+
+  suspend fun screenShot(context: Context): Boolean {
+    return if (isStoragePermissionGranted(context)) {
+      val directory: File? =
+        Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES)
+      directory?.let {
+        val fileName = "screenshot_${System.currentTimeMillis()}.jpg"
+        val file = File(it, fileName)
+        val path = file.absolutePath
+
+        suspendCancellableCoroutine<Boolean> { continuation ->
+          Tuya.mCameraP2P?.snapshot(
+            path,
+            context,
+            object : OperationDelegateCallBack {
+              override fun onSuccess(sessionId: Int, requestId: Int, data: String) {
+                try {
+                  Log.i(
+                    TAG,
+                    "Screenshot success: SessionID: $sessionId, RequestId: $requestId, Data: $data"
+                  )
+                  val bitmap = BitmapFactory.decodeFile(data)
+                  saveImageToStorage(bitmap, context)
+                  continuation.resume(true)
+                } catch (e: Exception) {
+                  Log.i(TAG, "Error in saving image: ${e.message.toString()}")
+                  continuation.resume(false)
+                }
+              }
+
+              override fun onFailure(sessionId: Int, requestId: Int, errCode: Int) {
+                Airbrake.logMessage(
+                  title = "Screenshot Capture Failed",
+                  message = "Error Code: $errCode",
+                  additionalInfo = mapOf(
+                    "sessionId" to sessionId.toString(),
+                    "requestId" to requestId.toString()
+                  )
+                )
+                continuation.resume(false)
+              }
+            })
+        }
+      } ?: run {
+        Log.i(TAG, "Screenshot Directory is null")
+        false
+      }
+    } else {
+      requestPermission(context)
+      false
+    }
+  }
+
+  fun startRecording(
+    context: Context,
+    setRecording: (value: Boolean) -> Unit
+  ) {
+    if (isStoragePermissionGranted(context)) {
+      try {
+        val directory: File? =
+          Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES)
+        directory?.let {
+          val fileName = "recording_${System.currentTimeMillis()}"
+          val path = directory.absolutePath + File.separator
+          videoFilePath = path + fileName
+
+          Tuya.mCameraP2P?.startRecordLocalMp4(
+            path,
+            fileName,
+            context,
+            object : OperationDelegateCallBack {
+              override fun onSuccess(sessionId: Int, requestId: Int, data: String) {
+                Log.i(
+                  TAG,
+                  "Recording Started: SessionID: $sessionId, RequestId: $requestId, Data: $data"
+                )
+                setRecording(true)
+              }
+
+              override fun onFailure(sessionId: Int, requestId: Int, errCode: Int) {
+                setRecording(false)
+                Airbrake.logMessage(
+                  title = "Start Recording Failed",
+                  message = "Error Code: $errCode",
+                  additionalInfo = mapOf(
+                    "sessionId" to sessionId.toString(),
+                    "requestId" to requestId.toString()
+                  )
+                )
+              }
+            })
+
+        } ?: run {
+          Log.i(TAG, "Recording Directory is null")
+          setRecording(false)
+        }
+      } catch (e: Exception) {
+        setRecording(false)
+        Log.i(TAG, "Error in start recording: ${e.message}")
+      }
+    } else {
+      requestPermission(context)
+    }
+  }
+
+  suspend fun stopRecording(
+    context: Context,
+    setRecording: (value: Boolean) -> Unit
+  ): Boolean {
+
+    return suspendCancellableCoroutine { continuation ->
+      Tuya.mCameraP2P?.stopRecordLocalMp4(object : OperationDelegateCallBack {
+        override fun onSuccess(sessionId: Int, requestId: Int, data: String) {
+          try {
+            videoFilePath?.let { path ->
+              saveVideoToMedia(path, context)
+            }
+            continuation.resume(true)
+            setRecording(false)
+            Log.i(
+              TAG,
+              "Stop Recording Success: SessionID: $sessionId, RequestId: $requestId, Data: $data\""
+            )
+          } catch (e: Exception) {
+            setRecording(false)
+            continuation.resume(false)
+            Log.e(TAG, "Exception while saving video: ${e.message}")
+          }
+        }
+
+        override fun onFailure(sessionId: Int, requestId: Int, errCode: Int) {
+          setRecording(!(errCode == -30011 || errCode == -30012))
+          Airbrake.logMessage(
+            title = "Stop Recording Failed",
+            message = "Error Code: $errCode",
+            additionalInfo = mapOf(
+              "sessionId" to sessionId.toString(),
+              "requestId" to requestId.toString()
+            )
+          )
+          continuation.resume(false)
+        }
+      })
+    }
+  }
+
+  private fun saveImageToStorage(bitmap: Bitmap, context: Context) {
+    try {
+      val filename = "screenshot_${System.currentTimeMillis()}.jpg"
+      context.contentResolver?.also { resolver ->
+        val contentValues = ContentValues().apply {
+          put(MediaStore.MediaColumns.DISPLAY_NAME, filename)
+          put(MediaStore.MediaColumns.MIME_TYPE, "image/jpg")
+          put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_PICTURES)
+        }
+
+        val imageUri: Uri? =
+          resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues)
+        imageUri?.let { uri ->
+          resolver.openOutputStream(uri)?.use { fos ->
+            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos)
+          }
+          Log.i(TAG, "Screenshot saved to: $uri")
+        }
+      }
+    } catch (e: Exception) {
+      Airbrake.logMessage(
+        title = "Save image to Storage Failed",
+        message = "Error: ${e.message}"
+      )
+    }
+  }
+
+  private fun saveVideoToMedia(filePath: String, context: Context) {
+    try {
+      context.contentResolver?.also { resolver ->
+        val fileName = "recording_${System.currentTimeMillis()}.mp4"
+        val contentValues = ContentValues().apply {
+          put(MediaStore.MediaColumns.DISPLAY_NAME, fileName)
+          put(MediaStore.MediaColumns.MIME_TYPE, "video/mp4")
+          put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_MOVIES)
+        }
+
+        val videoUri: Uri? =
+          resolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, contentValues)
+        videoUri?.let { uri ->
+          resolver.openOutputStream(uri)?.use { fos ->
+            File("$filePath.mp4").inputStream().use { fis ->
+              fis.copyTo(fos)
+            }
+          }
+          Log.i(TAG, "Video saved to: $uri")
+        }
+      }
+    } catch (e: Exception) {
+      Airbrake.logMessage(
+        title = "Save video to Storage Failed",
+        message = "Error: ${e.message}"
+      )
+    }
+  }
+
+  private fun isStoragePermissionGranted(context: Context): Boolean {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      true
+    } else {
+      PermissionHandler.isPermissionGranted(context, Manifest.permission.WRITE_EXTERNAL_STORAGE)
+    }
+  }
+
+  private fun requestPermission(context: Context) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+      PermissionHandler.requestPermission(
+        activity = context as Activity,
+        permission = Manifest.permission.WRITE_EXTERNAL_STORAGE,
+        requestCode = 10
+      )
+    }
+  }
+}