Android Camera 整理

最新推荐文章于 2024-04-28 10:56:19 发布
最新推荐文章于 2024-04-28 10:56:19 发布
阅读量418 收藏
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17169057/article/details/87862713
版权

xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.windowdemo"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="15"
        android:targetSdkVersion="15" />

    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
    <uses-permission android:name="android.permission.GET_TASKS" />
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <service android:name="com.example.windowdemo.MyService" >
        </service>
    </application>

</manifest>

====================================================================================

activity

package com.example.windowdemo;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
         
        Button btn = (Button) findViewById(R.id.btn);
        btn.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // 启动服务,在服务里开启悬浮窗
                Intent intent = new Intent(MainActivity.this,MyService.class);
                 startService(intent);
                 finish();
            }
        });
    }

}


============================================================================

service

package com.example.windowdemo;

import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.app.Service;
import android.app.ActivityManager.RunningTaskInfo;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.graphics.PixelFormat;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.provider.Settings;
import android.util.Log;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.view.WindowManager;
import android.view.WindowManager.LayoutParams;

public class MyService extends Service {
    public static String TAG = "MyService";

    /**
     * 自定义窗口
     */
    private MyWindow myWindow;
    /**
     * 窗口管理者
     */
    private WindowManager mWindowManager;
    /**
     * 窗口布局参数
     */
    private LayoutParams Params;
 
    private Handler handler = new Handler() {
    @SuppressLint("NewApi")
    public void handleMessage(Message msg) {

            if (isHome()) {
                // 如果回到桌面,则显示悬浮窗
                if (!myWindow.isAttachedToWindow()) {
                    mWindowManager.addView(myWindow, Params);
                }

            } else {
                // 如果在非桌面,则去掉悬浮窗
                if (myWindow.isAttachedToWindow()) {
                    myWindow.colseCamera();
                    mWindowManager.removeView(myWindow);
                }
            }
            super.handleMessage(msg);
        };
    };

    @Override
    public IBinder onBind(Intent arg0) {

        return null;
    }

    @SuppressLint("NewApi")
    @Override
    public void onCreate() {
        super.onCreate();
        // 定时器类
        Timer timer = new Timer();
        timer.schedule(task, 1000, 1000); // 1s后执行task,经过1s再次执行
        
        Log.i(TAG, "onCreate");
        showWindow();
        //对于6.0以上的设备
//        if (Build.VERSION.SDK_INT >= 23) {
//            //如果支持悬浮窗功能
//            if (Settings.canDrawOverlays(getApplicationContext())) {
//                 showWindow();
//            } else {
//                //手动去开启悬浮窗
//                Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
//                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//                getApplicationContext().startActivity(intent);
//            }
//        } else {
//                //6.0以下的设备直接开启
//                showWindow();
//        }

    }

