Android9.0 Camera App代码跟踪之Camrea拍照

最新推荐文章于 2022-08-12 17:15:09 发布
最新推荐文章于 2022-08-12 17:15:09 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： Android系统开发 笔记 文章标签： Android9.0 Camera Camera 拍照
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38160277/article/details/102971465
版权

接上篇博文https://blog.csdn.net/weixin_38160277/article/details/102969875

上次讲到Camrea预览，这次要讲Camrea的拍照

大家还记得第一篇博客讲App启动的时候讲到的CameraActivity里面的setModuleFromIndex（）函数吗，这个就是视频，拍照，全景等模块切换的函数，该函数通过moduleIndex来切换不同的模块,看代码：

 /**
     * Sets the mCurrentModuleIndex, creates a new module instance for the given
     * index an sets it as mCurrentModule.
     */
    private void setModuleFromIndex(int moduleIndex) {
        mCameraPhotoModuleRootView.setVisibility(View.GONE);
        mCameraVideoModuleRootView.setVisibility(View.GONE);
        mCameraPanoModuleRootView.setVisibility(View.GONE);
        mCameraCaptureModuleRootView.setVisibility(View.GONE);
        mCurrentModuleIndex = moduleIndex;
        switch (moduleIndex) {
            case ModuleSwitcher.VIDEO_MODULE_INDEX:
                if(mVideoModule == null) {
                    mVideoModule = new VideoModule();
                    mVideoModule.init(this, mCameraVideoModuleRootView);
                } else {
                    mVideoModule.reinit();
                }
                mCurrentModule = mVideoModule;
                mCameraVideoModuleRootView.setVisibility(View.VISIBLE);
                break;

            case ModuleSwitcher.PHOTO_MODULE_INDEX:
                if(mPhotoModule == null) {
                    mPhotoModule = new PhotoModule();
                    mPhotoModule.init(this, mCameraPhotoModuleRootView);
                } else {
                    mPhotoModule.reinit();
                }
                mCurrentModule = mPhotoModule;
                mCameraPhotoModuleRootView.setVisibility(View.VISIBLE);
                break;

            case ModuleSwitcher.WIDE_ANGLE_PANO_MODULE_INDEX:
                if(mPanoModule == null) {
                    mPanoModule = new WideAnglePanoramaModule();
                    mPanoModule.init(this, mCameraPanoModuleRootView);
                }
                mCurrentModule = mPanoModule;
                mCameraPanoModuleRootView.setVisibility(View.VISIBLE);
                break;

            case ModuleSwitcher.CAPTURE_MODULE_INDEX:
                if(mCaptureModule == null) {
                    mCaptureModule = new CaptureModule();
                    mCaptureModule.init(this, mCameraCaptureModuleRootView);
                } else {
                    mCaptureModule.reinit();
                }
                mCurrentModule = mCaptureModule;
                mCameraCaptureModuleRootView.setVisibility(View.VISIBLE);
                break;

            case ModuleSwitcher.PANOCAPTURE_MODULE_INDEX:
                final Activity activity = this;
                if(!PanoCaptureProcessView.isSupportedStatic()) {
                    this.runOnUiThread(new Runnable() {
                        public void run() {
                            RotateTextToast.makeText(activity, "Panocapture library is missing", Toast.LENGTH_SHORT).show();
                        }
                    });
                    mCurrentModuleIndex = ModuleSwitcher.PHOTO_MODULE_INDEX;
                    //Let it fall through to photo module
                } else {
                    if (mPano2Module == null) {
                        mPano2Module = new PanoCaptureModule();
                        mPano2Module.init(this, mCameraPanoModuleRootView);
                    }
                    mCurrentModule = mPano2Module;
                    mCameraPanoModuleRootView.setVisibility(View.VISIBLE);
                    break;
                }
            case ModuleSwitcher.LIGHTCYCLE_MODULE_INDEX: //Unused module for now
            case ModuleSwitcher.GCAM_MODULE_INDEX:  //Unused module for now
            default:
                // Fall back to photo mode.
                if(mPhotoModule == null) {
                    mPhotoModule = new PhotoModule();
                    mPhotoModule.init(this, mCameraPhotoModuleRootView);
                } else {
                    mPhotoModule.reinit();
                }
                mCurrentModule = mPhotoModule;
                mCameraPhotoModuleRootView.setVisibility(View.VISIBLE);
                break;
        }
    }

