安卓kotlin JetPack Compose 实现摄像头监控画面变化并录制视频

import android.content.Context
import android.net.Uri
import android.os.Handler
import android.os.Looper
import android.util.Log
import androidx.camera.core.*
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.camera.video.*
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.core.content.ContextCompat
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import java.io.File
import java.text.SimpleDateFormat
import java.util.*
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors

class CameraViewModel : ViewModel() {
    var isRecording = mutableStateOf(false)
    var previewUri = mutableStateOf<Uri?>(null)
    private var videoCapture: VideoCapture<Recorder>? = null
    private var recording: Recording? = null
    private lateinit var cameraExecutor: ExecutorService

    fun startCamera(context: Context, previewView: PreviewView) {
        val cameraProviderFuture = ProcessCameraProvider.getInstance(context)

        cameraProviderFuture.addListener({
            val cameraProvider = cameraProviderFuture.get()
            val preview = Preview.Builder().build().also {
                it.setSurfaceProvider(previewView.surfaceProvider)
            }

            val recorder = Recorder.Builder()
                .setQualitySelector(QualitySelector.from(Quality.HIGHEST))
                .build()

            videoCapture = VideoCapture.withOutput(recorder)
            val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

            try {
                cameraProvider.unbindAll()
                cameraProvider.bindToLifecycle(
                    context as androidx.lifecycle.LifecycleOwner,
                    cameraSelector,
                    preview,
                    videoCapture
                )
            } catch (exc: Exception) {
                Log.e("CameraViewModel", "Use case binding failed", exc)
            }
            
            detectMotionAndRecord(context) // Start detecting motion and recording
        }, ContextCompat.getMainExecutor(context))

        cameraExecutor = Executors.newSingleThreadExecutor()
    }

    private fun detectMotionAndRecord(context: Context) {
        var prevFrame: ImageProxy? = null
        val handler = Handler(Looper.getMainLooper())
        val delayMillis = 100L

        val captureRunnable = object : Runnable {
            override fun run() {
                if (isRecording.value) {
                    recording?.stop()
                    isRecording.value = false
                }

                // Capture frame
                videoCapture?.takePicture(cameraExecutor, ContextCompat.getMainExecutor(context), object : ImageCapture.OnImageCapturedCallback() {
                    override fun onCaptureSuccess(image: ImageProxy) {
                        if (prevFrame == null) {
                            prevFrame = image
                        } else {
                            // Compare frames
                            val isDifferent = compareFrames(prevFrame!!, image)
                            prevFrame?.close()
                            prevFrame = image

                            if (isDifferent) {
                                if (!isRecording.value) {
                                    startRecording(context)
                                    isRecording.value = true
                                }
                            } else {
                                if (System.currentTimeMillis() - recordingStartTime > 5000) {
                                    recording?.stop()
                                    isRecording.value = false
                                }
                            }
                        }
                        handler.postDelayed(this, delayMillis)
                    }

                    override fun onError(exception: ImageCaptureException) {
                        Log.e("CameraViewModel", "Image capture failed", exception)
                    }
                })
            }
        }
        handler.post(captureRunnable)
    }

    private var recordingStartTime = 0L

    private fun compareFrames(frame1: ImageProxy, frame2: ImageProxy): Boolean {
        // Implement frame comparison logic (e.g., by comparing pixel values)
        return true // example return, implement actual comparison
    }

    private fun startRecording(context: Context) {
        val fileName = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US)
            .format(System.currentTimeMillis()) + ".mp4"
        val file = File(context.externalMediaDirs.first(), fileName)
        val outputOptions = VideoCapture.OutputFileOptions.Builder(file).build()

        recordingStartTime = System.currentTimeMillis()
        videoCapture?.startRecording(
            outputOptions,
            ContextCompat.getMainExecutor(context),
            object : VideoCapture.OnVideoSavedCallback {
                override fun onVideoSaved(outputFileResults: VideoCapture.OutputFileResults) {
                    val savedUri = Uri.fromFile(file)
                    previewUri.value = savedUri
                    uploadToFTP(file)
                }

                override fun onError(videoCaptureError: Int, message: String, cause: Throwable?) {
                    Log.e("CameraViewModel", "Video capture failed: $message", cause)
                }
            })
    }

    private fun uploadToFTP(file: File) {
        viewModelScope.launch(Dispatchers.IO) {
            FTPUpload.uploadFile(
                file.path,
                "192.168.10.100", 21,
                "yyy", "xxx"
            )
        }
    }
}