    private void showWindow() {
        Log.i(TAG, "showWindow1");
        //创建MyWindow的实例
        myWindow = new MyWindow(getApplicationContext());
        //窗口管理者
        mWindowManager = (WindowManager) getSystemService(Service.WINDOW_SERVICE);
        //窗口布局参数
        Params = new WindowManager.LayoutParams();
        //布局坐标,以屏幕左上角为(0,0)
        Params.x = 0;
        Params.y = 0;

        //布局类型
        Params.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT; // 系统提示类型,重要
        
        //布局flags
        Params.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE; // 不能抢占聚焦点
        Params.flags = Params.flags | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
        Params.flags = Params.flags | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS; // 排版不受限制
        Params.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;

        //布局的gravity
        Params.gravity = Gravity.LEFT | Gravity.TOP;
 
        //布局的宽和高
        Params.width =  400;
        Params.height = 400;

        myWindow.setOnTouchListener(new OnTouchListener() {
 
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                 switch (event.getAction()) {                
                 
                 case MotionEvent.ACTION_MOVE:
                    Params.x = (int) event.getRawX() - myWindow.getWidth() / 2;
                    Params.y = (int) event.getRawY() - myWindow.getHeight() / 2;
                    //更新布局位置
                    mWindowManager.updateViewLayout(myWindow, Params);
                    
                    break;
                }
                 return false;
            }
         });

    }

    //定时发送message给Handler
    TimerTask task = new TimerTask() {
        @Override
        public void run() {
            Message message = new Message();
            handler.sendMessage(message);
        }
    };

    
    /**
     * @return 获取桌面(Launcher)的包名
     */
    private List<String> getHomes() {
        List<String> names = new ArrayList<String>();
        PackageManager packageManager = this.getPackageManager();
        
        Intent intent = new Intent(Intent.ACTION_MAIN);
        intent.addCategory(Intent.CATEGORY_HOME);
        List<ResolveInfo> resolveInfo = packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
        for (ResolveInfo info : resolveInfo) {
            names.add(info.activityInfo.packageName);
        }
        return names;
    }

    /**
     * @return 判断当前是否是桌面
     */
    public boolean isHome() {
        ActivityManager mActivityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        List<RunningTaskInfo> rti = mActivityManager.getRunningTasks(1);
        List<String> strs = getHomes();
        if (strs != null && strs.size() > 0) {
            return strs.contains(rti.get(0).topActivity.getPackageName());
        } else {
            return false;
        }
    }

}

 

=================================================================

view

package com.example.windowdemo;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import android.app.Service;
import android.content.Context;
import android.graphics.SurfaceTexture;
import android.hardware.Camera;
import android.hardware.Camera.PictureCallback;
import android.os.Environment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Surface;
import android.view.TextureView;
import android.view.TextureView.SurfaceTextureListener;
import android.view.View;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.LinearLayout;

public class MyWindow extends LinearLayout implements SurfaceTextureListener {
    public static String TAG = "MyWindow";
    private TextureView textureView;
    private SurfaceTexture mSurfaceTexture = null ;
    public static final int MEDIA_TYPE_IMAGE = 1;
    public static final int MEDIA_TYPE_VIDEO = 2;
    private static final int CAPTURE_IMAGE_ACTIVITY_REQUEST_CODE = 100;
    private static final int CAPTURE_VIDEO_ACTIVITY_REQUEST_CODE = 200;

 

    /**
     * 相机类
     */
    private Camera myCamera;
    private Context context;

    private WindowManager mWindowManager;

