前言
本章基于前章基础上功能补全和代码优化
1 上代码
// GENERATED BY UNITY. REMOVE THIS COMMENT TO PREVENT OVERWRITING WHEN EXPORTING AGAIN
package com.unity3d.player;
import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.graphics.ImageFormat;
import android.graphics.Matrix;
import android.graphics.PixelFormat;
import android.graphics.RectF;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.media.Image;
import android.media.ImageReader;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.util.Size;
import android.view.Display;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.os.Process;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class UnityPlayerActivity extends Activity implements IUnityPlayerLifecycleEvents
{
protected UnityPlayer mUnityPlayer; // don't change the name of this variable; referenced from native code
// Override this in your custom UnityPlayerActivity to tweak the command line arguments passed to the Unity Android Player
// The command line arguments are passed as a string, separated by spaces
// UnityPlayerActivity calls this from 'onCreate'
// Supported: -force-gles20, -force-gles30, -force-gles31, -force-gles31aep, -force-gles32, -force-gles, -force-vulkan
// See https://docs.unity3d.com/Manual/CommandLineArguments.html
// @param cmdLine the current command line arguments, may be null
// @return the modified command line string or null
protected String updateUnityCommandLineArguments(String cmdLine)
{
return cmdLine;
}
// Setup activity layout
@Override protected void onCreate(Bundle savedInstanceState)
{
requestWindowFeature(Window.FEATURE_NO_TITLE);
super.onCreate(savedInstanceState);
String cmdLine = updateUnityCommandLineArguments(getIntent().getStringExtra("unity"));
getIntent().putExtra("unity", cmdLine);
mUnityPlayer = new UnityPlayer(this, this);
setContentView(mUnityPlayer);
mUnityPlayer.requestFocus();
applyForPermission(); // add by eh
}
// When Unity player unloaded move task to background
@Override public void onUnityPlayerUnloaded() {
moveTaskToBack(true);
}
// Callback before Unity player process is killed
@Override public void onUnityPlayerQuitted() {
}
@Override protected void onNewIntent(Intent intent)
{
// To support deep linking, we need to make sure that the client can get access to
// the last sent intent. The clients access this through a JNI api that allows them
// to get the intent set on launch. To update that after launch we have to manually
// replace the intent with the one caught here.
setIntent(intent);
mUnityPlayer.newIntent(intent);
}
// Quit Unity
@Override protected void onDestroy ()
{
mUnityPlayer.destroy();
super.onDestroy();
}
// Pause Unity
@Override protected void onPause()
{
super.onPause();
mUnityPlayer.pause();
}
// Resume Unity
@Override protected void onResume()
{
super.onResume();
mUnityPlayer.resume();
}
// Low Memory Unity
@Override public void onLowMemory()
{
super.onLowMemory();
mUnityPlayer.lowMemory();
}
// Trim Memory Unity
@Override public void onTrimMemory(int level)
{
super.onTrimMemory(level);
if (level == TRIM_MEMORY_RUNNING_CRITICAL)
{
mUnityPlayer.lowMemory();
}
}
// This ensures the layout will be correct.
@Override public void onConfigurationChanged(Configuration newConfig)
{
super.onConfigurationChanged(newConfig);
mUnityPlayer.configurationChanged(newConfig);
}
// Notify Unity of the focus change.
@Override public void onWindowFocusChanged(boolean hasFocus)
{
super.onWindowFocusChanged(hasFocus);
mUnityPlayer.windowFocusChanged(hasFocus);
}
// For some reason the multiple keyevent type is not supported by the ndk.
// Force event injection by overriding dispatchKeyEvent().
@Override public boolean dispatchKeyEvent(KeyEvent event)
{
if (event.getAction() == KeyEvent.ACTION_MULTIPLE)
return mUnityPlayer.injectEvent(event);
return super.dispatchKeyEvent(event);
}
// Pass any events not handled by (unfocused) views straight to UnityPlayer
@Override public boolean onKeyUp(int keyCode, KeyEvent event) {
return mUnityPlayer.injectEvent(event); }
@Override public boolean onKeyDown(int keyCode, KeyEvent event) {
return mUnityPlayer.injectEvent(event); }
@Override public boolean onTouchEvent(MotionEvent event) {
return mUnityPlayer.injectEvent(event); }
/*API12*/ public boolean onGenericMotionEvent(MotionEvent event) {
return mUnityPlayer.injectEvent(event); }
//增加的代码开始处
final private static String TAG = UnityPlayerActivity.class.getName() ;
//供unity 调用 接口
public void OnClickBtn1(){
Log.d(TAG,"android OnClickBtn1");
if(isOpenFlatingWindow()){
addFloatingWindowView(); //增加悬浮窗后
}else{
openCamera();
}
}
//供unity 调用 接口
public void OnClickBtn2(){
Log.d(TAG,"android OnClickBtn2");
if(isOpenFlatingWindow()){
releaseFloatingWindow();
}else{
releaseCamera();
}
}
//供unity 调用 接口 暂时无用
public void OnClickBtn3(){
Log.d(TAG,"android OnClickBtn3");
// myActivity.addFloatingWindowView();
exchangeCamera(); //切换相机
}
/
//增加camera2 摄像头
private CameraManager mCameraManager;
private CameraDevice.StateCallback mStateCallback;
private CameraDevice mCameraDevice;
private TextureView mTextureView;
private CameraCaptureSession mCaptureSession;
private CaptureRequest mPreviewRequest;
private int mCameraSensorOrientation = 0 ; //摄像头方向
private int mCameraFacing = CameraCharacteristics.LENS_FACING_FRONT ; //默认使用前置摄像头
private int mDisplayRotation = 0; //getDisplay().defaultDisplay.rotation //手机方向
private String cameraIdFront = ""; //相机ID
private Size[] cameraSizeFront ; //相机支持的尺寸
private CameraCharacteristics cameraCharacteristicsFront ; //
private static final int RECV_MAX_IMAGES = 2 ; //同时最多接收2张图片
private ImageReader mImageReader;
private TextureView.SurfaceTextureListener surfaceTextureListener ;
private ImageReader.OnImageAvailableListener imageAvailableListener;
private boolean mFlashSupported =false; //判断是否支持闪关灯
android.util.Range<Integer> mAverageFPS =null ; //中间帧率
private HandlerThread mBackgroundThread; //用于运行不应阻塞UI的任务的附加线程
private Handler mBackgroundHandler; //用于在后台运行任务的{@link Handler}
//悬浮窗相关
private WindowManager windowManager = null;
private WindowManager.LayoutParams layoutParams = null;
// public static final int DMS_INPUT_IMG_W = 640;
// public static final int DMS_INPUT_IMG_H = 480;
public static final int PREVIEW_WIDTH = 640 ; //预览的宽度
public static final int PREVIEW_HEIGHT = 480 ; //预览的高度
public static final int DEFAULT_SCREEN_X = 300 ; //默认开始位置
public static final int DEFAULT_SCREEN_Y = 300 ; //默认开始位置
private Size mPreviewSize = null; //预览的尺寸 默认 PREVIEW_WIDTH PREVIEW_HEIGHT
private View mPreviewdisplayView = null; //预览窗口
private Surface mPreviewSurface; //预览窗口surface
// LayoutInflater floatingWindowlayoutInflater = null ; //悬浮窗口布局填充器 //放这里也可以，用临时变量也可以的
private final boolean bOpenFloatingWindowFlag = true ; //是否开启悬浮窗口 //不开启只做数据分析
//
//权限 相关
private final int REQUEST_CODE_CONTACT = 1;
final String[] AppPermissions = {
// Manifest.permission.WRITE_EXTERNAL_STORAGE,
// Manifest.permission.READ_EXTERNAL_STORAGE,
// Manifest.permission.READ_PHONE_STATE,
Manifest.permission.INTERNET,
Manifest.permission.CAMERA,
//Manifest.permission.RECORD_AUDIO,
};
///
//是否开启悬浮窗口
private boolean isOpenFlatingWindow() {
return bOpenFloatingWindowFlag;}
//创建悬浮窗布局
void createFloatingWindowLayout(){
windowManager = (WindowManager) getSystemService(WINDOW_SERVICE); //在哪都能有， 下面只有在Activity及继续类里有
// windowManager = getWindowManager() ; //上面1句 跟这句 是一样的 Activity里 自带
layoutParams = new WindowManager.LayoutParams();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
layoutParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL; //TYPE_APPLICATION_SUB_PANEL ; //TYPE_APPLICATION_OVERLAY;
} else {
layoutParams.type = WindowManager.LayoutParams.TYPE_PHONE;
}
layoutParams.format = PixelFormat.RGBA_8888;
layoutParams.gravity = Gravity.LEFT | Gravity.TOP;
layoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
layoutParams.width = getPreviewWidth(); // PREVIEW_WIDTH; //窗口宽度
layoutParams.height = getPreviewHeight();//PREVIEW_HEIGHT; //窗口高度
layoutParams.x = DEFAULT_SCREEN_X; //开始的位置
layoutParams.y = DEFAULT_SCREEN_Y; //开始的位置
}
//更新预览框大小 当默认的窗口尺寸不存在时 重新设置个尺寸
private void updateFloatingWindowLayout(int w,int h){
if(layoutParams != null){
// layoutParams.width = getPreviewWidth(); // PREVIEW_WIDTH; //窗口宽度
//layoutParams.height = getPreviewHeight();//PREVIEW_HEIGHT; //窗口高度
layoutParams.width = w ; //窗口宽度
layoutParams.height = h ;//窗口高度
}
}
//增加悬浮窗口
void addFloatingWindowView(){
LayoutInflater floatingWindowlayoutInflater = LayoutInflater.from(this);
mPreviewdisplayView = floatingWindowlayoutInflater.inflate(R.layout.camera_display, null);
mPreviewdisplayView.setOnTouchListener(new FloatingOnTouchListener());
mTextureView = mPreviewdisplayView.findViewById(R.id.preview);
/
//因为 TextureView 没问有具体尺寸，只是 匹配(match_parent) mPreviewdisplayView ，而 mPreviewdisplayView 尺寸 跟mPreviewSize 一样的所以 第1,2参数全 mPreviewSize的 宽高
final int w = getPreviewWidth() ;
final int h = getPreviewHeight() ;
Matrix matrix = configureTransform(w,h,w ,h,windowManager.getDefaultDisplay().getRotation()) ; //旋转角度根据屏幕
if(matrix != null) mTextureView.setTransform(matrix);
/
mTextureView.setSurfaceTextureListener(surfaceTextureListener);
windowManager.addView(mPreviewdisplayView, layoutParams);
}
//释放悬浮窗口 并停止 相机
void releaseFloatingWindow(){
if(windowManager != null && mPreviewdisplayView !=null){
windowManager.removeView(mPreviewdisplayView);
mPreviewdisplayView = null ;
}
releaseCamera();
}
private void doSomeThing(){
if(initCameraInfo()){
initSurfaceTextureListener(); //监听SurfaceTexture
initImageAvailableListener(); //图像监听，也可以放到createImageReader前
createFloatingWindowLayout(); //创建布局
}
}
//申请权限
private void applyForPermission(){
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
for (String str : AppPermissions) {
if (ContextCompat.checkSelfPermission(this, str) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this, AppPermissions, REQUEST_CODE_CONTACT);
return;
}
}
//do some thing
doSomeThing();
}else{
//使用的比Build.VERSION_CODES.M大 所以这里不可能走到
}
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
// super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (requestCode == REQUEST_CODE_CONTACT) {
// If request is cancelled, the result arrays are empty.
if (grantResults.length > 0
&& grantResults[0] == PackageManager.PERMISSION_GRANTED) {
//do some thing
doSomeThing();
} else if (grantResults.length == 0) {
// 已知魅族手机会进这个结果
} else {
Toast.makeText(this, "您拒绝了相关权限，无法使用！", Toast.LENGTH_SHORT).show();
finish();
}
}
}
///相机相关//
//启动相机前 开启
private void startBackgroundThread() {
if (mBackgroundThread == null || mBackgroundHandler == null) {
Log.v(TAG, "startBackgroundThread");
mBackgroundThread = new HandlerThread("CameraBackground");
mBackgroundThread.start();
mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}
}
//手动停止 或 onDestroy 停止
private void stopBackgroundThread() {
Log.v(TAG, "stopBackgroundThread");
if(mBackgroundThread != null){
mBackgroundThread.quitSafely();
try {
mBackgroundThread.join();
mBackgroundThread = null;
mBackgroundHandler = null;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//释放 与切换
private void releaseCamera() {
if(mCaptureSession!=null){
mCaptureSession.close();
mCaptureSession = null ;
}
if(mCameraDevice !=null){
mCameraDevice.close();
mCameraDevice = null;
}
if(mImageReader !=null){
mImageReader.close();
mImageReader = null ;
}
stopBackgroundThread(); // 对应 openCamera() 方法中的 startBackgroundThread()
}
private Handler getBackgroundHandler(){
return mBackgroundHandler ;
}
//切换相机 //直接点击事件下调用即可
private void exchangeCamera() {
if(windowManager == null) return;
//前后置相机切换
mCameraFacing = mCameraFacing == CameraCharacteristics.LENS_FACING_FRONT?CameraCharacteristics.LENS_FACING_BACK:CameraCharacteristics.LENS_FACING_FRONT ;
releaseCamera();
initCameraInfo() ;
if(mTextureView != null){
/
//因为 TextureView 没问有具体尺寸，只是 匹配(match_parent) mPreviewdisplayView ，而 mPreviewdisplayView 尺寸 跟mPreviewSize 一样的所以 第1,2参数全 mPreviewSize的 宽高
final int w = getPreviewWidth() ;
final int h = getPreviewHeight() ;
Matrix matrix = configureTransform(w,h,w ,h,windowManager.getDefaultDisplay().getRotation()) ; //旋转角度根据屏幕
if(matrix != null) mTextureView.setTransform(matrix);
/
}
openCamera();
}
///
//初始化Surface 监听
void initSurfaceTextureListener(){
surfaceTextureListener= new TextureView.SurfaceTextureListener() {
@Override
public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surfaceTexture, int width, int height) {
// SurfaceTexture texture = mTextureView.getSurfaceTexture(); //也可以的
SurfaceTexture texture = surfaceTexture ; //感觉只有一个TextureView surfaceTexture == mTextureView.getSurfaceTexture() 用那个都可以
final int w = getPreviewWidth() ;
final int h = getPreviewHeight() ;
texture.setDefaultBufferSize(w, h); //这里会重新设置尺寸
mPreviewSurface = new Surface(texture);
openCamera();
}
@Override
public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surface, int width, int height) {
}
@Override
public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surface) {
return false;
}
@Override
public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surface) {
}
};
}
// private boolean initWindowManager(Context context){
// if(windowManager == null){
// if (context instanceof Activity) {
// Activity activity = (Activity) context;
// windowManager = activity.getWindowManager();
// } else {
// windowManager = (WindowManager) context.getSystemService(UnityPlayerActivity.WINDOW_SERVICE);
// }
// }
// return windowManager !=null ;
// }
// //得到屏幕旋转角度
// private int getDisplayRotation(Context context) {
// if(initWindowManager(context))
// {
// int rotation = windowManager.getDefaultDisplay().getRotation();
// switch (rotation) {
// case Surface.ROTATION_0:
// return 0;
// case Surface.ROTATION_90:
// return 90;
// case Surface.ROTATION_180:
// return 180;
// case Surface.ROTATION_270:
// return 270;
// }
// }
// return 0;
// }
//
// //得到屏幕信息
// private Display getDisplay(Context context) {
// if(initWindowManager(context)) return windowManager.getDefaultDisplay() ;
// return null;
// }
//预览图像旋转度根据屏幕旋(横竖)转度 //displayRotation 1 3 横屏 0 2 竖屏
private Matrix configureTransform(final int viewWidth, final int viewHeight,final int previewWidth,final int previewHeight,final int displayRotation) {
int rotation = displayRotation ;
RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
RectF bufferRect = new RectF(0, 0, previewHeight, previewWidth);
float centerX = viewRect.centerX();
float centerY = viewRect.centerY();
if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
Matrix matrix = new Matrix();
bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
float scale = Math.max(
(float) viewHeight / previewHeight,
(float) viewWidth / previewWidth);
matrix.postScale(scale, scale, centerX, centerY);
matrix.postRotate(90 * (rotation - 2), centerX, centerY);
return matrix ;
}
return null ;
}
// private void configureTransform(int viewWidth, int viewHeight) {
// if (null == mTextureView || null == mPreviewSize || null == windowManager) {
// return;
// }
// // int rotation = getWindowManager().getDefaultDisplay().getRotation();
// int rotation = windowManager.getDefaultDisplay().getRotation();
// Matrix matrix = new Matrix();
// RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
// RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth());
// float centerX = viewRect.centerX();
// float centerY = viewRect.centerY();
// if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
// bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
// matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
// float scale = Math.max(
// (float) viewHeight / mPreviewSize.getHeight(),
// (float) viewWidth / mPreviewSize.getWidth());
// matrix.postScale(scale, scale, centerX, centerY);
// matrix.postRotate(90 * (rotation - 2), centerX, centerY);
// }
// mTextureView.setTransform(matrix);
// }
private class CompareSizeByArea implements java.util.Comparator<Size> {
@Override
public int compare(Size lhs, Size rhs) {
return Long.signum((long) lhs.getWidth() * lhs.getHeight()
- (long) rhs.getWidth() * rhs.getHeight());
}
}
private int getPreviewWidth(){
return mPreviewSize!=null?mPreviewSize.getWidth():PREVIEW_WIDTH ;
}
private int getPreviewHeight(){
return mPreviewSize!=null?mPreviewSize.getHeight():PREVIEW_HEIGHT;
}
//是否支持闪光灯模式
private boolean isFlashSupported(){
return mFlashSupported ;
}
//初始化相机
private boolean initCameraInfo() {
mCameraManager = (CameraManager) getSystemService(CAMERA_SERVICE);
try {
String [] carmeraids = mCameraManager.getCameraIdList() ;
for(int i =0 ;i<carmeraids.length ;i++){
CameraCharacteristics cameraCharacteristics = mCameraManager.getCameraCharacteristics(carmeraids[i]);
// cameraCharacteristics.get(CameraCharacteristics.LENS_FACING);
if(cameraCharacteristics.get(CameraCharacteristics.LENS_FACING)== mCameraFacing) {
//前置
cameraIdFront = carmeraids[i] ;
cameraCharacteristicsFront = cameraCharacteristics ;
cameraSizeFront = cameraCharacteristics .get( CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP) .getOutputSizes(ImageReader.class);
break;
}
}
}catch (CameraAccessException e){
Log.e(TAG,e.getMessage());
return false;
}
// int supportLevel = cameraCharacteristicsFront.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL)
// if (supportLevel == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY) {
// // mActivity.toast("相机硬件不支持新特性")
// }
int supportLevel = cameraCharacteristicsFront.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
if(!isHardwareLevelSupported(supportLevel,CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)){
//希望支持
return false ;
}
//判断是否支持闪光灯
Boolean available = cameraCharacteristicsFront.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
mFlashSupported = available == null ? false : available;
StreamConfigurationMap map = cameraCharacteristicsFront.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
Size [] outputSizes = map.getOutputSizes(ImageFormat.YUV_420_888);
Size largest = Collections.max(Arrays.asList(outputSizes), new CompareSizeByArea());
// 获取预览画面的尺寸
if(!(outputSizes!= null && outputSizes.length > 0)){
return false;
}
boolean bFound = false ;
for(Size s :outputSizes){
if(s.getWidth() == PREVIEW_WIDTH && s.getHeight() == PREVIEW_HEIGHT){
bFound = true ; //
break;
}
}
if(bFound){
mPreviewSize = new Size(PREVIEW_WIDTH,PREVIEW_HEIGHT);
}else {
//这里取中间值不怎么好，最好得是找一个接近默认值比的宽高度，有旦继续优化
int average = (int)(outputSizes.length/2); //平均值 偶数个 取大的
mPreviewSize = outputSizes[average] ;//map.getOutputSizes(SurfaceTexture.class)[0]; //0 为最大尺寸， 感觉不合理，所以取平均值
updateFloatingWindowLayout(mPreviewSize.getWidth(),mPreviewSize.getHeight()); //重新更新下
}
//帧率
//Key<android.util.Range<Integer>[]> CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES
android.util.Range<Integer>[] ranges = cameraCharacteristicsFront.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
if(ranges != null && ranges.length > 0){
//取中间值 从低往高 0 帧率最低
int average = (int)(ranges.length/2); //平均值 偶数个 取大的
mAverageFPS = ranges[average]; //中间值
}
return true ;
}
// 对于Camera2采集系统来说，每个摄像头都有一个支持等级： 从高到底为 越高越好
// INFO_SUPPORTED_HARDWARE_LEVEL_3 支持YUV再处理和原始数据采集功能，并且具备先进的功能。
// INFO_SUPPORTED_HARDWARE_LEVEL_FULL支持先进的摄像头功能。
// INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED向后兼容模式，底层等同于Camera1的实现。
// INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY 随机赠送的功能支持，支持性不足。
// 总的来说如果摄像头等级是LEVEL_3和LEVEL_FULL才建议使用Camera2进行采集，否则推荐采用兼容性更好的Camera1进行视频采集。
//判断是否支持要求的等级
// Returns true if the device supports the required hardware level, or better.
boolean isHardwareLevelSupported(int supportLevel , int requiredLevel) {
final int[] sortedHwLevels = {
CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY,
CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL,
CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_FULL,
CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3
};
int deviceLevel = supportLevel ; CameraCharacteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
if (requiredLevel == deviceLevel) {
return true;
}
for (int sortedlevel : sortedHwLevels) {
if (sortedlevel == requiredLevel) {
return true;
} else if (sortedlevel == deviceLevel) {
return false;
}
}
return false; // Should never reach here
}
//初始化
private void initImageAvailableListener(){
imageAvailableListener = new ImageReader.OnImageAvailableListener(){
@Override
public void onImageAvailable(ImageReader var1){
Image image = var1.acquireLatestImage() ;
if(image== null){
return;
}
//得到图片 转成nv21格式
byte [] date = YUV_420_888toNV21(image);
// ByteBuffer buffer = image.getPlanes()[0].getBuffer();
// int length = buffer.remaining();
// var bytes = ByteArray(length);
// 转成 Bitmap
// ByteBuffer buffer = image.getPlanes()[0].getBuffer();
// byte[] b = new byte[buffer.capacity()];
// buffer.get(b, 0 , b.length);
// Bitmap bitmap = BitmapFactory.decodeByteArray(b, 0, b.length);
image.close();
}
};
}
private void createCameraDeviceCallback(){
mStateCallback = new CameraDevice.StateCallback() {
@Override
public void onOpened(@NonNull CameraDevice camera) {
mCameraDevice = camera;
createCameraPreviewSession();
}
@Override
public void onDisconnected(@NonNull CameraDevice camera) {
camera.close();
mCameraDevice = null;
}
@Override
public void onError(@NonNull CameraDevice camera, int error) {
camera.close();
mCameraDevice = null;
}
};
}
public void openCamera(){
mCameraManager = (CameraManager) getSystemService(CAMERA_SERVICE);
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
// TODO: Consider calling
// ActivityCompat#requestPermissions
// here to request the missing permissions, and then overriding
// public void onRequestPermissionsResult(int requestCode, String[] permissions,
// int[] grantResults)
// to handle the case where the user grants the permission. See the documentation
// for ActivityCompat#requestPermissions for more details.
return;
}
startBackgroundThread(); //开启
createCameraDeviceCallback() ; //相机状态监听
createImageReader(); //图像解析
try {
mCameraManager.openCamera(cameraIdFront, mStateCallback, getBackgroundHandler()); //"0" 前置 "1" 后置 // handler null 主线程处理 否 创建个独立线程区处理
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
//创建分析
private void createImageReader() {
if (mImageReader != null) {
mImageReader.close();
mImageReader = null;
}
//mPreviewSize.getWidth()
mImageReader = ImageReader.newInstance(getPreviewWidth(), getPreviewHeight(),
ImageFormat.YUV_420_888, RECV_MAX_IMAGES);
// imageReader = ImageReader.newInstance(1280, 720, ImageFormat.JPEG, 2)
mImageReader.setOnImageAvailableListener(imageAvailableListener, getBackgroundHandler());
}
//创建预览会话
private void createCameraPreviewSession() {
try {
final CaptureRequest.Builder previewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
if(isOpenFlatingWindow()){
//是否开启悬浮窗口
previewRequestBuilder.addTarget(mPreviewSurface);
}
previewRequestBuilder.addTarget(mImageReader.getSurface());
//这几句可以放到 // 放到设置预览时连续捕获图像数据前 也可以
// 设置自动对焦模式
previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
// 设置自动曝光模式
if(isFlashSupported()){
//如果支持就开启
previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
}
//设置帧率
if(mAverageFPS!=null){
previewRequestBuilder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, mAverageFPS);
}
// 开始显示相机预览
mPreviewRequest = previewRequestBuilder.build();
//
// width 和 height 与 surfaceview 的相同
//ImageReader 用于接收处理（拍照、录像）的相机流
//SurfaceView 用于接收预览的相机流
// ImageReader mImageReader = ImageReader.newInstance(width, height, ImageFormat.JPEG, 1);
List<Surface> surfaces = new ArrayList<Surface>();
if(isOpenFlatingWindow()) {
//是否开启悬浮窗口
surfaces.add(mPreviewSurface);
}
surfaces.add(mImageReader.getSurface());
// surfaces.add(surfaceView.getHolder().getSurface());
// surfaces.add(mImageReader.getSurface());
// Arrays.asList(surface)
mCameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() {
@Override
public void onConfigured(CameraCaptureSession cameraCaptureSession) {
mCaptureSession = cameraCaptureSession;
try {
//这几句可以放到 // 放到设置预览时连续捕获图像数据 也可以
// 设置自动对焦模式
// previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
// // 设置自动曝光模式
// if(isFlashSupported()){ //如果支持就开启
// previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
// }
// //设置帧率
// if(mAverageFPS!=null){
// previewRequestBuilder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, mAverageFPS);
// }
// // 开始显示相机预览
// mPreviewRequest = previewRequestBuilder.build();
//
// 设置预览时连续捕获图像数据
//listener 这里不是拍照，预览的无需回调，拍照就需要了
mCaptureSession.setRepeatingRequest(mPreviewRequest, null, getBackgroundHandler());
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
@Override
public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
Log.e("MainActivity", "onConfigureFailed");
}
}, getBackgroundHandler());
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
数据格式处理//
//数据转化 抄别人的 //
//Planar格式（P）的处理
private static ByteBuffer getuvBufferWithoutPaddingP(ByteBuffer uBuffer, ByteBuffer vBuffer, int width, int height, int rowStride, int pixelStride){
int pos = 0;
byte []byteArray = new byte[height*width/2];
for (int row=0; row<height/2; row++) {
for (int col=0; col<width/2; col++) {
int vuPos = col*pixelStride + row*rowStride;
byteArray[pos++] = vBuffer.get(vuPos);
byteArray[pos++] = uBuffer.get(vuPos);
}
}
ByteBuffer bufferWithoutPaddings=ByteBuffer.allocate(byteArray.length);
// 数组放到buffer中
bufferWithoutPaddings.put(byteArray);
//重置 limit 和postion 值否则 buffer 读取数据不对
bufferWithoutPaddings.flip();
return bufferWithoutPaddings;
}
//Semi-Planar格式（SP）的处理和y通道的数据
private static ByteBuffer getBufferWithoutPadding(ByteBuffer buffer, int width, int rowStride, int times,boolean isVbuffer){
if(width == rowStride) return buffer; //没有buffer,不用处理。
int bufferPos = buffer.position();
int cap = buffer.capacity();
byte []byteArray = new byte[times*width];
int pos = 0;
//对于y平面，要逐行赋值的次数就是height次。对于uv交替的平面，赋值的次数是height/2次
for (int i=0;i<times;i++) {
buffer.position(bufferPos);
//part 1.1 对于u,v通道,会缺失最后一个像u值或者v值，因此需要特殊处理，否则会crash
if(isVbuffer && i==times-1){
width = width -1;
}
buffer.get(byteArray, pos, width);
bufferPos+= rowStride;
pos = pos+width;
}
//nv21数组转成buffer并返回
ByteBuffer bufferWithoutPaddings=ByteBuffer.allocate(byteArray.length);
// 数组放到buffer中
bufferWithoutPaddings.put(byteArray);
//重置 limit 和postion 值否则 buffer 读取数据不对
bufferWithoutPaddings.flip();
return bufferWithoutPaddings;
}
private static byte[] YUV_420_888toNV21(Image image) {
int width = image.getWidth();
int height = image.getHeight();
ByteBuffer yBuffer = getBufferWithoutPadding(image.getPlanes()[0].getBuffer(), image.getWidth(), image.getPlanes()[0].getRowStride(),image.getHeight(),false);
ByteBuffer vBuffer;
//part1 获得真正的消除padding的ybuffer和ubuffer。需要对P格式和SP格式做不同的处理。如果是P格式的话只能逐像素去做，性能会降低。
if(image.getPlanes()[2].getPixelStride()==1){
//如果为true，说明是P格式。
vBuffer = getuvBufferWithoutPaddingP(image.getPlanes()[1].getBuffer(), image.getPlanes()[2].getBuffer(),
width,height,image.getPlanes()[1].getRowStride(),image.getPlanes()[1].getPixelStride());
}else{
vBuffer = getBufferWithoutPadding(image.getPlanes()[2].getBuffer(), image.getWidth(), image.getPlanes()[2].getRowStride(),image.getHeight()/2,true);
}
//part2 将y数据和uv的交替数据（除去最后一个v值）赋值给nv21
int ySize = yBuffer.remaining();
int vSize = vBuffer.remaining();
byte[] nv21;
int byteSize = width*height*3/2;
nv21 = new byte[byteSize];
yBuffer.get(nv21, 0, ySize);
vBuffer.get(nv21, ySize, vSize);
//part3 最后一个像素值的u值是缺失的，因此需要从u平面取一下。
ByteBuffer uPlane = image.getPlanes()[1].getBuffer();
byte lastValue = uPlane.get(uPlane.capacity() - 1);
nv21[byteSize - 1] = lastValue;
return nv21;
}
//悬浮窗口 移动 更新位置
private class FloatingOnTouchListener implements View.OnTouchListener {
private int x;
private int y;
@Override
public boolean onTouch(View view, MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
x = (int) event.getRawX();
y = (int) event.getRawY();
break;
case MotionEvent.ACTION_MOVE:
int nowX = (int) event.getRawX();
int nowY = (int) event.getRawY();
int movedX = nowX - x;
int movedY = nowY - y;
x = nowX;
y = nowY;
layoutParams.x = layoutParams.x + movedX;
layoutParams.y = layoutParams.y + movedY;
windowManager.updateViewLayout(view, layoutParams);
break;
default:
break;
}
return true;
}
}
//
//权限
// <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
// <uses-permission android:name="android.permission.CAMERA" />
// <uses-permission android:name="android.permission.INTERNET" />
//硬件加速
// android:hardwareAccelerated="true"
//使用 useAndroidX
//android.useAndroidX=true
//增加依赖
//implementation 'androidx.core:core:1.2.0' 跟下面3句有关系，不增加，下面的找不到
// import androidx.annotation.NonNull;
//import androidx.core.app.ActivityCompat;
//import androidx.core.content.ContextCompat;
///
// unity 导出 Plugin Version(3.6.0) Gradle Version(6.1.1) 这里用
// compileSdkVersion 33
// buildToolsVersion '33.0.0'
// 不支持 所以需要提升下
// Android Gradle Plugin Version
//3.6.0 ----> 4.1.1
// Gradle Version
//6.1.1 ----> 6.9
//
//启动过程
//1： 申请权限，得到相机与屏幕 信息 多出相依处理
//applyForPermission() //放到 onCreate 里就OK了
//有权限 dosomething
//2:dosomething 里 初始化相机
//createFloatingWindowLayout() 初始化各种监听 等
//3: 点击事件 或其他地方调用
//addFloatingWindowView 触发
// TextureView.SurfaceTextureListener() 的
// public void onSurfaceTextureAvailable 从而 启动相机
//4: 启动相机
//openCamera 在 mCameraManager.openCamera 前 回调函数都设置好
//createCameraDeviceCallback() ; //相机状态监听回调
// createImageReader(); //图像解析
//触发 createCameraPreviewSession
//5 创建预览会话
// 预览 解析 加入会话申请中
}
2 说明
开启悬浮窗口标志
private final boolean bOpenFloatingWindowFlag = true ; //是否开启悬浮窗口 //不开启只做数据分析
//是否开启悬浮窗口
private boolean isOpenFlatingWindow() {
return bOpenFloatingWindowFlag;}
private HandlerThread mBackgroundThread; //用于运行不应阻塞UI的任务的附加线程
private Handler mBackgroundHandler; //用于在后台运行任务的{@link Handler}
private void createCameraPreviewSession() {
...............................
if(isOpenFlatingWindow()){
//是否开启悬浮窗口
previewRequestBuilder.addTarget(mPreviewSurface);
}
....................................
if(isOpenFlatingWindow()) {
//是否开启悬浮窗口
surfaces.add(mPreviewSurface);
}
..............................
}
启动 背景线程处理 ，为了不影响 UI
//启动相机前 开启
private void startBackgroundThread() {
if (mBackgroundThread == null || mBackgroundHandler == null) {
Log.v(TAG, "startBackgroundThread");
mBackgroundThread = new HandlerThread("CameraBackground");
mBackgroundThread.start();
mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}
}
//手动停止 或 onDestroy 停止
private void stopBackgroundThread() {
Log.v(TAG, "stopBackgroundThread");
if(mBackgroundThread != null){
mBackgroundThread.quitSafely();
try {
mBackgroundThread.join();
mBackgroundThread = null;
mBackgroundHandler = null;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//释放 与切换
private void releaseCamera() {
if(mCaptureSession!=null){
mCaptureSession.close();
mCaptureSession = null ;
}
if(mCameraDevice !=null){
mCameraDevice.close();
mCameraDevice = null;
}
if(mImageReader !=null){
mImageReader.close();
mImageReader = null ;
}
stopBackgroundThread(); // 对应 openCamera() 方法中的 startBackgroundThread()
}
private Handler getBackgroundHandler(){
return mBackgroundHandler ;
}
预览大小跟悬浮布布局大小有差异时
//更新预览框大小 当默认的窗口尺寸不存在时 重新设置个尺寸
private void updateFloatingWindowLayout(int w,int h){
if(layoutParams != null){
// layoutParams.width = getPreviewWidth(); // PREVIEW_WIDTH; //窗口宽度
//layoutParams.height = getPreviewHeight();//PREVIEW_HEIGHT; //窗口高度
layoutParams.width = w ; //窗口宽度
layoutParams.height = h ;//窗口高度
}
}
//初始化相机
private boolean initCameraInfo() {
..............................
if(bFound){
mPreviewSize = new Size(PREVIEW_WIDTH,PREVIEW_HEIGHT);
}else {
//这里取中间值不怎么好，最好得是找一个接近默认值比的宽高度，有旦继续优化
int average = (int)(outputSizes.length/2); //平均值 偶数个 取大的
mPreviewSize = outputSizes[average] ;//map.getOutputSizes(SurfaceTexture.class)[0]; //0 为最大尺寸， 感觉不合理，所以取平均值
updateFloatingWindowLayout(mPreviewSize.getWidth(),mPreviewSize.getHeight()); //重新更新下
}
..............................
}
根据屏幕旋转角度
//预览图像旋转度根据屏幕旋(横竖)转度 //displayRotation 1 3 横屏 0 2 竖屏
private Matrix configureTransform(final int viewWidth, final int viewHeight,final int previewWidth,final int previewHeight,final int displayRotation) {
int rotation = displayRotation ;
RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
RectF bufferRect = new RectF(0, 0, previewHeight, previewWidth);
float centerX = viewRect.centerX();
float centerY = viewRect.centerY();
if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
Matrix matrix = new Matrix();
bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
float scale = Math.max(
(float) viewHeight / previewHeight,
(float) viewWidth / previewWidth);
matrix.postScale(scale, scale, centerX, centerY);
matrix.postRotate(90 * (rotation - 2), centerX, centerY);
return matrix ;
}
return null ;
}
切换前后置相机
//切换相机 //直接点击事件下调用即可
private void exchangeCamera() {
if(windowManager == null) return;
//前后置相机切换
mCameraFacing = mCameraFacing == CameraCharacteristics.LENS_FACING_FRONT?CameraCharacteristics.LENS_FACING_BACK:CameraCharacteristics.LENS_FACING_FRONT ;
releaseCamera();
initCameraInfo() ;
if(mTextureView != null){
/
//因为 TextureView 没问有具体尺寸，只是 匹配(match_parent) mPreviewdisplayView ，而 mPreviewdisplayView 尺寸 跟mPreviewSize 一样的所以 第1,2参数全 mPreviewSize的 宽高
final int w = getPreviewWidth() ;
final int h = getPreviewHeight() ;
Matrix matrix = configureTransform(w,h,w ,h,windowManager.getDefaultDisplay().getRotation()) ; //旋转角度根据屏幕
if(matrix != null) mTextureView.setTransform(matrix);
/
}
openCamera();
}
2 运行结果（切换为后置）
临时 用button2 借用下 ,懒得再去unity 增加button3了
public void OnClickBtn2(){
exchangeCamera(); //切换相机
}
3 后续需要优化的部分
1 没找到匹配的窗口大小默认值，用中间值代替，不知道中间值宽高比是否跟默认值等效，
2 YUV_420_888toNV21 JAVA 效率不高，后面用c++ 重写个so 调用
4 觉得有用 ，点个赞，加个关注