这里默认是进入到PhotoModule的也就是拍照模块，我们再来看看拍照的代码在哪里？打开PhotoModule.java，我们直接找一下有没有capture()，果然有，look：

 @Override
    public boolean capture() {
        // If we are already in the middle of taking a snapshot or the image save request
        // is full then ignore.
        if (mCameraDevice == null || mCameraState == SNAPSHOT_IN_PROGRESS
                || mCameraState == SWITCHING_CAMERA
                || mCameraState == PREVIEW_STOPPED
                || mActivity.getMediaSaveService() == null
                || mActivity.getMediaSaveService().isQueueFull()) {
            return false;
        }
        mCaptureStartTime = System.currentTimeMillis();
        mPostViewPictureCallbackTime = 0;
        mJpegImageData = null;

        final boolean animateBefore = (mSceneMode == CameraUtil.SCENE_MODE_HDR);
        if(mHiston) {
            if (mSnapshotMode != CameraInfoWrapper.CAMERA_SUPPORT_MODE_ZSL) {
                mHiston = false;
                mCameraDevice.setHistogramMode(null);
            }
            mActivity.runOnUiThread(new Runnable() {
                public void run() {
                    if(mGraphView != null)
                        mGraphView.setVisibility(View.INVISIBLE);
                }
            });
        }

        if (animateBefore) {
            animateAfterShutter();
        }

        if (mCameraState == LONGSHOT) {
            mCameraDevice.setLongshot(true);
        }

        // Set rotation and gps data.
        int orientation = mOrientation;
        mJpegRotation = CameraUtil.getJpegRotationForCamera1(mCameraId, orientation);
        String pictureFormat = mParameters.get(KEY_PICTURE_FORMAT);
        Location loc = getLocationAccordPictureFormat(pictureFormat);
        //这里是线程安全的，同一时间Camera只允许一个进程访问
        synchronized (mCameraDevice) {
            mParameters.setRotation(mJpegRotation);
            CameraUtil.setGpsParameters(mParameters, loc);

            if (mRefocus) {
                mParameters.set(CameraSettings.KEY_QC_LEGACY_BURST,
                        CameraSettings.KEY_QC_RE_FOCUS_COUNT);
            } else {
                mParameters.remove(CameraSettings.KEY_QC_LEGACY_BURST);
            }

            // Unlock AE&AWB, if they continue
            // to be locked during snapshot, then
            // side effects could be triggered w.r.t.
            // flash.
            mFocusManager.setAeAwbLock(false);
            setAutoExposureLockIfSupported();
            setAutoWhiteBalanceLockIfSupported();
            //设置Camrea参数，什么曝光量啊，色彩值啊，锐度啊都用Camrea的SetParameters里面设置，你只需要把这些参数封装好传给Camera就行
            mCameraDevice.setParameters(mParameters);
            mParameters = mCameraDevice.getParameters();
        }

        try {
            mBurstSnapNum = mParameters.getInt("num-snaps-per-shutter");
        }catch (NumberFormatException ex){
            mBurstSnapNum = 1;
        }
        mReceivedSnapNum = 0;
        mPreviewRestartSupport = PersistUtil.isPreviewRestartEnabled();
        mPreviewRestartSupport &= CameraSettings.isInternalPreviewSupported(
                mParameters);
        mPreviewRestartSupport &= (mBurstSnapNum == 1);
        // Restart is needed  if HDR is enabled
        mPreviewRestartSupport &= !CameraUtil.SCENE_MODE_HDR.equals(mSceneMode);
        mPreviewRestartSupport &= PIXEL_FORMAT_JPEG.equalsIgnoreCase(
                pictureFormat);

        // We don't want user to press the button again while taking a
        // multi-second HDR photo. For longshot, no need to disable.
        if (mCameraState != LONGSHOT) {
            mUI.enableShutter(false);
        }

        if (!isShutterSoundOn()) {
            mCameraDevice.enableShutterSound(false);
        } else {
            mCameraDevice.enableShutterSound(!mRefocus);
        }

        mSaveBokehXmp = mIsBokehMode && mDepthSuccess;

        if (mCameraState == LONGSHOT) {
            mLongShotCaptureCountLimit = SystemProperties.getInt(
                                    "persist.sys.camera.longshot.shotnum", 0);
            mLongShotCaptureCount = 1;
            if(mLongshotSave) {
//调用Camera的takePicture方法传入回调函数，拍照完成会回调这些函数并传递图片信息过来给App存储和编辑
                mCameraDevice.takePicture(mHandler,
                        new LongshotShutterCallback(),
                        mRawPictureCallback, mPostViewPictureCallback,
                        new LongshotPictureCallback(loc));
            } else {
                mCameraDevice.takePicture(mHandler,
                        new LongshotShutterCallback(),
                        mRawPictureCallback, mPostViewPictureCallback,
                        new JpegPictureCallback(loc));
            }
        } else {
            mCameraDevice.takePicture(mHandler,
                    new ShutterCallback(!animateBefore),
                    mRawPictureCallback, mPostViewPictureCallback,
                    new JpegPictureCallback(loc));
            setCameraState(SNAPSHOT_IN_PROGRESS);
        }

        mNamedImages.nameNewImage(mCaptureStartTime, mRefocus);

        if (mSnapshotMode != CameraInfoWrapper.CAMERA_SUPPORT_MODE_ZSL) {
            mFaceDetectionStarted = false;
        }
        UsageStatistics.onEvent(UsageStatistics.COMPONENT_CAMERA,
                UsageStatistics.ACTION_CAPTURE_DONE, "Photo", 0,
                UsageStatistics.hashFileName(mNamedImages.mQueue.lastElement().title + ".jpg"));
        return true;
    }