    public MyWindow(Context context) {
        super(context);
        LayoutInflater.from(context).inflate(R.layout.window, this);
        this.context = context;

        initView();
    }
    Button bt_open,bt2_pic,bt_colse;
    private void initView() {

        textureView = (TextureView) findViewById(R.id.textureView);
        bt_open = (Button) findViewById(R.id.bt_open);
        bt2_pic = (Button) findViewById(R.id.bt2_pic);
        bt_colse = (Button) findViewById(R.id.bt_colse);
        textureView.setSurfaceTextureListener(this);
        mWindowManager = (WindowManager) context.getSystemService(Service.WINDOW_SERVICE);
        bt_open.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                openCamera();
            }
        });
        bt2_pic.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub

                myCamera.takePicture(null, null, mPicture);
            }
        });
        bt_colse.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                colseCamera();
            }
        });
    }
    String cameraId;
    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {

        //        if (myCamera == null) {
        //            // 创建Camera实例
        //            myCamera = Camera.open(0);
        //            Log.i(TAG, "myCamera:"+myCamera);
        //            try {
        //                // 设置预览在textureView上
        //                myCamera.setPreviewTexture(surface);
        //                myCamera.setDisplayOrientation(SetDegree(MyWindow.this));
        //
        //                // 开始预览
        //                myCamera.startPreview();
        //            } catch (IOException e) {
        //                e.printStackTrace();
        //            }
        //        }

        Log.d(TAG,"onSurfaceTextureAvailable-width:"+width+"-height:"+height);
        //        int cameraFacing  =CAMERA_FACING_FRONT;s
        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
        for (int i = 0; i < Camera.getNumberOfCameras(); i++) {
            Camera.getCameraInfo(i, cameraInfo);
            //               if (cameraInfo.facing == cameraFacing) {
            //                   cameraId = i;
            //               }
            Log.d(TAG,"startCamera -cameraInfo.facing:"+cameraInfo.facing);
        }

        //      // TtsUtils.systemOutPtintln("startCamera -isCameraCanUse-cameraId:"+cameraId);
        Log.d(TAG,"startCamera -isCameraCanUse-cameraId:"+cameraId);
        //       mCamera = Camera.open(cameraId);
        mSurfaceTexture = surface ;
        myCamera = Camera.open();
        Log.d(TAG,"startCamera -isCameraCanUse-myCamera:"+myCamera);
        Log.d(TAG,"startCamera -isCameraCanUse-surface:"+surface);
        if (myCamera != null) {
            try {
                myCamera.setPreviewTexture(surface);
                myCamera.startPreview();
            } catch (Exception e) {
                Log.d(TAG, e.getMessage());
            }
        }
    }

    private int SetDegree(MyWindow myWindow) {
        // 获得手机的方向
        int rotation = mWindowManager.getDefaultDisplay().getRotation();
        int degree = 0;
        // 根据手机的方向计算相机预览画面应该选择的角度
        switch (rotation) {
        case Surface.ROTATION_0:
            degree = 90;
            break;
        case Surface.ROTATION_90:
            degree = 0;
            break;
        case Surface.ROTATION_180:
            degree = 270;
            break;
        case Surface.ROTATION_270:
            degree = 180;
            break;
        }
        return degree;
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        myCamera.stopPreview(); //停止预览
        myCamera.release();     // 释放相机资源
        myCamera = null;

        return false;
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
        //         int displayOrientation = getDisplayOrientation();
        //         myCamera.setDisplayOrientation(displayOrientation);
        //         List<Camera.Size> supportedPreviewSizes = myCamera.getParameters().getSupportedPreviewSizes();
        //         Camera.Size optimalPreviewSize = getOptimalPreviewSize(supportedPreviewSizes, width, height);
        //         myCamera.getParameters().setPictureSize(optimalPreviewSize.width, optimalPreviewSize.height);
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {

    }
    public void colseCamera(){
        if(myCamera != null ){
            myCamera.stopPreview(); //停止预览
            myCamera.release();     // 释放相机资源
            myCamera = null;
        }

    }
    public void openCamera(){

        myCamera = Camera.open();
        Log.d(TAG,"startCamera -isCameraCanUse-myCamera:"+myCamera);
        Log.d(TAG,"startCamera -isCameraCanUse-surface:"+mSurfaceTexture);
        if (myCamera != null) {
            try {
                myCamera.setPreviewTexture(mSurfaceTexture);
                myCamera.startPreview();
            } catch (Exception e) {
                Log.d(TAG, e.getMessage());
            }
        }


    }

    private PictureCallback mPicture = new PictureCallback() {
        @Override
        public void onPictureTaken(byte[] data, Camera camera) {
            File pictureFile = getOutputMediaFile(MEDIA_TYPE_IMAGE);
            if (pictureFile == null) {
                Log.d(TAG,
                        "Error creating media file, check storage permissions: "
                                + "e.getMessage()");
                return;
            }
            try {
                FileOutputStream fos = new FileOutputStream(pictureFile);
                fos.write(data);
                fos.close();
                Log.d(TAG, "File ok getPath: " + pictureFile.getPath());
            } catch (FileNotFoundException e) {
                Log.d(TAG, "File not found: " + e.getMessage());
            } catch (IOException e) {
                Log.d(TAG, "Error accessing file: " + e.getMessage());
            }
        }
    };
    /** 为保存图片或视频创建File */
    private static File getOutputMediaFile(int type) {
        // 安全起见，在使用前应该
        // 用Environment.getExternalStorageState()检查SD卡是否已装入
        File mediaStorageDir = new File(
                Environment
                .getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
                "MyCameraApp");
        // 如果期望图片在应用程序卸载后还存在、且能被其它应用程序共享，
        // 则此保存位置最合适
        // 如果不存在的话，则创建存储目录
        if (!mediaStorageDir.exists()) {
            if (!mediaStorageDir.mkdirs()) {
                Log.d("MyCameraApp", "failed to create directory");
                return null;
            }
            Log.d("MyCameraApp", "failed to create directory");
        }
        // 创建媒体文件名
        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss")
                .format(new Date());
        File mediaFile;
        if (type == MEDIA_TYPE_IMAGE) {
            mediaFile = new File(mediaStorageDir.getPath() + File.separator
                    + "IMG_" + timeStamp + ".jpg");
        } else if (type == MEDIA_TYPE_VIDEO) {
            mediaFile = new File(mediaStorageDir.getPath() + File.separator
                    + "VID_" + timeStamp + ".mp4");
        } else {
            return null;
        }
        return mediaFile;
    }

 

}


