mMDT5_GreenWatch/app/src/main/java/com/example/greenwatch/sensors/CameraSensor.java

package com.example.greenwatch.sensors;

import android.content.Context;
import android.graphics.ImageFormat;
import android.media.Image;
import android.util.Size;

import androidx.camera.core.CameraSelector;
import androidx.camera.core.ImageAnalysis;
import androidx.camera.lifecycle.ProcessCameraProvider;
import androidx.core.content.ContextCompat;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.MutableLiveData;

import java.nio.ByteBuffer;

public class CameraSensor {
    private final MutableLiveData<Boolean> mVideoAlarmDetected = new MutableLiveData<>();
    private static CameraSensor cameraSensorInstance;
    private boolean videoAlarmDetected;
    private ByteBuffer previousBuffer;
    private int previousWidth;
    private int previousHeight;

    private CameraSensor() {
        videoAlarmDetected = false;
    }

    public static synchronized CameraSensor getInstance() {
        if (cameraSensorInstance == null){
            cameraSensorInstance = new CameraSensor();
        }
        return cameraSensorInstance;
    }

    public MutableLiveData<Boolean> getVideoAlarmDetectedValue() {
        setMutableLiveDataVideoAlarmDetected();
        return mVideoAlarmDetected;
    }

    private void setMutableLiveDataVideoAlarmDetected() {
        mVideoAlarmDetected.setValue(videoAlarmDetected);
    }

    public void bindImageAnalysis(ProcessCameraProvider cameraProvider, LifecycleOwner lifecycleOwner, Context context) {
        ImageAnalysis.Builder builder = new ImageAnalysis.Builder();
        builder.setTargetResolution(new Size(640, 480));
        builder.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST);
        ImageAnalysis imageAnalysis = builder.build();
        imageAnalysis.setAnalyzer(
                ContextCompat.getMainExecutor(context),
                imageProxy -> {

                    int imageFormat = imageProxy.getFormat();

                    if (imageFormat == ImageFormat.YUV_420_888) {

                        Image currentImage = imageProxy.getImage();

                        if (previousHeight != 0) {
                            assert currentImage != null;
                            videoAlarmDetected = compareFrames(currentImage);
                        }

                        assert currentImage != null;
                        Image.Plane[] planes = currentImage.getPlanes();
                        ByteBuffer buffer = planes[0].getBuffer().duplicate();
                        previousBuffer = ByteBuffer.allocateDirect(buffer.remaining());
                        previousBuffer.put(buffer);
                        previousWidth = currentImage.getWidth();
                        previousHeight = currentImage.getHeight();

                        currentImage.close();

                        checkAlarmCondition();

                    }

                    imageProxy.close();
                });

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

        cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, imageAnalysis);
    }

    private boolean compareFrames(Image currentImage) {

        ByteBuffer currentBuffer = currentImage.getPlanes()[0].getBuffer();

        int currentWidth = currentImage.getWidth();
        int currentHeight = currentImage.getHeight();

        if (previousWidth != currentWidth || previousHeight != currentHeight) {
            return false;
        }

        for (int row = 0; row < previousHeight; row++) {
            for (int col = 0; col < previousWidth; col++) {

                int previousIndex = row * previousWidth + col;
                int currentIndex = row * currentWidth + col;

                int previousPixel = previousBuffer.get(previousIndex) & 0xFF;
                int currentPixel = currentBuffer.get(currentIndex) & 0xFF;

                int pixelDifference = Math.abs(previousPixel - currentPixel);
                int threshold = 120;

                if (pixelDifference > threshold) {
                    return true;
                }
            }
        }
        return false;
    }

    public void checkAlarmCondition() {
        if (videoAlarmDetected && !mVideoAlarmDetected.getValue()) {
            setMutableLiveDataVideoAlarmDetected();
        }
        else if (!videoAlarmDetected && mVideoAlarmDetected.getValue()){
            setMutableLiveDataVideoAlarmDetected();
        }
    }
}