import android.Manifest
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.result.contract.ActivityResultContracts
import androidx.activity.viewModels
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.core.content.ContextCompat
import com.google.accompanist.permissions.ExperimentalPermissionsApi
import com.google.accompanist.permissions.rememberMultiplePermissionsState
import com.google.accompanist.permissions.shouldShowRationale
import java.util.*

class MainActivity : ComponentActivity() {
    private val cameraViewModel: CameraViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            JetpackComposeCameraTheme {
                Surface(modifier = Modifier.fillMaxSize()) {
                    val context = remember { this }
                    val permissionState = rememberMultiplePermissionsState(
                        permissions = listOf(
                            Manifest.permission.CAMERA,
                            Manifest.permission.RECORD_AUDIO,
                            Manifest.permission.WRITE_EXTERNAL_STORAGE,
                            Manifest.permission.READ_EXTERNAL_STORAGE
                        )
                    )

                    if (permissionState.allPermissionsGranted) {
                        CameraPreview(cameraViewModel)
                    } else {
                        Column(
                            Modifier
                                .fillMaxSize()
                                .padding(16.dp)
                        ) {
                            Text("Permissions need to be granted to use the camera")

                            Spacer(modifier = Modifier.height(8.dp))

                            if (permissionState.shouldShowRationale) {
                                Text("Please allow the permissions.")
                            } else {
                                OutlinedButton(onClick = { permissionState.launchMultiplePermissionRequest() }) {
                                    Text("Allow")
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

@Composable
fun CameraPreview(cameraViewModel: CameraViewModel) {
    val context = LocalContext.current
    val isRecording = cameraViewModel.isRecording.collectAsState()
    
    Column(modifier = Modifier.fillMaxSize()) {
        Box(modifier = Modifier
            .weight(1f)
            .fillMaxSize()) {
            
            AndroidView(
                factory = { ctx ->
                    val previewView = PreviewView(ctx)
                    cameraViewModel.startCamera(ctx, previewView)
                    previewView
                },
                modifier = Modifier.fillMaxSize()
            )
        }

        Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Center) {
            Button(onClick = { /* Trigger cameraViewModel logic here */ },
                modifier = Modifier.padding(16.dp)) {
                Text("Start Recording")
            }
        
            Button(onClick = { /* Trigger cameraViewModel logic here */ },
                modifier = Modifier.padding(16.dp)) {
                Text("Stop Recording")
            }
        }
    }
}

import org.apache.commons.net.ftp.FTP
import org.apache.commons.net.ftp.FTPClient
import java.io.File
import java.io.FileInputStream
import java.io.IOException

object FTPUpload {

    fun uploadFile(filePath: String, server: String, port: Int, user: String, pass: String) {
        val ftpClient = FTPClient()
        try {
            ftpClient.connect(server, port)
            ftpClient.login(user, pass)
            ftpClient.enterLocalPassiveMode()
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE)

            val dateFolder = SimpleDateFormat("yyyyMMdd", Locale.US).format(System.currentTimeMillis())
            ftpClient.makeDirectory(dateFolder)
            ftpClient.changeWorkingDirectory(dateFolder)

            val firstRemoteFile = File(filePath).name
            val inputStream = FileInputStream(filePath)

            println("Start uploading first file")
            val done = ftpClient.storeFile(firstRemoteFile, inputStream)
            inputStream.close()

            if (done) {
                println("File is uploaded successfully.")
            }
        } catch (ex: IOException) {
            ex.printStackTrace()
        } finally {
            try {
                if (ftpClient.isConnected) {
                    ftpClient.logout()
                    ftpClient.disconnect()
                }
            } catch (ex: IOException) {
                ex.printStackTrace()
            }
        }
    }
}