=====================================================================

main xml

 

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="${relativePackage}.${activityClass}" >

    <Button
        android:id="@+id/btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:text="开启悬浮窗" />

</RelativeLayout>


view xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1" >

        <TextureView
            android:id="@+id/textureView"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:orientation="horizontal" >

        <Button
            android:id="@+id/bt_open"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:background="#00ffff"
            android:text="照相机"
            android:layout_weight="1"
            android:textSize="30sp" />

        <Button
            android:id="@+id/bt2_pic"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:background="#00ffff"
            android:layout_weight="1"
            android:text="拍照"
            android:textSize="30sp" />
        <Button
            android:id="@+id/bt_colse"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:background="#00ffff"
            android:layout_weight="1"
            android:text="关闭"
            android:textSize="30sp" />
    </LinearLayout>

</LinearLayout>

 

======================================

探讨在打开摄像头预览时这两个方法的作用
关于:setPreviewCallbackWithBuffer()

    Installs a callback to be invoked for every preview frame, using buffers supplied with addCallbackBuffer(byte[]), in addition to displaying them on the screen.
    在摄像头开启时增加一个回调函数,在每一帧出现时调用.通过addCallbackBuffer(byte[])使用一个缓存容器来显示这些数据.

其实就是通过内存复用来提高预览的效率,但是如果没有调用这个方法addCallbackBuffer(byte[]),帧回调函数就不会被调用,也就是说在每一次回调函数调用后都必须调用addCallbackBuffer(byte[]).(所以可以直接在onPreviewFrame中调用addCallbackBuffer(byte[]),即camera.addCallbackBuffer(data);),复用这个原来的内存地址即可.
使用步骤:
1 在打开摄像头预览前先分配一个buffer地址

camera.setPreviewCallbackWithBuffer(h264Encoder);
camera.addCallbackBuffer(mPreviewSize.width* mPreviewSize.height*3 / 2);
camera.startPreview();

    1
    2
    3

2 然后只用在onPreviewFrame中调用addCallbackBuffer(data)即可了,就可以一直复用原来开辟的那个内存空间了,视频数据data永远都只会保持在一个地址中,只是其中的内容在不断的变化

 

 

 

=======================

package com.example.windowdemo;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import android.app.Service;
import android.content.Context;
import android.graphics.ImageFormat;
import android.graphics.SurfaceTexture;
import android.hardware.Camera;
import android.hardware.Camera.PictureCallback;
import android.hardware.Camera.PreviewCallback;
import android.os.Environment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Surface;
import android.view.TextureView;
import android.view.TextureView.SurfaceTextureListener;
import android.view.View;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.LinearLayout;