代码跟踪到这里，你也许会有疑问，这个capture()函数是何时调用执行的？这当然是在按下快门键的时候调用的。接下来就跟踪一下快门键按钮，找到ShutterButton.java

/**
 * A button designed to be used for the on-screen shutter button.
 * It's currently an {@code ImageView} that can call a delegate when the
 * pressed state changes.
 */
public class ShutterButton extends RotateImageView {

    private class LongClickListener implements View.OnLongClickListener {
         public boolean onLongClick(View v) {
            ...
             return false;
         }
    }

    ....
    public interface OnShutterButtonListener {
        /**
         * Called when a ShutterButton has been pressed.
         *
         * @param pressed The ShutterButton that was pressed.
         */
        void onShutterButtonFocus(boolean pressed);
        void onShutterButtonClick();
        void onShutterButtonLongClick();
    }
...
private OnShutterButtonListener mListener;
....
public void setOnShutterButtonListener(OnShutterButtonListener listener) {
        mListener = listener;
        setOnLongClickListener(mLongClick);
    }
@Override
    public boolean performClick() {
        boolean result = super.performClick();
        if (mListener != null && getVisibility() == View.VISIBLE) {
            mListener.onShutterButtonClick();
        }
        return result;
    }
    ....
}

可看到它是一个自定义的ImageView来的里面有个OnShutterButtonListener 接口，这个接口是用来规定快门键点击事件的。现在来看下谁实现了这个接口

