Android Camera默认属性设置

最新推荐文章于 2025-04-22 15:19:22 发布
最新推荐文章于 2025-04-22 15:19:22 发布
阅读量4.3k 收藏 2
点赞数
分类专栏： 个人学习总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdnxialei/article/details/82625382
版权

需求说明：系统自带Camera需要修改默认图片预览比例以及录像比例。

android版本：8.1

Camera的启动activity是CameraActivity.java

在启动之后在oncreate里开启了许多初始化相关的代码。

    @Override
    public void onCreate(Bundle icicle) {

        super.onCreate(icicle);
        。。。。
        mCameraDeviceCtrl = new CameraDeviceCtrl(this, mPreferences);

        if (mPermissionManager.requestCameraLaunchPermissions()) {
            mCameraDeviceCtrl.openCamera();
        }
        。。。。
        ModuleCtrlImpl moduleCtrl = new ModuleCtrlImpl(this);
        CameraPerformanceTracker.onEvent(TAG,
                CameraPerformanceTracker.NAME_CAMERA_INIT_VIEW_MANAGER,
                CameraPerformanceTracker.ISBEGIN);
        mCameraAppUi = new CameraAppUiImpl(this);
        mCameraAppUi.createCommonView();
        initializeCommonManagers();
        mCameraAppUi.initializeCommonView();
        。。。
        setContentView(R.layout.camera);
        。。。
        parseIntent();
        CameraPerformanceTracker.onEvent(TAG,
                CameraPerformanceTracker.NAME_CAMERA_CREATE_MODULE,
                CameraPerformanceTracker.ISBEGIN);
        mModuleManager = new ModuleManager(this, fileSaver, mCameraAppUi,
                featureConfig, deviceManager, moduleCtrl, mISelfTimeManager);
        mISettingCtrl = mModuleManager.getSettingController();
        mCameraAppUi.setSettingCtrl(mISettingCtrl);

在setcontentview之前，创建了CameraDeviceCtrl，

在CameraDeviceCtrl的构造方法里

    public CameraDeviceCtrl(CameraActivity activity, ComboPreferences preferences) {
        mCameraActivity = activity;
        mPreferences = preferences;
        mIsFirstStartUp = true;
        mMainHandler = new MainHandler(mCameraActivity.getMainLooper());
        mCameraStartUpThread = new CameraStartUpThread();
        mCameraStartUpThread.start();
        HandlerThread ht = new HandlerThread("Camera Handler Thread");
        ht.start();
        mCameraHandler = new CameraHandler(ht.getLooper());
    }

创建了CameraStartUpThread线程，并且启动了它。

在CameraStartUpThread的run方法里，就开始了各个参数的配置

@Override
        public void run() {
            while (mIsActive) {

                if (mIsFirstStartUp) {
                    CameraPerformanceTracker.onEvent(TAG,
                            CameraPerformanceTracker.NAME_CAMERA_START_UP,
                            CameraPerformanceTracker.ISBEGIN);
                    int openResult = firstOpenCamera();
                    if (CAMERA_OPEN_SUCEESS != openResult) {
                        setCameraState(CameraState.STATE_CAMERA_CLOSED);
                        mIsFirstStartUp = false;
                        continue;
                    }
                    ModeChecker.updateModeMatrix(mCameraActivity, mCameraId);
                    mCurCameraDevice.setDisplayOrientation(true);
                    mCurCameraDevice.setPreviewSize();
                    // if open camera too quickly, here may be run with
                    // setCameraActor at the same time, this will make CameraStartUpThread
                    // pause forever, so we synchronize it for workaround.
                    synchronized (mCameraActorSync) {
                        if (mCameraActor == null) {
                            try {
                                mCameraActorSync.wait();
                            } catch (InterruptedException e) {
                                Log.e(TAG, "mCameraActorSync.wait with InterruptedException");
                            }
                        }
                    }
                    mCameraActor.onCameraOpenDone();
                    mModuleManager.onCameraOpen();
                    initializeFocusManager();
                    if (mCameraActivity.getCurrentMode() == ModePicker.MODE_PHOTO) {
                        mCurCameraDevice.setPhotoModeParameters(
                                mCameraActivity.isNonePickIntent());
                    }
                    if (mCancel) {
                        Log.d(TAG, "[mIsFirstStartUp.run] cancel after openCamera");
                        mIsFirstStartUp = false;
                        continue;
                    }

                    if (mCameraActivity.isVideoCaptureIntent()) {
                        initializeSettingController();
                        mModuleManager.setModeSettingValue(
                                mCameraActor.getCameraModeType(mCameraActor.getMode()), "on");
                    }
                    applyFirstParameters();
                    //Block startUp thread when not set surface to native
                    mSycForLaunch.block(500);
                    mCurCameraDevice.setOneShotPreviewCallback(mOneShotPreviewCallback);
                    mMainHandler.sendEmptyMessage(MSG_CAMERA_PARAMETERS_READY);
                    mMainHandler.sendEmptyMessage(MSG_CAMERA_PREVIEW_DONE);
                    mMainHandler.sendEmptyMessage(MSG_CAMERA_OPEN_DONE);
                    Storage.mkFileDir(Storage.getFileDirectory());
                    clearDeviceCallbacks();
                    applyDeviceCallbacks();
                    mCameraAppUi.clearViewCallbacks();
                    mCameraAppUi.applayViewCallbacks();
                    if (mCancel) {
                        Log.d(TAG, "[mIsFirstStartUp.run]" +
                                " cancel before initializeSettingController");
                        mIsFirstStartUp = false;
                        continue;
                    }
                    if (!mCameraActivity.isVideoCaptureIntent()) {
                        initializeSettingController();
                        mModuleManager.setModeSettingValue(
                                mCameraActor.getCameraModeType(mCameraActor.getMode()), "on");
                    }
                    if (mCancel) {
                        Log.d(TAG, "[mIsFirstStartUp.run] cancel before applySecondParameters");
                        mIsFirstStartUp = false;
                        continue;
                    }
                    applySecondParameters();
                    setCameraState(CameraState.STATE_CAMERA_OPENED);
                    mIsFirstStartUp = false;
                    CameraPerformanceTracker.onEvent(TAG,
                            CameraPerformanceTracker.NAME_CAMERA_START_UP,
                            CameraPerformanceTracker.ISEND);
                    continue;
                }
                。。。。。

        }

这里做了个判断mIsFirstStartUp，接着走第一次启动的时候的初始化，

这里有两个关键点：

mCurCameraDevice.setPreviewSize() 是设置预览尺寸的地方，

initializeSettingController是进一步初始化其他设置属性

第一步：先看看setPreviewsize做了什么

可以发现，mCurCameraDevice是接口对象，而setPreviewSize是接口中的方法，找到是谁实现接口，发现

public interface ICameraDeviceExt
public class CameraDeviceExt implements ICameraDeviceExt

于是去看CameraDeviceExt的setPreviewSize方法里做了什么

@Override
    public void setPreviewSize() {
        String pictureRatio = mPreferences.getString(SettingConstants.KEY_PICTURE_RATIO, 
        null);
        if (pictureRatio == null) {
            List<String> supportedRatios = SettingUtils.buildPreviewRatios(mActivity,
                    mParametersExt);
            if (supportedRatios != null && supportedRatios.size() > 0) {
                SharedPreferences.Editor editor = mPreferences.edit();
                String ratioString = supportedRatios.get(0);
                editor.putString(SettingConstants.KEY_PICTURE_RATIO, ratioString);
                editor.apply();
                pictureRatio = ratioString;
            }
        }
        SettingUtils.setPreviewSize(mActivity, mParametersExt, pictureRatio);

        String pictureSize = mPreferences.getString(SettingConstants.KEY_PICTURE_SIZE, 
        null);
        int limitedResolution = SettingUtils.getLimitResolution();
        if (limitedResolution > 0) {
            int index = pictureSize.indexOf('x');
            int width = Integer.parseInt(pictureSize.substring(0, index));
            int height = Integer.parseInt(pictureSize.substring(index + 1));
            if (width * height > limitedResolution) {
                pictureSize = null;
            }
        }
        if (pictureSize == null) {
            List<String> supportedSizes = SettingUtils
                    .buildSupportedPictureSizeByRatio(mParametersExt, pictureRatio);
            SettingUtils.sortSizesInAscending(supportedSizes);
            if (limitedResolution > 0) {
                SettingUtils.filterLimitResolution(supportedSizes);
            }

            if (supportedSizes != null && supportedSizes.size() > 0) {
                pictureSize = supportedSizes.get(supportedSizes.size() - 1);
                SharedPreferences.Editor editor = mPreferences.edit();
                editor.putString(SettingConstants.KEY_PICTURE_SIZE, pictureSize);
                editor.apply();

            }
        }
        Point ps = SettingUtils.getSize(pictureSize);
        mParametersExt.setPictureSize(ps.x, ps.y);
    }

可以发现，这里先是根据KEY_PICTURE_RATIO这个key从preference里获取ratio比率值，在还没有初始化完成前，这个ratio其实是空的，于是会去构造属性，SettingUtils.buildPreviewRatios会根据系统属性来获取系统支持的预览比例，得到一个数组，从数组里取出制定元素，存入SharedPreference里，然后再根据这个ratio也就是比如  4：3 = 1.333  16：9=17.777

从这些double值来匹配得到指定比例属性，然后再把这个picturesize设置给parameters去设置显示大小。

经过调试，发现supportedsizs这个列表的构造过程是这样的

public static List<String> buildPreviewRatios(Context context, Parameters parameters) {
        List<String> supportedRatios = new ArrayList<String>();
        String findString = null;
        if (context != null && parameters != null) {
            // Add standard preview ratio.
            supportedRatios.add(getRatioString(4d / 3));

            mCurrentFullScreenRatio = findFullscreenRatio(context);
            List<String> fullScreenPictureSizes = buildSupportedPictureSizeByRatio(parameters,
                    getRatioString(mCurrentFullScreenRatio));
            // Add full screen ratio if platform has full screen ratio picture sizes.
            if (fullScreenPictureSizes.size() > 0) {
                findString = getRatioString(mCurrentFullScreenRatio);
                if (!supportedRatios.contains(findString)) {
                    supportedRatios.add(findString);
                }
            }
        }
        return supportedRatios;
    }

第一个元素默认是标准比例  4：3， 接着就是系统的全屏比例，但是不论如何，列表的第一个是4：3=1.333  而其他的可能是16:9或者5：2等等，会根据搜索结果找到并添加到列表里。

然后客户的需要就是要设置成默认4：3，于是前面put放入preference的值，只能是get(0)第一个元素，经过验证，打开相机就是默认了4：3的预览模式，不是全屏。

搞定了照片预览模式，接着找video的预览比例设置。

第二步：initializeSettingController

    private void initializeSettingController() {
        if (!mISettingCtrl.isSettingsInitialized()) {
            mISettingCtrl.initializeSettings(R.xml.camera_preferences, mPreferences.getGlobal(),
                    mPreferences.getLocal());
        }
        mISettingCtrl.updateSetting(mPreferences.getLocal());
        // Workaround for hdr value is on in pip video mode when pause and resume camera
        // again in pip video mode.
        if (mCameraActor.getMode() == ModePicker.MODE_VIDEO_PIP
                && mISettingCtrl.getSetting(SettingConstants.KEY_HDR) != null) {
            mISettingCtrl.onSettingChanged(SettingConstants.KEY_HDR, "off");
        }
        mMainHandler.sendEmptyMessage(MSG_CAMERA_PREFERENCE_READY);
    }

mISettingCtrl的initializeSettings

    @Override
    public void initializeSettings(int preferenceRes, SharedPreferences globalPref,
            SharedPreferences localPref) {
//        Log.d(TAG, "[initializeSettings]...");
        mGlobalPref = globalPref;
        mLocalPrefs.put(mICameraDeviceManager.getCurrentCameraId(), localPref);
        mPrefTransfer = new SharedPreferencesTransfer(globalPref, localPref);
        mSettingGenerator = new SettingGenerator(mICameraContext, mPrefTransfer);
        mSettingGenerator.createSettings(preferenceRes);
        createRules();
        mIsInitializedSettings = true;
    }

这里有settingGenerator，并且还看到createSettings

    public void createSettings(int preferenceRes) {
        mPreferenceRes = preferenceRes;
        mInflater = new PreferenceInflater(mContext, mPrefTransfer);
        int currentCameraId = mICameraDeviceManager.getCurrentCameraId();
        PreferenceGroup group = (PreferenceGroup) mInflater.inflate(preferenceRes);
        mPreferencesGroupMap.put(currentCameraId, group);
        createSettingItems();
        createPreferences(group, currentCameraId);
    }

createSettingItems

createPreferences

两步，创建设置的item并且创建属性存入preference

private void createPreferences(PreferenceGroup group, int cameraId) {
//        Log.d(TAG, "[createPreferences], cameraId:" + cameraId + ", group:" + group);
        ArrayList<ListPreference> preferences = mPreferencesMap.get(cameraId);
        mSupportedImageProperties = new ArrayList<String>();
        mSupportedFaceBeautyProperties = new ArrayList<String>();
        if (preferences == null) {
            preferences = new ArrayList<ListPreference>();
            ArrayList<SettingItem> settingItems = mSettingItemsMap.get(cameraId);
            for (int settingId = 0; settingId < SettingConstants.SETTING_COUNT; settingId++) {
                String key = SettingConstants.getSettingKey(settingId);
                ListPreference preference = group.findPreference(key);

                preferences.add(preference);

                SettingItem settingItem = settingItems.get(settingId);
                settingItem.setListPreference(preference);
            }
            mPreferencesMap.put(cameraId, preferences);
        }
        // every camera maintain one setting item list.
        filterPreferences(preferences, cameraId);
    }

preference的group是在settingConstants类里定义好的，这里集合初步建完了

最后过滤一下， 因为列表里是有很多preference的item，但是他们是xml里和settingConstants预先就定义好了的数组和结构体，他们中的一些属性是默认就有，有些是没有的，有些是需要从底层获取硬件信息从parameter里得到，有的是需要从preference里得到，所以构建完了，就得过滤一下，得到真实的有效的默认值。filterPreferences

    private void filterPreferences(ArrayList<ListPreference> preferences, int cameraId) {
        ArrayList<SettingItem> settingItems = mSettingItemsMap.get(cameraId);
        limitPreferencesByIntent();
        for (int i = 0; i < preferences.size(); i++) {
            // filter list preference.
            ListPreference preference = preferences.get(i);
            boolean isRemove = filterPreference(preference);
            if (isRemove) {
                preference = null;
                preferences.set(i, null);
            }
            // update setting's value and default value.
            SettingItem settingItem = settingItems.get(i);
            updateSettingItem(settingItem, preference);
        }

        overrideSettingByIntent();
    }

过滤过程，就是把每一个ListPreference给检查一遍。然后更新数据。

从源码里看，filterPreference是一个很长的switch条件选择方法，里面匹配了各个item的区别对待，

只看我想看到的

        case SettingConstants.ROW_SETTING_VIDEO_QUALITY:// video
            removePreference = filterUnsupportedOptions(preference,
                    getMTKSupportedVideoQuality(),
                    settingId);
            break;

VIDEO_QUALITY 视频质量，就是那个拍摄的质量选项 

这里看到 filterUnsupportedOptions 和getMTKSupportedVideoQuality

 private boolean filterUnsupportedOptions(ListPreference pref, List<String> supported,
            boolean resetFirst, int row) {
        if (supported != null) {
            pref.filterUnsupported(supported);
        }

        if (pref.getEntryValues().length == 1) {
            SettingItem settingItem = getSettingItem(row);
            CharSequence[] values = pref.getEntryValues();
            settingItem.setDefaultValue(values[0].toString());
            settingItem.setValue(values[0].toString());
        }

        // Remove the preference if the parameter is not supported or there is
        // only one options for the settings.
        if (supported == null || supported.size() <= 1) {
            return true;
        }

        if (pref.getEntries().length <= 1) {
            return true;
        }
        resetIfInvalid(pref, resetFirst);
        return false;
    }

就是从系统获取可用的值，来检测当前给出的值是否合理，如果不合理就默认用数组里的第一个。

    private void resetIfInvalid(ListPreference pref, boolean first) {
        // Set the value to the first entry if it is invalid.
        String value = pref.getValue();
        if (pref.findIndexOfValue(value) == NOT_FOUND) {
            if (first) {
                pref.setValueIndex(0);
            } else if (pref.getEntryValues() != null && pref.getEntryValues().length > 0) {
                pref.setValueIndex(pref.getEntryValues().length - 1);
            }
        }
    }

很明显，如果系统初始化的时候，没有指定默认可用item就是用第一个可用的item。

在updatesettingitem

private void updateSettingItem(SettingItem settingItem, ListPreference preference) {
        int settingId = settingItem.getSettingId();
        int type = SettingConstants.getSettingType(settingId);
        String defaultValue = settingItem.getDefaultValue();
        switch (type) {
        case SettingConstants.NEITHER_IN_PARAMETER_NOR_IN_PREFERENCE:
        case SettingConstants.ONLY_IN_PARAMETER:
            // set setting default value and value, the value is initialized to
            // default value.
            defaultValue = SettingDataBase.getDefaultValue(settingId);
            if (!mIModuleCtrl.isNonePickIntent()) {
                if (SettingConstants.ROW_SETTING_CAMERA_MODE == settingId) {
                    defaultValue = Integer.toString(Parameters.CAMERA_MODE_NORMAL);
                }
            }
            settingItem.setDefaultValue(defaultValue);
            settingItem.setValue(defaultValue);
            break;

        case SettingConstants.BOTH_IN_PARAMETER_AND_PREFERENCE:
        case SettingConstants.ONLY_IN_PEFERENCE:
            Parameters parameters = mICameraDevice.getParameters();
            // if setting has preferences, its default value and value get from
            // preference.
            if (preference != null) {
                preference.reloadValue();
                if (defaultValue == null) {
                    defaultValue = generateDefaultValue(settingItem.getKey(),
                            mICameraDevice.getParameters(), preference);
                }
                settingItem.setDefaultValue(defaultValue);
                settingItem.setValue(preference.getValue());
            } else {
                if(settingItem.getKey().equals(SettingConstants.KEY_PICTURE_RATIO)){
                    settingItem.setEnable(true);
                }else{
                    settingItem.setEnable(false);
                }
            }
            break;
        default:
            break;
        }
    }

settingItem设置默认的值是从preference的默认值来的，而preference的默认值又是可用item的第一个值，于是，如果我们想要给指定的属性值设置初始默认值就应该在把默认的preference的value改成我们自己的值。

这里有个ONLY_IN_PREFERNCE来自于SettingConstant的定义

static {
        // setting only in preference
        SETTING_TYPE[ROW_SETTING_DUAL_CAMERA]               = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_IMAGE_PROPERTIES]          = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_RECORD_LOCATION]           = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_MICROPHONE]                = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_AUDIO_MODE]                = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_VIDEO_QUALITY]             = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_PICTURE_RATIO]             = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_VOICE]                     = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_STEREO_MODE]               = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_FACEBEAUTY_PROPERTIES]     = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_CAMERA_FACE_DETECT]        = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_ASD]                       = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_DUAL_CAMERA_MODE]          = ONLY_IN_PEFERENCE;
        SETTING_TYPE[ROW_SETTING_DNG]                       = ONLY_IN_PEFERENCE;
        。。。。