public class MyWindow extends LinearLayout implements SurfaceTextureListener{//PreviewCallback
    public static String TAG = "MyWindow";
    private TextureView textureView;
    private SurfaceTexture mSurfaceTexture = null ;
    public static final int MEDIA_TYPE_IMAGE = 1;
    public static final int MEDIA_TYPE_VIDEO = 2;
    private static final int CAPTURE_IMAGE_ACTIVITY_REQUEST_CODE = 100;
    private static final int CAPTURE_VIDEO_ACTIVITY_REQUEST_CODE = 200;

 

    /**
     * 相机类
     */
    private Camera myCamera;
    private Context context;

    private WindowManager mWindowManager;

    public MyWindow(Context context) {
        super(context);
        LayoutInflater.from(context).inflate(R.layout.window, this);
        this.context = context;

        initView();
    }
    Button bt_open,bt2_pic,bt_colse;
    private void initView() {

        textureView = (TextureView) findViewById(R.id.textureView);
        bt_open = (Button) findViewById(R.id.bt_open);
        bt2_pic = (Button) findViewById(R.id.bt2_pic);
        bt_colse = (Button) findViewById(R.id.bt_colse);
        textureView.setSurfaceTextureListener(this);
        mWindowManager = (WindowManager) context.getSystemService(Service.WINDOW_SERVICE);
        bt_open.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                openCamera();
            }
        });
        bt2_pic.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub

                myCamera.takePicture(null, null, mPicture);
            }
        });
        bt_colse.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                colseCamera();
            }
        });
    }
    String cameraId;
    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {

        //        if (myCamera == null) {
        //            // 创建Camera实例
        //            myCamera = Camera.open(0);
        //            Log.i(TAG, "myCamera:"+myCamera);
        //            try {
        //                // 设置预览在textureView上
        //                myCamera.setPreviewTexture(surface);
        //                myCamera.setDisplayOrientation(SetDegree(MyWindow.this));
        //
        //                // 开始预览
        //                myCamera.startPreview();
        //            } catch (IOException e) {
        //                e.printStackTrace();
        //            }
        //        }

        Log.d(TAG,"onSurfaceTextureAvailable-width:"+width+"-height:"+height);
        //        int cameraFacing  =CAMERA_FACING_FRONT;s
        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
        for (int i = 0; i < Camera.getNumberOfCameras(); i++) {
            Camera.getCameraInfo(i, cameraInfo);
            //               if (cameraInfo.facing == cameraFacing) {
            //                   cameraId = i;
            //               }
            Log.d(TAG,"startCamera -cameraInfo.facing:"+cameraInfo.facing);
        }

        //      // TtsUtils.systemOutPtintln("startCamera -isCameraCanUse-cameraId:"+cameraId);
        Log.d(TAG,"startCamera -isCameraCanUse-cameraId:"+cameraId);
        //       mCamera = Camera.open(cameraId);
        mSurfaceTexture = surface ;
        myCamera = Camera.open();
        Log.d(TAG,"startCamera -isCameraCanUse-myCamera:"+myCamera);
        Log.d(TAG,"startCamera -isCameraCanUse-surface:"+surface);
        if (myCamera != null) {
            try {
                

                
                //Callback buffer was too small! Expected 460800 bytes, but got 217200 bytes!
                myCamera.addCallbackBuffer(new byte[((800 * 480) * 3) / 2] );
//                myCamera.addCallbackBuffer(new byte[((800 * 480) * ImageFormat.getBitsPerPixel(ImageFormat.NV21)) / 8]);
                myCamera.setPreviewCallbackWithBuffer(myPreviewCallback);
                
                myCamera.setPreviewTexture(surface);
                myCamera.startPreview();
            } catch (Exception e) {
                Log.d(TAG, e.getMessage());
            }
        }
    }

    private int SetDegree(MyWindow myWindow) {
        // 获得手机的方向
        int rotation = mWindowManager.getDefaultDisplay().getRotation();
        int degree = 0;
        // 根据手机的方向计算相机预览画面应该选择的角度
        switch (rotation) {
        case Surface.ROTATION_0:
            degree = 90;
            break;
        case Surface.ROTATION_90:
            degree = 0;
            break;
        case Surface.ROTATION_180:
            degree = 270;
            break;
        case Surface.ROTATION_270:
            degree = 180;
            break;
        }
        return degree;
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        myCamera.stopPreview(); //停止预览
        myCamera.release();     // 释放相机资源
        myCamera = null;

        return false;
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
        //         int displayOrientation = getDisplayOrientation();
        //         myCamera.setDisplayOrientation(displayOrientation);
        //         List<Camera.Size> supportedPreviewSizes = myCamera.getParameters().getSupportedPreviewSizes();
        //         Camera.Size optimalPreviewSize = getOptimalPreviewSize(supportedPreviewSizes, width, height);
        //         myCamera.getParameters().setPictureSize(optimalPreviewSize.width, optimalPreviewSize.height);
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {

    }
    public void colseCamera(){
        if(myCamera != null ){
            myCamera.stopPreview(); //停止预览
            myCamera.release();     // 释放相机资源
            myCamera = null;
        }

    }
    public void openCamera(){

        myCamera = Camera.open();
        Log.d(TAG,"startCamera -isCameraCanUse-myCamera:"+myCamera);
        Log.d(TAG,"startCamera -isCameraCanUse-surface:"+mSurfaceTexture);
        if (myCamera != null) {
            try {
                
                myCamera.setPreviewTexture(mSurfaceTexture);
                myCamera.startPreview();
                
                myCamera.setPreviewCallbackWithBuffer(myPreviewCallback);
            } catch (Exception e) {
                Log.d(TAG, e.getMessage());
            }
        }


    }

    private PictureCallback mPicture = new PictureCallback() {
        @Override
        public void onPictureTaken(byte[] data, Camera camera) {
            File pictureFile = getOutputMediaFile(MEDIA_TYPE_IMAGE);
            if (pictureFile == null) {
                Log.d(TAG,
                        "Error creating media file, check storage permissions: "
                                + "e.getMessage()");
                return;
            }
            try {
                FileOutputStream fos = new FileOutputStream(pictureFile);
                fos.write(data);
                fos.close();
                Log.d(TAG, "File ok getPath: " + pictureFile.getPath());
            } catch (FileNotFoundException e) {
                Log.d(TAG, "File not found: " + e.getMessage());
            } catch (IOException e) {
                Log.d(TAG, "Error accessing file: " + e.getMessage());
            }
        }
    };
    /** 为保存图片或视频创建File */
    private static File getOutputMediaFile(int type) {
        // 安全起见，在使用前应该
        // 用Environment.getExternalStorageState()检查SD卡是否已装入
        File mediaStorageDir = new File(
                Environment
                .getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
                "MyCameraApp");
        // 如果期望图片在应用程序卸载后还存在、且能被其它应用程序共享，
        // 则此保存位置最合适
        // 如果不存在的话，则创建存储目录
        if (!mediaStorageDir.exists()) {
            if (!mediaStorageDir.mkdirs()) {
                Log.d("MyCameraApp", "failed to create directory");
                return null;
            }
            Log.d("MyCameraApp", "failed to create directory");
        }
        // 创建媒体文件名
        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss")
                .format(new Date());
        File mediaFile;
        if (type == MEDIA_TYPE_IMAGE) {
            mediaFile = new File(mediaStorageDir.getPath() + File.separator
                    + "IMG_" + timeStamp + ".jpg");
        } else if (type == MEDIA_TYPE_VIDEO) {
            mediaFile = new File(mediaStorageDir.getPath() + File.separator
                    + "VID_" + timeStamp + ".mp4");
        } else {
            return null;
        }
        return mediaFile;
    }

    
    private PreviewCallback myPreviewCallback = new PreviewCallback() {

        @Override
        public void onPreviewFrame(byte[] data, Camera camera) {
            // TODO Auto-generated method stub
            Log.e(TAG, "onPreviewFrame2");
            if (data == null ) {
                camera.addCallbackBuffer(data);
                return;
            }else{
                camera.addCallbackBuffer(data);
            }    
        }
    };


}