public class PhotoModule
        implements CameraModule,
        PhotoController,
        FocusOverlayManager.Listener,
        CameraPreference.OnPreferenceChangedListener,
        ShutterButton.OnShutterButtonListener,
        MediaSaveService.Listener,
        OnCountDownFinishedListener,
        LocationManager.Listener,
        SensorEventListener, MakeupLevelListener {

可见就是PhotoModule本身实现了这个接口，那接下来就看下它的实现方法

//当快门按钮点击的时候会调用到这个函数 
@Override
    public synchronized void onShutterButtonClick() {
        .....
            initiateSnap();
        ....
    }

private void initiateSnap()
    {
        if(mPreferences.getString(CameraSettings.KEY_SELFIE_FLASH,
                mActivity.getString(R.string.pref_selfie_flash_default))
                .equalsIgnoreCase("on") &&
                mCameraId == CameraHolder.instance().getFrontCameraId()) {
            mUI.startSelfieFlash();
            if(selfieThread == null) {
                selfieThread = new SelfieThread();
                selfieThread.start();
            }
        } else {
            mFocusManager.doSnap();
        }
    }
//FocusOverlayManager类
 public void doSnap() {
        if (!mInitialized) return;

        // If the user has half-pressed the shutter and focus is completed, we
        // can take the photo right away. If the focus mode is infinity, we can
        // also take the photo.
        if (!needAutoFocusCall() || (mState == STATE_SUCCESS || mState == STATE_FAIL)) {
            capture();
        } else if (mState == STATE_FOCUSING) {
            // Half pressing the shutter (i.e. the focus button event) will
            // already have requested AF for us, so just request capture on
            // focus here.
            mState = STATE_FOCUSING_SNAP_ON_FINISH;
        } else if (mState == STATE_IDLE) {
            // We didn't do focus. This can happen if the user press focus key
            // while the snapshot is still in progress. The user probably wants
            // the next snapshot as soon as possible, so we just do a snapshot
            // without focusing again.
            capture();
        }
    }

private void capture() {
        if (mListener.capture()) {
            mState = STATE_IDLE;
            mHandler.removeMessages(RESET_TOUCH_FOCUS);
        }
    }

代码跟踪到这里mListener.capture()这行代码是干嘛的捏，请看mListener是什么玩意：

 public interface Listener {
        public void autoFocus();
        public void cancelAutoFocus();
        public boolean capture();
        public void startFaceDetection();
        public void stopFaceDetection();
        public void setFocusParameters();
    }

它是一个接口，定义在FocusOverlayManager类里面，那么谁实现了这个接口呢

look，又是PhotoModule

public class PhotoModule
        implements CameraModule,
        PhotoController,
        FocusOverlayManager.Listener,
        CameraPreference.OnPreferenceChangedListener,
        ShutterButton.OnShutterButtonListener,
        MediaSaveService.Listener,
        OnCountDownFinishedListener,
        LocationManager.Listener,
        SensorEventListener, MakeupLevelListener {

看下它的实现方法capture()

@Override
    public boolean capture() {
        // If we are already in the middle of taking a snapshot or the image save request
        // is full then ignore.
        if (mCameraDevice == null || mCameraState == SNAPSHOT_IN_PROGRESS
                || mCameraState == SWITCHING_CAMERA
                || mCameraState == PREVIEW_STOPPED
                || mActivity.getMediaSaveService() == null
                || mActivity.getMediaSaveService().isQueueFull()) {
            return false;
        }
        mCaptureStartTime = System.currentTimeMillis();
        mPostViewPictureCallbackTime = 0;
        mJpegImageData = null;

        final boolean animateBefore = (mSceneMode == CameraUtil.SCENE_MODE_HDR);
        if(mHiston) {
            if (mSnapshotMode != CameraInfoWrapper.CAMERA_SUPPORT_MODE_ZSL) {
                mHiston = false;
                mCameraDevice.setHistogramMode(null);
            }
            mActivity.runOnUiThread(new Runnable() {
                public void run() {
                    if(mGraphView != null)
                        mGraphView.setVisibility(View.INVISIBLE);
                }
            });
        }

        if (animateBefore) {
            animateAfterShutter();
        }

        if (mCameraState == LONGSHOT) {
            mCameraDevice.setLongshot(true);
        }

        // Set rotation and gps data.
        int orientation = mOrientation;
        mJpegRotation = CameraUtil.getJpegRotationForCamera1(mCameraId, orientation);
        String pictureFormat = mParameters.get(KEY_PICTURE_FORMAT);
        Location loc = getLocationAccordPictureFormat(pictureFormat);

        synchronized (mCameraDevice) {
            mParameters.setRotation(mJpegRotation);
            CameraUtil.setGpsParameters(mParameters, loc);

            if (mRefocus) {
                mParameters.set(CameraSettings.KEY_QC_LEGACY_BURST,
                        CameraSettings.KEY_QC_RE_FOCUS_COUNT);
            } else {
                mParameters.remove(CameraSettings.KEY_QC_LEGACY_BURST);
            }

            // Unlock AE&AWB, if they continue
            // to be locked during snapshot, then
            // side effects could be triggered w.r.t.
            // flash.
            mFocusManager.setAeAwbLock(false);
            setAutoExposureLockIfSupported();
            setAutoWhiteBalanceLockIfSupported();

            mCameraDevice.setParameters(mParameters);
            mParameters = mCameraDevice.getParameters();
        }

        try {
            mBurstSnapNum = mParameters.getInt("num-snaps-per-shutter");
        }catch (NumberFormatException ex){
            mBurstSnapNum = 1;
        }
        mReceivedSnapNum = 0;
        mPreviewRestartSupport = PersistUtil.isPreviewRestartEnabled();
        mPreviewRestartSupport &= CameraSettings.isInternalPreviewSupported(
                mParameters);
        mPreviewRestartSupport &= (mBurstSnapNum == 1);
        // Restart is needed  if HDR is enabled
        mPreviewRestartSupport &= !CameraUtil.SCENE_MODE_HDR.equals(mSceneMode);
        mPreviewRestartSupport &= PIXEL_FORMAT_JPEG.equalsIgnoreCase(
                pictureFormat);

        // We don't want user to press the button again while taking a
        // multi-second HDR photo. For longshot, no need to disable.
        if (mCameraState != LONGSHOT) {
            mUI.enableShutter(false);
        }

        if (!isShutterSoundOn()) {
            mCameraDevice.enableShutterSound(false);
        } else {
            mCameraDevice.enableShutterSound(!mRefocus);
        }

        mSaveBokehXmp = mIsBokehMode && mDepthSuccess;

        if (mCameraState == LONGSHOT) {
            mLongShotCaptureCountLimit = SystemProperties.getInt(
                                    "persist.sys.camera.longshot.shotnum", 0);
            mLongShotCaptureCount = 1;
            if(mLongshotSave) {
                mCameraDevice.takePicture(mHandler,
                        new LongshotShutterCallback(),
                        mRawPictureCallback, mPostViewPictureCallback,
                        new LongshotPictureCallback(loc));
            } else {
                mCameraDevice.takePicture(mHandler,
                        new LongshotShutterCallback(),
                        mRawPictureCallback, mPostViewPictureCallback,
                        new JpegPictureCallback(loc));
            }
        } else {
            mCameraDevice.takePicture(mHandler,
                    new ShutterCallback(!animateBefore),
                    mRawPictureCallback, mPostViewPictureCallback,
                    new JpegPictureCallback(loc));
            setCameraState(SNAPSHOT_IN_PROGRESS);
        }

        mNamedImages.nameNewImage(mCaptureStartTime, mRefocus);

        if (mSnapshotMode != CameraInfoWrapper.CAMERA_SUPPORT_MODE_ZSL) {
            mFaceDetectionStarted = false;
        }
        UsageStatistics.onEvent(UsageStatistics.COMPONENT_CAMERA,
                UsageStatistics.ACTION_CAPTURE_DONE, "Photo", 0,
                UsageStatistics.hashFileName(mNamedImages.mQueue.lastElement().title + ".jpg"));
        return true;
    }

是不是似曾相识，哈哈，对又绕回来了，这个就是开始的时候讲的那个capture()，有点晕了吧，现在来理一下：

当快门按钮ShutterButton按下时会回调OnShutterButtonListener的onShutterButtonClick()方法，而实现该接口的PhotoModule类的onShutterButtonClick()会被执行，接着又调用到了FocusOverlayManager的doSnap() ，而doSnap() 又调用到了FocusOverlayManager.Listener的capture()函数，PhotoModule正是FocusOverlayManager.Listener的实现类，所以最终PhotoModule的capture()被执行，调用系统层api实现拍照功能。

讲到这里可能大家会郁闷，怎么那么多的接口，就不能直白一点吗?说实话我也郁闷，但是用接口写的好处就是结构清晰，写大型项目就需要这样的。当然你也可以直白一点写，但是项目大了就会出问题的。

好了，本博到此结束，下篇我还会接着讲Camera的其他功能流程，敬请期待。

谢谢大家，祝你工作顺利，生活愉快

 

米兰铁匠的锤子
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android9.0 Camera2 API 使用流程分析（MTK）
zjy764219923的专栏
12-05 1245
camera api2 mtkcam3
android 9.0 Camera2 去掉后置摄像头仅支持前置摄像头功能
最新发布
安卓兼职framework和app工程师的博客
02-19 836
在9.0的系统产品rom定制化开发中，在一些产品中只有前置摄像头一个摄像头的产品中，这时在打开摄像头的时候，只需要打开前置摄像头的就可以了，所以这需要 在Camera2的app中找到关于调用打开摄像头的方法，然后把后置摄像头也换成前置摄像头就可以了，接下来分析下Camera2调用打开摄像头的相关方法，来实现 功能需求的研发。
android Camera源码（可用）
03-03
修改了包名，可以直接运行，没有bug。之前找的都有问题不能用。
Android9.0 系统摄像头前后置预览问题
Y的博客
08-12 1888
在插入的USB摄像头后，会生成/dev/video0这样的设备节点，而在硬件抽象层中，会去判断是否存在该设备节点，以提供给android系统层使用，再往上分析就是android部分，暂时先不分析。
Android 9.0 hal3 CTS Verifier Camera Video配置修改
weicaihui2008的博客
06-07 755
CTS Verifier Camera Video hal3如何配置
详解Android app自动更新总结（已适配9.0）
08-26
主要介绍了详解Android app自动更新总结（已适配9.0），文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
android 9.0 launcher3 去掉抽屉式显示所有 app(代码详解)
08-25
本文通过实例代码给大家介绍了android 9.0 Launcher3 去掉抽屉式,显示所有 app,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
ANDROID9.0 蓝牙主从切换方案.rar
07-30
在Android 9.0系统中，蓝牙功能的灵活性得到了显著提升，其中一项重要的特性就是支持蓝牙主从角色的切换。这个“ANDROID9.0 蓝牙主从模式一键切换”方案旨在帮助开发者和用户更加方便地管理蓝牙设备，使得在不同场景...
android Camera自动拍照、自动对焦并获取指定大小图片
01-03
1.首先android6.0以上版本要动态申请相机和文件读写权限 2.废话不啰嗦，上代码： /** * 摄像头画面采集界面 */ public class DistinguishActivity extends BaseActivity implements SurfaceHolder.Callback, ...
【移动安全】Android App Smail代码动态跟踪调试方法
Walter的专栏
08-12 3635
1、反编译可调试模式的smail代码D:\software\android\ApkTool\dump\apktool>java -jar apktool.jar d -d b11842d4126d 72df16c1c1870c819c37.apk -o out I: Using Apktool 2.0.0-RC3 on b11842d4126d72df16c1c1870c819c37.apk I:
Android——华为手机（G9）调用Camera需要手动申请权限
01-13
blog:http://www.cnblogs.com/ityizhainan/p/6283328.html
Android移动开发-调用摄像头进行拍照的实现
09-30
现在Android智能手机的像素都会提供照相的功能，大部分的手机的摄像头的像素都在1000万以上的像素，有的甚至会更高。它们大多都会支持光学变焦、曝光以及快门等等。 下面的程序Demo实例示范了使用Camera v2来进行拍照，当用户按下拍照键时，该应用会自动对焦，当对焦成功时拍下照片。
Android 自带应用相机(Camera)源代码
12-29
Android 自带应用相机(Camera)源代码
android 启动相机程序,Android Camera启动流程之一app
weixin_33185261的博客
05-26 798
8种机械键盘轴体对比本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？转载请注明出处。前言今天开始来梳理Camera模块的整体流程，代码基于Android O上Camera2模块来分析。Camera模块是比较复杂的，贯穿整个Android上下层，需要分多篇来整理。这篇只涉及app层的初始化逻辑。流程依惯例，先上图。 下面根据此流程图来一步步细化。CameraActivity的初始化Came...
Android调用相机拍照和本地上传图片添加到ImageView 适配6.0,7.0,8.0,9.0
ridgepole_king的博客
09-10 1643
## 引言:首先工作中可以学到新的东西,在项目开发中会常常遇到一些问题.多番查找资料一直9.0版本拍照和相册一直无法显示,并且把ImageView默认的占位图都消失.问题已经解决. 1,首先版本6.0以上必须动态授权,9.0手机好像可以自动检测并弹出对话框询问. 2,直接看代码吧: 加入app中build.gradle //动态权限申请库 implementation ‘pub.devrel:ea...
Android Camera预览对着强光闪烁
weixin_49118704的博客
09-01 383
关闭自动曝光。 Camera.Parameters parameters = camera.getParameters(); parameters.setAutoExposureLock(true); camera.setParameters(parameters);
骁龙camera预览拍照录像流程 api1和api2
fuyinghaha的专栏
06-17 1567
首先说api1的预览流程 CameraActivity的onCreate先区分是不是安全模式(锁屏进入就是安全模式)，如果是安全模式会设置flag indowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED这个flag会在锁屏的时候显示出来 if (mSecureCamera) { // Change the window flags so that secure camera can show when locked
java图像白平衡_Camera.Parameters 参数
weixin_29164091的博客
02-27 1119
public classCamera.Parametersextends Objectjava.lang.Object↳android.hardware.Camera.ParametersClass Overview类概述相机的服务设置。使相机参数生效，应用程序必须调用setparameters(相机参数。)。例如，在setwhitebalance(字符串)被称为，白平衡不实际上改变了之前setp...
Camera参数
Wubo的博客
01-25 1781
这源码参数，你知道几个 常数 String antibanding_50hz   反冲带 String antibanding_60hz   String antibanding_auto   String antibanding_off   String effect_aqua   String effect_blackboard   String effect_
Android 9.0 Camera2框架详解与进程协作
Android 最新Camera框架是Android 9.0及后续版本中重要的图像处理和采集技术的核心组成部分，它在提升设备摄像头性能、降低系统碎片化以及增强更新灵活性方面发挥了关键作用。这个框架涉及多个进程间的协作与通信，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值