使用 Android Studio 开发实时视频监控 App (摄像头提供源)

import androidx.camera.core.CameraSelector;
import androidx.camera.core.ImageAnalysis;
import androidx.camera.core.ImageProxy;
import androidx.camera.core.Preview;
import androidx.camera.lifecycle.ProcessCameraProvider;
import androidx.camera.view.PreviewView;
import androidx.core.content.ContextCompat;
import androidx.lifecycle.LifecycleOwner;

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.util.Log;
import android.util.Size;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;

import com.google.common.util.concurrent.ListenableFuture;

import org.opencv.android.OpenCVLoader;
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.ExecutionException;

public class MainActivity extends AppCompatActivity {

    private PreviewView previewView;
    private ListenableFuture<ProcessCameraProvider> cameraProviderFuture;
    private CascadeClassifier faceDetector;

    static {
        if (!OpenCVLoader.initDebug()) {
            Log.e("OpenCV", "Unable to load OpenCV!");
        } else {
            Log.d("OpenCV", "OpenCV loaded Successfully!");
        }
    }


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        previewView = findViewById(R.id.previewView);

        cameraProviderFuture = ProcessCameraProvider.getInstance(this);
        cameraProviderFuture.addListener(() -> {
            try {
                ProcessCameraProvider cameraProvider = cameraProviderFuture.get();
                bindPreview(cameraProvider);
            } catch (ExecutionException | InterruptedException e) {
                // No errors need to be handled for this Future.
                // This should never be reached.
            }
        }, ContextCompat.getMainExecutor(this));

        try {
            // Load the cascade classifier
            InputStream is = getResources().openRawResource(R.raw.haarcascade_frontalface_default);
            File cascadeDir = getDir("cascade", MODE_PRIVATE);
            File mCascadeFile = new File(cascadeDir, "haarcascade_frontalface_default.xml");
            FileOutputStream os = new FileOutputStream(mCascadeFile);

            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = is.read(buffer)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            is.close();
            os.close();

            faceDetector = new CascadeClassifier(mCascadeFile.getAbsolutePath());
            if (faceDetector.empty()) {
                Log.e("OpenCV", "Failed to load cascade classifier");
                faceDetector = null;
            } else
                Log.i("OpenCV", "Loaded cascade classifier from " + mCascadeFile.getAbsolutePath());

            cascadeDir.delete();

        } catch (IOException e) {
            e.printStackTrace();
            Log.e("OpenCV", "Failed to load cascade. Exception thrown: " + e);
        }

    }

    @SuppressLint("UnsafeOptInUsageError")
    void bindPreview(@androidx.annotation.NonNull ProcessCameraProvider cameraProvider) {
        Preview preview = new Preview.Builder()
                .build();

        CameraSelector cameraSelector = new CameraSelector.Builder()
                .requireLensFacing(CameraSelector.LENS_FACING_FRONT)
                .build();

        preview.setSurfaceProvider(previewView.getSurfaceProvider());

        ImageAnalysis imageAnalysis = new ImageAnalysis.Builder()
                .setTargetResolution(new Size(640, 480))
                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
                .build();

        imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(this), image -> {
            @SuppressLint("UnsafeOptInUsageError")
            android.media.Image mediaImage = image.getImage();
            if (mediaImage != null) {
                Mat imageMat = new Mat();
                // Convert ImageProxy to Mat (OpenCV) - This part needs to be implemented based on the ImageProxy format.  YUV_420_888 is common.
                // **Important**:  You'll likely need a YUV -> RGB conversion here.  This example skips that for brevity.  See below for a potential solution.
                // Convert ImageProxy to Mat (OpenCV) - A basic placeholder - REPLACE THIS
                // This is a VERY simplified example.  You will need to handle different image formats correctly.
                // This code assumes the image is in a format directly convertible to Mat, which is often NOT the case.

                // For YUV_420_888 (most common):
                // 1.  Convert ImageProxy to YUV planes (Y, U, V).
                // 2.  Convert YUV planes to NV21 byte array.
                // 3.  Create a Mat from the NV21 byte array (Imgproc.COLOR_YUV2BGR_NV21 for color, or Imgproc.COLOR_YUV2GRAY_NV21 for grayscale).
                // 4.  Use that Mat for face detection.

                // Example (Conceptual - Adapt to your needs):
                // byte[] nv21; // Get NV21 byte array from ImageProxy (YUV_420_888) - Requires custom conversion code.
                // Mat yuv = new Mat(image.getHeight() + image.getHeight() / 2, image.getWidth(), CvType.CV_8UC1);
                // yuv.put(0, 0, nv21);
                // Imgproc.cvtColor(yuv, imageMat, Imgproc.COLOR_YUV2BGR_NV21);

                // For demonstration, we'll just create an empty Mat.  THIS IS WRONG AND WILL NOT WORK.
                // Replace this with the correct conversion from ImageProxy to Mat.
                //imageMat = new Mat(image.getHeight(), image.getWidth(), CvType.CV_8UC3);

                // Face detection
                if (faceDetector != null) {
                    MatOfRect faceDetections = new MatOfRect();
                    faceDetector.detectMultiScale(imageMat, faceDetections);

                    for (Rect rect : faceDetections.toArray()) {
                        Imgproc.rectangle(imageMat, rect.tl(), rect.br(), new Scalar(0, 255, 0), 3);
                    }

                    // Display the image with detected faces (This requires converting the Mat back to a Bitmap/Image and displaying it).
                    // This is a complex topic on its own and is beyond the scope of this simplified example.
                    // Consider using a custom View or a library to display the processed image.
                    Log.d("Faces Detected", String.format("%s faces detected", faceDetections.toArray().length));
                } else {
                    Log.e("OpenCV", "Face detector not initialized");
                }

                image.close();
            }
        });

        cameraProvider.bindToLifecycle((LifecycleOwner)this, cameraSelector, preview, imageAnalysis);
    }
}

<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera.any"/>

dependencies {
    // CameraX core library using camera2 implementation
    def camerax_version = "1.2.3"
    implementation "androidx.camera:camera-camera2:$camerax_version"
    implementation "androidx.camera:camera-lifecycle:$camerax_version"
    implementation "androidx.camera:camera-view:$camerax_version"

    implementation 'org.opencv:opencv:4.7.0'
}