Vulkan-Samples/app/android/java/com/khronos/vulkan_samples/MainActivity.java

package com.khronos.vulkan_samples;


import android.Manifest;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.graphics.PixelFormat;
import android.graphics.SurfaceTexture;
import android.os.Bundle;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceView;
import android.view.TextureView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.camera.core.AspectRatio;
import androidx.camera.core.CameraSelector;
import androidx.camera.core.ImageAnalysis;
import androidx.camera.core.ImageProxy;
import androidx.camera.core.Preview;
import androidx.camera.core.SurfaceRequest;
import androidx.camera.lifecycle.ProcessCameraProvider;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

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

import java.nio.ByteBuffer;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MainActivity extends GameActivity {
    private ProcessCameraProvider cameraProvider;
    private void initCamera(){
        backgroundExecutor = Executors.newSingleThreadExecutor();
        if (hasCameraPermission()) {
            startCamera();
        } else {
            requestCameraPermission();
        }
    }


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        String native_lib_name = getResources().getString(R.string.native_lib_name);
        try {
            System.loadLibrary(native_lib_name);
        } catch (UnsatisfiedLinkError e) {
            Toast.makeText(getApplicationContext(), "Native code library failed to load.", Toast.LENGTH_SHORT).show();
        }
        String[] argArray = new String[2];
        argArray[0] = "sample";
        argArray[1] = "texture_loading";//"hello_triangle";
        sendArgumentsToPlatform(argArray);
        super.onCreate(savedInstanceState);

        initCamera();

        Log.i("MainActivity", "onCreate: ");
    }

    private boolean hasCameraPermission() {
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
                == PackageManager.PERMISSION_GRANTED;
    }

    private void requestCameraPermission() {
        ActivityCompat.requestPermissions(this,
                new String[]{Manifest.permission.CAMERA},
                REQUEST_CAMERA_PERMISSION);
    }

    private static final int REQUEST_CAMERA_PERMISSION = 1001;
    ImageAnalysis imageAnalyzer;
    ExecutorService backgroundExecutor;

    private void startCamera() {
        ListenableFuture<ProcessCameraProvider> cameraProviderFuture =
                ProcessCameraProvider.getInstance(this);

        cameraProviderFuture.addListener(() -> {
            try {
                cameraProvider = cameraProviderFuture.get();

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

                imageAnalyzer = new ImageAnalysis.Builder()
                        .setTargetAspectRatio(AspectRatio.RATIO_4_3)
                        .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
                        .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_RGBA_8888)
                        .build();


                imageAnalyzer.setAnalyzer(backgroundExecutor, new ImageAnalysis.Analyzer() {

                    @Override
                    public void analyze(@NonNull ImageProxy image) {
                        try {
                            Log.d("Camera", "Received image: " + image.getWidth() + "x" + image.getHeight());
                            processImageForVulkan(image);
                        } finally {
                            image.close(); // 确保在这里关闭
                            Log.d("Camera", "Image closed, ready for next frame");
                        }
                    }
                });

                cameraProvider.bindToLifecycle(this, cameraSelector, imageAnalyzer);

            } catch (ExecutionException | InterruptedException e) {
                Log.e("MainActivity", "Error starting camera: " + e.getMessage());
            }
        }, ContextCompat.getMainExecutor(this));
    }

    private void processImageForVulkan(ImageProxy image) {
        // 获取图像信息
        int width = image.getWidth();
        int height = image.getHeight();
        int format = image.getFormat();

        // 获取图像数据平面
        ImageProxy.PlaneProxy[] planes = image.getPlanes();

        // 对于 RGBA_8888 格式，通常只有一个平面
        if (planes.length > 0) {
            ImageProxy.PlaneProxy plane = planes[0];
            ByteBuffer buffer = plane.getBuffer();
            int rowStride = plane.getRowStride();
            int pixelStride = plane.getPixelStride();

            // 调用 Native 方法处理图像
            processImageNative(buffer, width, height, format,
                    rowStride, pixelStride, image.getImageInfo().getRotationDegrees());
        }
    }

    // Native 方法
    private native void processImageNative(ByteBuffer buffer, int width, int height,
                                           int format, int rowStride, int pixelStride,
                                           int rotation);


    private static final int REQUEST_CODE_PERMISSIONS = 1001;
    private static final String[] REQUIRED_PERMISSIONS = new String[]{Manifest.permission.CAMERA};
    private static final String TAG = "MainActivity";

    private boolean allPermissionsGranted() {
        for (String permission : REQUIRED_PERMISSIONS) {
            if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == REQUEST_CODE_PERMISSIONS) {
            if (allPermissionsGranted()) {
                startCamera();
            } else {
                Log.e(TAG, "Permissions not granted by the user.");
                finish(); // Close the activity if permission is denied
            }
        }
    }

    private native void sendArgumentsToPlatform(String[] args);
}