ROW_SETTING_VIDEO_QUALITY就是录像视频质量属性

于是应该在settingItem.setValue(preference.getValue());这一行之前做个拦截，就能解决video的默认视频质量值了。

Camera在启动的时候会有很多初始化，不像其他app直接从xml或者数组里直接取值，因为有些属性会根据实际的硬件camera来加载，但是大部分的属性值都在初始化的时候给设置了默认第一个或者最后一个，极少有自定义的。

这里在调试解决问题的时候，代码量太多，很容易走错，加上惯性思维，导致在其他地方设置item的属性时没有生效，解决问题还是得从源头找起，这是需要反思的。

Android 11.0 设置Camera2的相机拍照默认像素为1080P
安卓兼职framework和app工程师的博客
06-18 3655
11.0定制化开发中，要求设置默认Camera2拍照的时候默认像素为1080P的所以就要分析Camera2拍照的相关代码来实现需求功能 3.核心代码分析和功能实现3.1分析PhoneModule拍照相关代码 3.2 ResolutionSetting.java源码分析 根据上面代码分析得出就是调用 ResolutionSetting.java 的getPictureSize(）来获取预览相机拍照的像素大小 3.3解决方法...
Android 9.0 Camera2 拍照功能默认选前摄像头
安卓兼职framework和app工程师的博客
05-09 1499
在9.0的系统产品开发中，对于app调用系统api来打开摄像头拍照的功能也是常有的功能，而拍照一般是默认打开后置摄像头拍照的，由于 客户的产品特殊要求，需要打开前置摄像头拍照功能，所以需要了解拍照功能的流程，然后修改默认前置摄像头打开拍照功能就可以了
Android Camera参数
pang9998的博客
06-26 1422
我们都知道，android是开源生态，这样造成很多设备硬件差异很大，比如照相机Camera，不同厂商可能支持不同的参数设置，如果参数设置不当有可能就Exception了，那么有没有什么方法知道相机支持哪些参数呢？答案是有的，如下代码： 然后设置参数即可...
android camera默认参数设置
chaod5659的专栏
11-29 8203
private static final String BACKPARA = "ae-mode=1;ae-mode-values=1,2,3,4,5,6,7,8,9,10,11,13,14,15,16,17,18,19,20,21," + "22;af-draw=0;af-x=0;af-y=0;afeng-mode=0;afeng-pos=0;antibanding=aut
Android录制视频，三种Camera的使用与预览及其简单封装
最新发布
dodod2012的专栏
04-22 110
本文对于常见的三种 Camera API 做了示例代码及其对于分别进行封装。对于使用哪一种 Camera 实现效果，大家可以自行选择。如果我想要回调 NV21 的数据，其实我会选择 Camera1 ,因为它本身返回就是这个格式不需要转换，如果我想要回调 I420 格式，我会选择 Camera2 或 CameraX ，反正需要转换，他们更方便，特别是配合 libyuv 库，效率会更高。如果想实现录制视频的功能呢？如果是普通的录制我会选择 CameraX 自带的录制视频功能，更加的简单方便。
Android Camera了解一下
Android茶话会
09-17 9230
首发于公众号 Android Camera了解一下 Camera 演进简介 最近在项目中遇到 Camera相关的场景，之前对这块不是很了解，趁机补了一下盲区。Android Camera 相关也是生态碎片化较为严重的一块，Android FrameWorkt提供Camera API来实现拍照与屏幕录制的能力，目前Android有三类API Camera (为了便于区分 下面简称 Camera1) 此类是用于控制设备相机的旧版API，在Android5.0以下使用，现已Deprecated Cam..
程序参数设置 android,android camera默认参数设置
weixin_31040629的博客
05-26 491
private static final String BACKPARA = "ae-mode=1;ae-mode-values=1,2,3,4,5,6,7,8,9,10,11,13,14,15,16,17,18,19,20,21," +"22;af-draw=0;af-x=0;af-y=0;afeng-mode=0;afeng-pos=0;antibanding=auto;antibanding...
Android系统Camera参数设置&&Android之Camera拍照 && Android之Camera预览过程中插拔摄像头节点后移
Gabby
04-16 4433
http://blog.youkuaiyun.com/tankai19880619/article/details/17120827 一、应用程序 1.Camera应用使用的参数对象 frameworks/base/core/java/android/hardware/Camera.java [java] view plaincopy public class Paramet
Android Camera
JackGe_41314721的博客
12-10 1186
Android 的相机硬件抽象层 (HAL) 可将 Camera 2 中较高层级的相机框架 API 连接到底层的相机驱动程序和硬件。相机子系统包括相机管道组件的实现，而相机 HAL 可提供用于实现您的这些组件版本的接口。
android camera2 设置,Android Camera2 之 CameraManager 详解
weixin_30663789的博客
05-27 1523
一、简介CameraManager 是系统服务之一，专门用于 检测 和 打开相机，以及 获取相机设备特性。二、获取 CameraManager 实例通过 Context 类的 getSystemService() 方法来获取一个系统服务，参数使用 Context.CAMERA_SERVICE 或 CameraManager.class 都行。// 方式一CameraManager manager ...
Android Camera性能优化概述
weixin_42136255的博客
10-07 2881
做camera性能优化方面的工作有几年了，想写一篇文章简单介绍一下其中涉及到的具体技术，这篇文章会大概介绍一下涉及到的技术。
android camera系列(Camera1、Camera2、CameraX)的使用以及输出的图像格式
知识共享，你我皆是知识的搬运工
01-25 5577
android中camera的预览和数据操作
android camera 全屏,Android Camera做全屏预览之最简单方法.doc
weixin_39726697的博客
05-27 797
Android Camera做全屏预览之最简单方法M厂开发五部：刘 博一、全屏预览与非全屏预览的区别对于大多数人来说，我们看电影、玩游戏等都喜欢全屏，我们之所以喜欢全屏的一个主要原因就是全屏的感觉比非全屏看起来的感觉爽，因为画面看起来变大了，有些微小的东西也能够看清楚了。即使有时候不能够去全屏欣赏，我们也会尽量去把画面调到最大化去享受。20世纪80年代到20世纪末，绝大部分人的生活质量都不怎么好...
Camera基本属性了解及设置
qq_34723470的博客
10-09 4026
将camera肯定是要有预览界面来配合着才有激情，不然无图无真相。那就讲的没有太大的激情。   我们对camera的使用一般是在app里面有用到设置获取图片的时候提供一个拍照功能，一般是跳转到系统的拍照界面使用camera来获取图片；有的app有需求就跳转到自己的拍照界面。我们知道系统的应用其实也是个app，无论是跳转到系统拍照界面还是自己的拍照界面其实都是一个preview，然后再“截屏”生成
[Android]Camera2——(1) camera模块初始化
军火库
02-23 1897
本系列文章旨在分析android应用打开摄像头并显示预览的流程。 文章将通过源码分析，总结和时序图的方式，帮助理解Camera2框架。 本篇文章将分析framework层camera相关模块的初始化，为后续分析打下基础。 1 相关源码分析 frameworks\av\camera\cameraserver\main_cameraserver.cpp int main(int argc __unused, char** argv __unused) { hardware::configureRpcTh
android CAMERA 设置照片大小
dengchonglin的专栏
12-28 7867
最近在 REAL210 android 上调试 CAMERA 驱动。 发现原来的开发板只支持 640*320 以及 320*240 ， 但是用的是 OV3640 300W 的摄像头，应该可以拍照到 2048*1536 的分辨率的。 索性把这个 300W 打开吧。 1、看看这里是否支持 300W 的分辨率，原生 ANDROID 是支持到 500W 的。 packages/apps/Came
Android 12.0 MTK Camera2 设置默认拍照尺寸功能实现
安卓兼职framework和app工程师的博客
02-17 760
​ 在12.0的系统rom定制化开发中，在mtk平台的camera2关于拍照的一些功能修改中，在一些平台默认需要设置最大的分辨率 来作为拍照的分辨率，所以就需要了解拍照尺寸设置流程，然后来实现相关的功能 ​
Android 11.0 Camera2 默认选择拍照尺寸修改及流程分析
秦逸轩的博客
08-23 4678
一、前言 最近有一个需求是修改默认的照片尺寸，这篇文章就总结一下Camara 选择默认的拍照尺寸的逻辑吧。 二、定位代码 2.1、根据“照片大小” text 可以定位到布局文件 picturesize_preference.xml. 代码路径: android\vendor\mediatek\proprietary\packages\apps\Camera2\feature\setting\picturesize\res\xml\picturesize_preference.xml`** <?xml
[RK3399][Android7.1] 调试笔记 --- 设置系统默认相机为1080p
Kris Fei's blog
06-26 3070
Platform: RK3399 OS: Android 7.1 Kernel: v4.4.83 需求： 系统相机打开默认是1280*960，需要改成1920*1080 解决方法： diff --git a/src/com/android/camera/settings/ResolutionSetting.java b/src/com/android/camera/settings/Resolu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值