====缓冲（w*h）*3/2

 

跨界混迹车辆网的Android工程师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android Camera相关类功能整理
xx18030637774的博客
12-26 1121
camera3_callback_ops：Hal层回调结构体，Hal层处理结果通过当前类回调给Native，定义参考camera.cpp文件中的camera3_callback_ops定义。CameraDevice：CameraDevice Hal实现类，调用CameraModule/CameraDeviceSession和Hal层交互。CameraDeviceClientBase：CameraDeviceUser的实际实现类，向上对接CameraDevice。
Android Camera 架构
程序员Android
09-21 8855
和你一起终身学习，这里是程序员 Android 本篇文章主要介绍 Android 开发中的部分知识点，通过阅读本篇文章，您将收获以下内容: 一、Android Camera整体架构简述 二、 Camera App层简述 三、Camera Framework层简述 四、Camera Hal3 子系统 五、下面需要梳理的重点-正在进行 一.Android Camera整体架构简述 自Android8.0之后大多机型采用Camera API2 HAL3架构, 先盗改谷歌的一张图,读完整部代码后再看这张图,真的
Android camera预览流程
chengwei_peng
10-17 1万+
前面已经简单介绍了，在Android系统中open camera的流程，但是，它又是怎么预览、怎么配置流，如何最终操作到camera HAL的呢。接下来以android原生相机应用，android9，API2，camera HAL3为例，继续阅读代码，看看预览过程到底进行了什么操作？ configureStreams 操作 APP — 从open camera说起 在 Camera2 相机应用，打...
Android Camera开发完全手册
苦心人天不负
11-12 1441
随着Android版本迭代，Camera的重要性也日益凸显。Camera的数量从后置单颗发展到最新的后置五颗模组；分辨率从后置200万发展到惊人的一亿像素。Android Camera几乎每一代都在发生翻天覆地的变化。这些变化是作为终端用户直观感受得到的，而作为从业者同样能够感受到来自软硬件的巨大变化。 Google将Camera SDK从API1升级到API2；Came...
android camera zoom,Android
weixin_35241774的博客
05-27 314
8种机械键盘轴体对比本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？摘要:Android - Camera + ZoomControl我想要在Camera 加上能够放大缩小的功能，所以找了网络解，还好，有一个stackoverflow有写这个问题SurfaceView Zoom IN and OUT functionality using Custom Camerahttp://stac...
Android Camera简单整理(四)-Android Camera性能Debug经验
热门推荐
TaylorPotter的博客
04-24 1万+
针对手机厂商相机性能优化部分经验进行重点总结记录笔记
Android Camera模块(一)
weixin_44205232的博客
03-04 5303
Android Camera模块(一) 一、Android Camera架构 1.1 整体架构 架构参考Android Camera简单整理(一)-Camera Android架构(基于Q) google 官方图： 从上图得知,Android手机中Camera软件主要有大体上有4层: 1.应用层: 应用开发者调用AOSP提供的接口即可,AOSP的接口即Android提供的相机应用的通用接口,这些接口将通过Binder与Framework层的相机服务进行操作与数据传递; 2.Framework层: 位于 f
Android 10 Camera学习笔记：Camera Framework架构
biandan1231的专栏
05-16 5250
CameraFramework架构 又是很久没有写了，这几天一直在看camera framework相关源码，于是乎整理出了这个架构图。Camera API2比较好整理，反而是Camera API1花了我不少时间。好了，现在开始正文吧。本文主要是基于Android 10源码分析得出。 横向看：Camera从上到下，主要分为三层：APP client 、CameraFramework、CameraHal。这三层分别运行在不同的进程，APP client运行在APP用户进程中，CameraFramework运行
Android Camera1相机预览
最新发布
2401_84537646的博客
04-28 826
文章会持续更新的。绝对干货！！！Android进阶学习全套手册关于实战，我想每一个做开发的都有话要说，对于小白而言，缺乏实战经验是通病，那么除了在实际工作过程当中，我们如何去更了解实战方面的内容呢？实际上，我们很有必要去看一些实战相关的电子书。
Android 13 Camera预览流程详解
weixin_41678668的博客
09-11 1128
环境说明硬件设备AOSP版本Camera HAL So库Google提供的参考实现 camera.v4l2以上环境看起来似乎有些奇怪，因为Android 13的时候其实已经不再用camera.provider@2.4了，我们之所以拿这个来分析，是因为目前很多公司使用的AOSP版本并不是最新的，这个2.4版本使用的是比较多的。当然，我们分析完2.4后，后面也会分析最新的基于AIDL实现的camera.provider进程。
Android Camera简单整理(一)-Camera Android架构-基于Android 10.0
01-03
Camera整体架构简单整理一.Android Camera整体架构简述1.1 Android Camera 基本分层1.2 Android Camera工作大体流程二. Camera App层简述三. Camera Framework层简述3.1 CameraServer初始化3.2 App调用CameraServer...
Android中使用Camera类编写手机拍照App的实例教程
09-02
主要介绍了Android中使用Camera类编写手机拍照App的实例教程,整理了Camera调用硬件进行拍照的一些常用方法,需要的朋友可以参考下
Android camera 资料合集（物有所值）
03-22
(精品)Android Camera分析（整理）.pdf Android 的Camera架构介绍.pdf Camera模块解析驱动.pdf Android Camera的接口与架构介绍.pdf 第七章_Android_Camera架构.pdf 学习camera framework 总结.pdf Android框架下...
RSUtil:Android工具类整理; Android Camera 使用解决翻转、拉伸、变形问题
05-14
Android 工具类整理 最新版本 添加依赖 allprojects { repositories { maven { url 'https://jitpack.io' } } } implementation 'com.github.readsense-cn:RSUtil:1.5.5' 20201111: 采用OpenGLES 3.0来渲染Camera...
android1.5Camera相关code
07-13
自己使用的东西，暂时放这里备份一下，供以后自己整理用的。
关于 android app 返回键模拟 home键 功能的介绍_仿QQ返回键 又重新回到当前界面_锁屏状态 又要重新唤醒
qq_17169057的专栏
12-09 3020
最近有朋友问我 一些 关于 android 应用 退出了界面或应用 后 ，又要回到应用或者某个界面或者退出后且有在锁屏状态 又要重新唤醒（讲分 第一篇，第二篇 分享给大家） ： 在这里分享想我的做法，先讲第一篇，模仿 home键功能 首先，先讲下 Android home键和back键区别 back键 Android的程序无需刻意 的去退出,当你一按下手机的back键的时候，系统会
Android QLite 分页查询 增删改查
qq_17169057的专栏
11-03 498
Android ， QLite， 分页查询 ，增，删，改，查
android app 开发 如何定制自己的日志工具_系统优化 日志控制
qq_17169057的专栏
12-03 449
即便Android系统中自带的日志工具功能非常强大，但若直接用的话，貌似缺点 还是有的，主要表现是性能上的差异！因此，我们要在打印日志方面做些控制！如下： /**  *  系统优化 日志控制  * @author 张绪田  *  */ public class LogUtil{     public static final int VERBOSE = 1;
android camera
04-05
The Android camera is an application that allows users to take photos and record videos using their Android device. It is a built-in feature on most Android smartphones and tablets, and it offers ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值