Android Camera TakePicture過程分析

最新推荐文章于 2021-12-03 22:00:00 发布
最新推荐文章于 2021-12-03 22:00:00 发布
阅读量876 收藏
点赞数
分类专栏： V4L2学习

接著上一篇文章，繼續講解camera拍照等具體功能實行流程
Camera子系统采用C/S架构,客户端和服务端在两个不同的进程当中,它们使用android中的binder机制进行通信,
本系列文章将从Android Camera应用程序到硬件抽象的实现一步一步对照相机系统进行分析,首先从CameraService初始化过程着手,然后从上层APP打开照相机->进行preview->拍照以及聚焦等功能的实现全面的学习照相机子系统

1、CameraService初始化过程
frameworks\base\media\mediaserver\Main_MediaServer.cpp
CameraService在MediaServer中初始化,代码是MediaServer的main函数,在该函数中初始化照相机服务，已在上一篇文章中講述
CameraService中的instantiate方法用来创建CameraService实例,并进行相应的初始化,这个函数定义在它的父类BinderService中： frameworks/base/include/binder/ BinderService.h
相机服务的初始化过程首先是创建CameraService实例,然后将其注册到ServiceManager中,关于它的启动是发生在init.rc中,通过media_server来启动CameraService,具体代码如下：
system/core/rootdir/init.rc
service servicemanager /system/bin/servicemanager
    class core
    user system
    group system
    critical
    onrestart restart zygote
    onrestart restart media
    onrestart restart surfaceflinger
    onrestart restart drm

service media /system/bin/mediaserver
    class main
    user media
    group audio camera inet net_bt net_bt_admin net_bw_acct drmrpc
    ioprio rt 4
在cameraService注册以及启动过程中cameraService自身会执行一些初始化的工作,主要涉及到如下工作
frameworks/base/services/camera/libcameraservice/CameraService.cpp
  1. CameraService::CameraService()
  2. :mSoundRef(0), mModule(0)
  3. {
  4.     LOGI("CameraService started (pid=%d)", getpid());
  5.     gCameraService = this;
  6. }

  8. void CameraService::onFirstRef()
  9. {
  10.     BnCameraService::onFirstRef();

  12.     if (hw_get_module(CAMERA_HARDWARE_MODULE_ID,
  13.                 (const hw_module_t **)&mModule) < 0) {
  14.         LOGE("Could not load camera HAL module");
  15.         mNumberOfCameras = 0;
  16.     }
  17.     else {
  18.         mNumberOfCameras = mModule->get_number_of_cameras();
  19.         if (mNumberOfCameras > MAX_CAMERAS) {
  20.             LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
  21.                     mNumberOfCameras, MAX_CAMERAS);
  22.             mNumberOfCameras = MAX_CAMERAS;
  23.         }
  24.         for (int i = 0; i < mNumberOfCameras; i++) {
  25.             setCameraFree(i);
  26.         }
  27.     }
  28. }
在上述初始化代码中,先通过调用HAL硬件抽象层库 load camera HAL module,获取支持的摄像头个数并保存到mNumberOfCameras

2、应用程序链接相机服务过程
在camera应用程序启动的时候首先会和CameraService建立连接,camera应用程序代码就不分析了,上一篇文章已經說過，下面这副图是一个简单的流程图

从上面的流程图我们可以看出在请求服务的过程中多出用到了应用框架层的camera类,该类定义在 frameworks/base/core/java/android/hardware/Camera.java文件当中,这一个类正是Camera子系统中APP层和JNI层交换的接口,它对上为应用程序提供了各种操作Camera的方法,向下访问JNI实现它自身的接口Camera类定义如下：

  1. public class Camera {
  2.     public static Camera open(int cameraId) {
  3.         return new Camera(cameraId);
  4.     }
  5.     
  6.     .................
  7.         
  8.     Camera(int cameraId) {
  9.     Looper looper;
  10.     if ((looper = Looper.myLooper()) != null) {
  11.         mEventHandler = new EventHandler(this, looper);
  12.     } else if ((looper = Looper.getMainLooper()) != null) {
  13.         mEventHandler = new EventHandler(this, looper);
  14.     } else {
  15.         mEventHandler = null;
  16.     }
  17.     native_setup(new WeakReference<Camera>(this), cameraId);
  18.     }
  19. }
下面就开始从app的takepicture逐步分析camera takepicture整个过程
在app中，takepicture是在capture方法中被调用的： packages/apps/OMAPCamera/src/com/ti/omap4/android/camera/Camera.java （apk）
  1. @Override
  2.     public boolean capture() {
  3.         synchronized (mCameraStateLock) {
  4.             // If we are already in the middle of taking a snapshot then ignore.
  5.             if (mCameraState == SNAPSHOT_IN_PROGRESS || mCameraDevice == null) {
  6.                 return false;
  7.             }
  8.             mCaptureStartTime = System.currentTimeMillis();
  9.             mPostViewPictureCallbackTime = 0;
  10.             mJpegImageData = null;

  12.             // Set rotation and gps data.
  13.             Util.setRotationParameter(mParameters, mCameraId, mOrientation);
  14.             Location loc = mLocationManager.getCurrentLocation();
  15.             Util.setGpsParameters(mParameters, loc);
  16.             if (canSetParameters()) {
  17.                 mCameraDevice.setParameters(mParameters);
  18.             }

  20.             try {
  21.                 mCameraDevice.takePicture(mShutterCallback, mRawPictureCallback,
  22.                         mPostViewPictureCallback, new JpegPictureCallback(loc));
  23.             } catch (RuntimeException e ) {
  24.                 e.printStackTrace();
  25.                 return false;
  26.             }
  27.             mFaceDetectionStarted = false;
  28.             setCameraState(SNAPSHOT_IN_PROGRESS);
  29.             return true;
  30.         }
  31.     }
这里调用的 takePicture是在framework层中定义 ： frameworks/base/core/java/android/hardware/Camera.java

  1. public final void takePicture(ShutterCallback shutter, PictureCallback raw,
  2.             PictureCallback postview, PictureCallback jpeg) {
  3.         mShutterCallback = shutter;
  4.         mRawImageCallback = raw;
  5.         mPostviewCallback = postview;
  6.         mJpegCallback = jpeg;

  8.         // If callback is not set, do not send me callbacks.
  9.         int msgType = 0;
  10.         if (mShutterCallback != null) {
  11.             msgType |= CAMERA_MSG_SHUTTER;
  12.         }
  13.         if (mRawImageCallback != null) {
  14.             msgType |= CAMERA_MSG_RAW_IMAGE;
  15.         }
  16.         if (mPostviewCallback != null) {
  17.             msgType |= CAMERA_MSG_POSTVIEW_FRAME;
  18.         }
  19.         if (mJpegCallback != null) {
  20.             msgType |= CAMERA_MSG_COMPRESSED_IMAGE;
  21.         }

  23.         native_takePicture(msgType);
  24.     }
在这里设置callback函数，并 调用通过JNI调用takepicture方法： frameworks/base/core/jni/android_hardware_Camera.cpp
  1. static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz, int msgType)
  2. {
  3.     LOGV("takePicture");
  4.     JNICameraContext* context;
  5.     sp<Camera> camera = get_native_camera(env, thiz, &context);
  6.     if (camera == 0) return;

  8.     /*
  9.      * When CAMERA_MSG_RAW_IMAGE is requested, if the raw image callback
  10.      * buffer is available, CAMERA_MSG_RAW_IMAGE is enabled to get the
  11.      * notification _and_ the data; otherwise, CAMERA_MSG_RAW_IMAGE_NOTIFY
  12.      * is enabled to receive the callback notification but no data.
  13.      *
  14.      * Note that CAMERA_MSG_RAW_IMAGE_NOTIFY is not exposed to the
  15.      * Java application.
  16.      */
  17.     if (msgType & CAMERA_MSG_RAW_IMAGE) {
  18.         LOGV("Enable raw image callback buffer");
  19.         if (!context->isRawImageCallbackBufferAvailable()) {
  20.             LOGV("Enable raw image notification, since no callback buffer exists");
  21.             msgType &= ~CAMERA_MSG_RAW_IMAGE;
  22.             msgType |= CAMERA_MSG_RAW_IMAGE_NOTIFY;
  23.         }
  24.     }

  26.     if (camera->takePicture(msgType) != NO_ERROR) {
  27.         jniThrowRuntimeException(env, "takePicture failed");
  28.         return;
  29.     }
  30. }
这里调用camera 的takepicture，即 camera client 的takepicture方法： frameworks/base/libs/camera/Camera.cpp
  1. status_t Camera::takePicture(int msgType, const String8& params)
  2. {
  3.     LOGV("takePicture: 0x%x", msgType);
  4.     sp <ICamera> c = mCamera;
  5.     if (c == 0) return NO_INIT;
  6.     return c->takePicture(msgType, params);
  7. }
这里client 端的takepicture又调用到 camera  server端的takepicture： frameworks/base/services/camera/libcameraservice/CameraService.cpp

  1. // take a picture - image is returned in callback
  2. #ifdef OMAP_ENHANCEMENT_CPCAM
  3. status_t CameraService::Client::takePicture(int msgType, const String8& params) {
  4. #else
  5. status_t CameraService::Client::takePicture(int msgType) {
  6. #endif
  7.     LOG1("takePicture (pid %d): 0x%x", getCallingPid(), msgType);

  9.     Mutex::Autolock lock(mLock);
  10.     status_t result = checkPidAndHardware();
  11.     if (result != NO_ERROR) return result;

  13.     if ((msgType & CAMERA_MSG_RAW_IMAGE) &&
  14.         (msgType & CAMERA_MSG_RAW_IMAGE_NOTIFY)) {
  15.         LOGE("CAMERA_MSG_RAW_IMAGE and CAMERA_MSG_RAW_IMAGE_NOTIFY"
  16.                 " cannot be both enabled");
  17.         return BAD_VALUE;
  18.     }

  20.     // We only accept picture related message types
  21.     // and ignore other types of messages for takePicture().
  22.     int picMsgType = msgType
  23.                         & (CAMERA_MSG_SHUTTER |
  24.                            CAMERA_MSG_POSTVIEW_FRAME |
  25.                            CAMERA_MSG_RAW_IMAGE |
  26. #ifdef OMAP_ENHANCEMENT
  27.                            CAMERA_MSG_RAW_BURST |
  28. #endif
  29.                            CAMERA_MSG_RAW_IMAGE_NOTIFY |
  30.                            CAMERA_MSG_COMPRESSED_IMAGE);
  31. #ifdef OMAP_ENHANCEMENT
  32.     picMsgType |= CAMERA_MSG_COMPRESSED_BURST_IMAGE;
  33. #endif

  35.     enableMsgType(picMsgType);

  37. #ifdef OMAP_ENHANCEMENT
  38.     // make sure the other capture messages are disabled
  39.     picMsgType = ~picMsgType &
  40.                  (CAMERA_MSG_SHUTTER |
  41.                   CAMERA_MSG_POSTVIEW_FRAME |
  42.                   CAMERA_MSG_RAW_IMAGE |
  43.                   CAMERA_MSG_RAW_BURST |
  44.                   CAMERA_MSG_RAW_IMAGE_NOTIFY |
  45.                   CAMERA_MSG_COMPRESSED_IMAGE |
  46.                   CAMERA_MSG_COMPRESSED_BURST_IMAGE);
  47.     disableMsgType(picMsgType);
  48. #endif

  50. #ifdef OMAP_ENHANCEMENT_CPCAM
  51.     return mHardware->takePicture(params);
  52. #else
  53.     return mHardware->takePicture();
  54. #endif
  55. }
一些初始化之后，最终server端的takepicture方法会调用 HAL层（硬件接口层 ）的takepicture方法： frameworks/base/services/camera/libcameraservice/CameraHardwareInterface.h
  1. /**
  2.      * Take a picture.
  3.      */
  4. #ifdef OMAP_ENHANCEMENT_CPCAM
  5.     status_t takePicture(const ShotParameters &params)
  6.     {
  7.         LOGV("%s(%s)", __FUNCTION__, mName.string());
  8.         if (mDevice->ops->take_picture)
  9.             return mDevice->ops->take_picture(mDevice,
  10.                                               params.flatten().string());
  11.         return INVALID_OPERATION;
  12.     }
  13. #else
  14.     status_t takePicture()
  15.     {
  16.         LOGV("%s(%s)", __FUNCTION__, mName.string());
  17.         if (mDevice->ops->take_picture)
  18.             return mDevice->ops->take_picture(mDevice);//从这里开始通过V4L2子系统调用到kerner driver的设备，以后针对这个部分做详细学习
  19.         return INVALID_OPERATION;
  20.     }
  21. #endif
下面的重点是分析数据回调过程，这个过程是camera的最重点，在我看来也是最难点理解的地方，要多花点时间，努把力了，现在就开始
首先还是必须先追溯到Camera客户端与服务端连接的时候，由我的上一遍初始化的文章知道， Camera客户端与服务端连接的时候，首先调用的是client端的connect方法，
client的connect方法首先getservice，然后调用server端的connect方法，为了方便理解我再次把这部分代码贴出：
server的connect（）函数定义在以下路径:frameworks/base/services/camera/libcameraservice/CameraService.cpp
  1. sp<ICamera> CameraService::connect(
  2.         const sp<ICameraClient>& cameraClient, int cameraId) {
  3.     int callingPid = getCallingPid();
  4.     sp<CameraHardwareInterface> hardware = NULL;

  6.     LOG1("CameraService::connect E (pid %d, id %d)", callingPid, cameraId);

  8.     if (!mModule) {
  9.         LOGE("Camera HAL module not loaded");
  10.         return NULL;
  11.     }

  13.     sp<Client> client;
  14.     if (cameraId < 0 || cameraId >= mNumberOfCameras) {
  15.         LOGE("CameraService::connect X (pid %d) rejected (invalid cameraId %d).",
  16.             callingPid, cameraId);
  17.         return NULL;
  18.     }

  20.     char value[PROPERTY_VALUE_MAX];
  21.     property_get("sys.secpolicy.camera.disabled", value, "0");
  22.     if (strcmp(value, "1") == 0) {
  23.         // Camera is disabled by DevicePolicyManager.
  24.         LOGI("Camera is disabled. connect X (pid %d) rejected", callingPid);
  25.         return NULL;
  26.     }

  28.     Mutex::Autolock lock(mServiceLock);
  29.     if (mClient[cameraId] != 0) {
  30.         client = mClient[cameraId].promote();
  31.         if (client != 0) {
  32.             if (cameraClient->asBinder() == client->getCameraClient()->asBinder()) {
  33.                 LOG1("CameraService::connect X (pid %d) (the same client)",
  34.                     callingPid);
  35.                 return client;
  36.             } else {
  37.                 LOGW("CameraService::connect X (pid %d) rejected (existing client).",
  38.                     callingPid);
  39.                 return NULL;
  40.             }
  41.         }
  42.         mClient[cameraId].clear();
  43.     }

  45.     if (mBusy[cameraId]) {
  46.         LOGW("CameraService::connect X (pid %d) rejected"
  47.              " (camera %d is still busy).", callingPid, cameraId);
  48.         return NULL;
  49.     }

  51.     struct camera_info info;
  52.     if (mModule->get_camera_info(cameraId, &info) != OK) {
  53.         LOGE("Invalid camera id %d", cameraId);
  54.         return NULL;
  55.     }

  57.     char camera_device_name[10];
  58.     snprintf(camera_device_name, sizeof(camera_device_name), "%d", cameraId);

  60.     hardware = new CameraHardwareInterface(camera_device_name);
  61.     if (hardware->initialize(&mModule->common) != OK) {
  62.         hardware.clear();
  63.         return NULL;
  64.     }

  66.     client = new Client(this, cameraClient, hardware, cameraId, info.facing, callingPid);
  67.     mClient[cameraId] = client;
  68.     LOG1("CameraService::connect X");
  69.     return client;
  70. }
最重要的地方在上面标注的绿色部分，这里在connect成功之后会new一个client，这个Client是CamereService类的内部类，
这个时候便会调用client这个内部类的client构造函数，而我们的回调函数也正是在这个时候被设置，看看代码：

  1. CameraService::Client::Client(const sp<CameraService>& cameraService,
  2.         const sp<ICameraClient>& cameraClient,
  3.         const sp<CameraHardwareInterface>& hardware,
  4.         int cameraId, int cameraFacing, int clientPid) {
  5.     int callingPid = getCallingPid();
  6.     LOG1("Client::Client E (pid %d)", callingPid);

  8.     mCameraService = cameraService;
  9.     mCameraClient = cameraClient;
  10.     mHardware = hardware;
  11.     mCameraId = cameraId;
  12.     mCameraFacing = cameraFacing;
  13.     mClientPid = clientPid;
  14.     mMsgEnabled = 0;
  15.     mSurface = 0;
  16.     mPreviewWindow = 0;
  17. #ifdef OMAP_ENHANCEMENT_CPCAM
  18.     mTapin = 0;
  19.     mTapinClient = 0;
  20.     mTapout = 0;
  21.     mTapoutClient = 0;
  22. #endif
  23.     mHardware->setCallbacks(notifyCallback,
  24.                             dataCallback,
  25.                             dataCallbackTimestamp,
  26.                             (void *)cameraId);

  28.     // Enable zoom, error, focus, and metadata messages by default
  29.     enableMsgType(CAMERA_MSG_ERROR | CAMERA_MSG_ZOOM | CAMERA_MSG_FOCUS |
  30.                   CAMERA_MSG_PREVIEW_METADATA);

  32.     // Callback is disabled by default
  33.     mPreviewCallbackFlag = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
  34.     mOrientation = getOrientation(0, mCameraFacing == CAMERA_FACING_FRONT);
  35.     mPlayShutterSound = true;
  36.     cameraService->setCameraBusy(cameraId);
  37.     cameraService->loadSound();
  38.     LOG1("Client::Client X (pid %d)", callingPid);
  39. }
上面就对camera设置了 notifyCallback、dataCallback、dataCallbackTimestamp三个回调函数，用于返回底层数据用于处理，看下它的处理方法：
这里先针对其中的dataCallback回调方法做介绍，其他的回调方法以此类推，所以我们就先看一下dataCallback方法中都做了些什么事情：
这里的回调函数是camera server层的回调函数：frameworks/base/services/camera/libcameraservice/CameraService.cpp
  1. void CameraService::Client::dataCallback(int32_t msgType,
  2.         const sp<IMemory>& dataPtr, camera_frame_metadata_t *metadata, void* user) {
  3.     LOG2("dataCallback(%d)", msgType);

  5.     sp<Client> client = getClientFromCookie(user);
  6.     if (client == 0) return;
  7.     if (!client->lockIfMessageWanted(msgType)) return;

  9.     if (dataPtr == 0 && metadata == NULL) {
  10.         LOGE("Null data returned in data callback");
  11.         client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
  12.         return;
  13.     }

  15.     switch (msgType & ~CAMERA_MSG_PREVIEW_METADATA) {
  16.         case CAMERA_MSG_PREVIEW_FRAME:
  17.             client->handlePreviewData(msgType, dataPtr, metadata);
  18.             break;
  19.         case CAMERA_MSG_POSTVIEW_FRAME:
  20.             client->handlePostview(dataPtr);
  21.             break;
  22.         case CAMERA_MSG_RAW_IMAGE:
  23.             client->handleRawPicture(dataPtr);
  24.             break;
  25.         case CAMERA_MSG_COMPRESSED_IMAGE:
  26.             client->handleCompressedPicture(dataPtr);
  27.             break;
  28. #ifdef OMAP_ENHANCEMENT
  29.         case CAMERA_MSG_COMPRESSED_BURST_IMAGE:
  30.             client->handleCompressedBurstPicture(dataPtr);
  31.             break;
  32. #endif
  33.         default:
  34.             client->handleGenericData(msgType, dataPtr, metadata);
  35.             break;
  36.     }
  37. }
这里进行分类处理，因为preview过程需要大量数据传输，而且容易大家理解，这里就针对 preview数据回调过程进行分析：
  1. // preview callback - frame buffer update
  2. void CameraService::Client::handlePreviewData(int32_t msgType,
  3.                                               const sp<IMemory>& mem,
  4.                                               camera_frame_metadata_t *metadata) {
  5.     ssize_t offset;
  6.     size_t size;
  7.     sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);

  9.     // local copy of the callback flags
  10.     int flags = mPreviewCallbackFlag;

  12.     // is callback enabled?
  13.     if (!(flags & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK)) {
  14.         // If the enable bit is off, the copy-out and one-shot bits are ignored
  15.         LOG2("frame callback is disabled");
  16.         mLock.unlock();
  17.         return;
  18.     }

  20.     // hold a strong pointer to the client
  21.     sp<ICameraClient> c = mCameraClient;

  23.     // clear callback flags if no client or one-shot mode
  24.     if (c == 0 || (mPreviewCallbackFlag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK)) {
  25.         LOG2("Disable preview callback");
  26.         mPreviewCallbackFlag &= ~(CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK |
  27.                                   CAMERA_FRAME_CALLBACK_FLAG_COPY_OUT_MASK |
  28.                                   CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
  29.         disableMsgType(CAMERA_MSG_PREVIEW_FRAME);
  30.     }

  32.     if (c != 0) {
  33.         // Is the received frame copied out or not?
  34.         if (flags & CAMERA_FRAME_CALLBACK_FLAG_COPY_OUT_MASK) {
  35.             LOG2("frame is copied");
  36.             copyFrameAndPostCopiedFrame(msgType, c, heap, offset, size, metadata);
  37.         } else {
  38.             LOG2("frame is forwarded");
  39.             mLock.unlock();
  40.             c->dataCallback(msgType, mem, metadata);
  41.         }
  42.     } else {
  43.         mLock.unlock();
  44.     }
  45. }
这里有两个方向
copyFrameAndPostCopiedFrame这个函数执行两个buff区preview数据的投递，通过它的具体实现过程，可以知道最终他也要调用dataCallback方法继续调用客户端client的回调函数
所以这里直接分析 copyFrameAndPostCopiedFrame：
  1. void CameraService::Client::copyFrameAndPostCopiedFrame(
  2.         int32_t msgType, const sp<ICameraClient>& client,
  3.         const sp<IMemoryHeap>& heap, size_t offset, size_t size,
  4.         camera_frame_metadata_t *metadata) {
  5.     LOG2("copyFrameAndPostCopiedFrame");
  6.     // It is necessary to copy out of pmem before sending this to
  7.     // the callback. For efficiency, reuse the same MemoryHeapBase
  8.     // provided it's big enough. Don't allocate the memory or
  9.     // perform the copy if there's no callback.
  10.     // hold the preview lock while we grab a reference to the preview buffer
  11.     sp<MemoryHeapBase> previewBuffer;

  13.     if (mPreviewBuffer == 0) {
  14.         mPreviewBuffer = new MemoryHeapBase(size, 0, NULL);
  15.     } else if (size > mPreviewBuffer->virtualSize()) {
  16.         mPreviewBuffer.clear();
  17.         mPreviewBuffer = new MemoryHeapBase(size, 0, NULL);
  18.     }
  19.     if (mPreviewBuffer == 0) {
  20.         LOGE("failed to allocate space for preview buffer");
  21.         mLock.unlock();
  22.         return;
  23.     }
  24.     previewBuffer = mPreviewBuffer;

  26.     memcpy(previewBuffer->base(), (uint8_t *)heap->base() + offset, size);

  28.     sp<MemoryBase> frame = new MemoryBase(previewBuffer, 0, size);
  29.     if (frame == 0) {
  30.         LOGE("failed to allocate space for frame callback");
  31.         mLock.unlock();
  32.         return;
  33.     }

  35.     mLock.unlock();
  36.     client->dataCallback(msgType, frame, metadata);
  37. }
从这里开始，回调函数进入到camera client的回调函数： frameworks/base/libs/camera/Camera.cpp
  1. // callback from camera service when frame or image is ready
  2. void Camera::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr,
  3.                           camera_frame_metadata_t *metadata)
  4. {
  5.     sp<CameraListener> listener;
  6.     {
  7.         Mutex::Autolock _l(mLock);
  8.         listener = mListener;
  9.     }
  10.     if (listener != NULL) {
  11.         listener->postData(msgType, dataPtr, metadata);
  12.     }
  13. }
这里的listener到底是什么，还记得初始化的时候，在jni里面有设置listenerm吗？我们还是从新再看一下吧： frameworks/base/core/jni/android_hardware_Camera.cpp
  1. // connect to camera service
  2. static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz,
  3.     jobject weak_this, jint cameraId)
  4. {
  5.     sp<Camera> camera = Camera::connect(cameraId);

  7.     if (camera == NULL) {
  8.         jniThrowRuntimeException(env, "Fail to connect to camera service");
  9.         return;
  10.     }

  12.     // make sure camera hardware is alive
  13.     if (camera->getStatus() != NO_ERROR) {
  14.         jniThrowRuntimeException(env, "Camera initialization failed");
  15.         return;
  16.     }

  18.     jclass clazz = env->GetObjectClass(thiz);
  19.     if (clazz == NULL) {
  20.         jniThrowRuntimeException(env, "Can't find android/hardware/Camera");
  21.         return;
  22.     }

  24.     // We use a weak reference so the Camera object can be garbage collected.
  25.     // The reference is only used as a proxy for callbacks.
  26.     sp<JNICameraContext> context = new JNICameraContext(env, weak_this, clazz, camera);
  27.     context->incStrong(thiz);
  28.     camera->setListener(context);

  30.     // save context in opaque field
  31.     env->SetIntField(thiz, fields.context, (int)context.get());
  32. }
由上面可以看出 JNICameraContext是个监听类，同时set这个监听类，这个类的定义在： frameworks/base/core/jni/android_hardware_Camera.cpp
  1. // provides persistent context for calls from native code to Java
  2. class JNICameraContext: public CameraListener
  3. {
  4. public:
  5.     JNICameraContext(JNIEnv* env, jobject weak_this, jclass clazz, const sp<Camera>& camera);
  6.     ~JNICameraContext() { release(); }
  7.     virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);
  8.     virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr,
  9.                           camera_frame_metadata_t *metadata);
  10.     virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);
  11.     void postMetadata(JNIEnv *env, int32_t msgType, camera_frame_metadata_t *metadata);
  12.     void addCallbackBuffer(JNIEnv *env, jbyteArray cbb, int msgType);
  13.     void setCallbackMode(JNIEnv *env, bool installed, bool manualMode);
  14.     sp<Camera> getCamera() { Mutex::Autolock _l(mLock); return mCamera; }
  15.     bool isRawImageCallbackBufferAvailable() const;
  16.     void release();

  18. private:
  19.     void copyAndPost(JNIEnv* env, const sp<IMemory>& dataPtr, int msgType);
  20.     void clearCallbackBuffers_l(JNIEnv *env, Vector<jbyteArray> *buffers);
  21.     void clearCallbackBuffers_l(JNIEnv *env);
  22.     jbyteArray getCallbackBuffer(JNIEnv *env, Vector<jbyteArray> *buffers, size_t bufferSize);

  24.     jobject mCameraJObjectWeak; // weak reference to java object
  25.     jclass mCameraJClass; // strong reference to java class
  26.     sp<Camera> mCamera; // strong reference to native object
  27.     jclass mFaceClass; // strong reference to Face class
  28.     jclass mRectClass; // strong reference to Rect class
  29.     Mutex mLock;

  31.     /*
  32.      * Global reference application-managed raw image buffer queue.
  33.      *
  34.      * Manual-only mode is supported for raw image callbacks, which is
  35.      * set whenever method addCallbackBuffer() with msgType =
  36.      * CAMERA_MSG_RAW_IMAGE is called; otherwise, null is returned
  37.      * with raw image callbacks.
  38.      */
  39.     Vector<jbyteArray> mRawImageCallbackBuffers;

  41.     /*
  42.      * Application-managed preview buffer queue and the flags
  43.      * associated with the usage of the preview buffer callback.
  44.      */
  45.     Vector<jbyteArray> mCallbackBuffers; // Global reference application managed byte[]
  46.     bool mManualBufferMode; // Whether to use application managed buffers.
  47.     bool mManualCameraCallbackSet; // Whether the callback has been set, used to
  48.                                          // reduce unnecessary calls to set the callback.
  49. };
标注部分是我们在上面用到的postData，我们看一看 postData的实现过程：
  1. void JNICameraContext::postData(int32_t msgType, const sp<IMemory>& dataPtr,
  2.                                 camera_frame_metadata_t *metadata)
  3. {
  4.     // VM pointer will be NULL if object is released
  5.     Mutex::Autolock _l(mLock);
  6.     JNIEnv *env = AndroidRuntime::getJNIEnv();
  7.     if (mCameraJObjectWeak == NULL) {
  8.         LOGW("callback on dead camera object");
  9.         return;
  10.     }

  12.     int32_t dataMsgType = msgType & ~CAMERA_MSG_PREVIEW_METADATA;

  14.     // return data based on callback type
  15.     switch (dataMsgType) {
  16.         case CAMERA_MSG_VIDEO_FRAME:
  17.             // should never happen
  18.             break;

  20.         // For backward-compatibility purpose, if there is no callback
  21.         // buffer for raw image, the callback returns null.
  22.         case CAMERA_MSG_RAW_IMAGE:
  23.             LOGV("rawCallback");
  24.             if (mRawImageCallbackBuffers.isEmpty()) {
  25.                 env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
  26.                         mCameraJObjectWeak, dataMsgType, 0, 0, NULL);
  27.             } else {
  28.                 copyAndPost(env, dataPtr, dataMsgType);
  29.             }
  30.             break;

  32.         // There is no data.
  33.         case 0:
  34.             break;

  36.         default:
  37.             LOGV("dataCallback(%d, %p)", dataMsgType, dataPtr.get());
  38.             copyAndPost(env, dataPtr, dataMsgType);
  39.             break;
  40.     }

  42.     // post frame metadata to Java
  43.     if (metadata && (msgType & CAMERA_MSG_PREVIEW_METADATA)) {
  44.         postMetadata(env, CAMERA_MSG_PREVIEW_METADATA, metadata);
  45.     }
  46. }
我们接着看看这个 copyAndPost方法：
  1. void JNICameraContext::copyAndPost(JNIEnv* env, const sp<IMemory>& dataPtr, int msgType)
  2. {
  3.     jbyteArray obj = NULL;

  5.     // allocate Java byte array and copy data
  6.     if (dataPtr != NULL) {
  7.         ssize_t offset;
  8.         size_t size;
  9.         sp<IMemoryHeap> heap = dataPtr->getMemory(&offset, &size);
  10.         LOGV("copyAndPost: off=%ld, size=%d", offset, size);
  11.         uint8_t *heapBase = (uint8_t*)heap->base();

  13.         if (heapBase != NULL) {
  14.             const jbyte* data = reinterpret_cast<const jbyte*>(heapBase + offset);

  16.             if (msgType == CAMERA_MSG_RAW_IMAGE) {
  17.                 obj = getCallbackBuffer(env, &mRawImageCallbackBuffers, size);
  18.             } else if (msgType == CAMERA_MSG_PREVIEW_FRAME && mManualBufferMode) {
  19.                 obj = getCallbackBuffer(env, &mCallbackBuffers, size);

  21.                 if (mCallbackBuffers.isEmpty()) {
  22.                     LOGV("Out of buffers, clearing callback!");
  23.                     mCamera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_NOOP);
  24.                     mManualCameraCallbackSet = false;

  26.                     if (obj == NULL) {
  27.                         return;
  28.                     }
  29.                 }
  30.             } else {
  31.                 LOGV("Allocating callback buffer");
  32.                 obj = env->NewByteArray(size);
  33.             }

  35.             if (obj == NULL) {
  36.                 LOGE("Couldn't allocate byte array for JPEG data");
  37.                 env->ExceptionClear();
  38.             } else {
  39.                 env->SetByteArrayRegion(obj, 0, size, data);
  40.             }
  41.         } else {
  42.             LOGE("image heap is NULL");
  43.         }
  44.     }

  46.     // post image data to Java
  47.     env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
  48.             mCameraJObjectWeak, msgType, 0, 0, obj);
  49.     if (obj) {
  50.         env->DeleteLocalRef(obj);
  51.     }
  52. }
以上先建立一个byte数组obj，将data缓存数据存储进obj数组，CallStaticVoidMethod是C调用java函数，最后执行实在Camera.java(框架）的postEventFromNative（）
从这里开始，回调函数进入到camera framework层
frameworks/base/core/java/android/hardware/Camera.java
  1. private static void postEventFromNative(Object camera_ref,
  2.                                             int what, int arg1, int arg2, Object obj)
  3.     {
  4.         Camera c = (Camera)((WeakReference)camera_ref).get();
  5.         if (c == null)
  6.             return;

  8.         if (c.mEventHandler != null) {
  9.             Message m = c.mEventHandler.obtainMessage(what, arg1, arg2, obj);
  10.             c.mEventHandler.sendMessage(m);
  11.         }
  12.     }
sendMessage之后由handle进行处理，定义同样在framework层
  1. private class EventHandler extends Handler
  2.     {
  3.         private Camera mCamera;

  5.         public EventHandler(Camera c, Looper looper) {
  6.             super(looper);
  7.             mCamera = c;
  8.         }

  10.         @Override
  11.         public void handleMessage(Message msg) {
  12.             switch(msg.what) {
  13.             case CAMERA_MSG_SHUTTER:
  14.                 if (mShutterCallback != null) {
  15.                     mShutterCallback.onShutter();
  16.                 }
  17.                 return;

  19.             case CAMERA_MSG_RAW_IMAGE:
  20.                 if (mRawImageCallback != null) {
  21.                     mRawImageCallback.onPictureTaken((byte[])msg.obj, mCamera);
  22.                 }
  23.                 return;

  25.             case CAMERA_MSG_COMPRESSED_IMAGE:
  26.                 if (mJpegCallback != null) {
  27.                     mJpegCallback.onPictureTaken((byte[])msg.obj, mCamera);
  28.                 }
  29.                 return;

  31.             case CAMERA_MSG_PREVIEW_FRAME:
  32.                 if (mPreviewCallback != null) {
  33.                     PreviewCallback cb = mPreviewCallback;
  34.                     if (mOneShot) {
  35.                         // Clear the callback variable before the callback
  36.                         // in case the app calls setPreviewCallback from
  37.                         // the callback function
  38.                         mPreviewCallback = null;
  39.                     } else if (!mWithBuffer) {
  40.                         // We're faking the camera preview mode to prevent
  41.                         // the app from being flooded with preview frames.
  42.                         // Set to oneshot mode again.
  43.                         setHasPreviewCallback(true, false);
  44.                     }
  45.                     cb.onPreviewFrame((byte[])msg.obj, mCamera);
  46.                 }
  47.                 return;

  49.             case CAMERA_MSG_POSTVIEW_FRAME:
  50.                 if (mPostviewCallback != null) {
  51.                     mPostviewCallback.onPictureTaken((byte[])msg.obj, mCamera);
  52.                 }
  53.                 return;

  55.             case CAMERA_MSG_FOCUS:
  56.                 if (mAutoFocusCallback != null) {
  57.                     mAutoFocusCallback.onAutoFocus(msg.arg1 == 0 ? false : true, mCamera);
  58.                 }
  59.                 return;

  61.             case CAMERA_MSG_ZOOM:
  62.                 if (mZoomListener != null) {
  63.                     mZoomListener.onZoomChange(msg.arg1, msg.arg2 != 0, mCamera);
  64.                 }
  65.                 return;

  67.             case CAMERA_MSG_PREVIEW_METADATA:
  68.                 if (mFaceListener != null) {
  69.                     mFaceListener.onFaceDetection((Face[])msg.obj, mCamera);
  70.                 }
  71.                 return;

  73.             case CAMERA_MSG_ERROR :
  74.                 Log.e(TAG, "Error " + msg.arg1);
  75.                 if (mErrorCallback != null) {
  76.                     mErrorCallback.onError(msg.arg1, mCamera);
  77.                 }
  78.                 return;

  80.             default:
  81.                 Log.e(TAG, "Unknown message type " + msg.what);
  82.                 return;
  83.             }
  84.         }
  85.     }
上面可以看出，这里处理了所有的回调，快门回调mShutterCallback.onShutter()，RawImageCallback.onPictureTaken（）拍照数据回调，自动对焦回调等。。
默认是没有previewcallback这个回调的，除非你的app设置了setPreviewCallback，可以看出preview的数据还是可以向上层回调，只是系统默认不回调，这里再说深一些：
由上面绿色标注的地方可以看出，我们需要做以下事情，检查 PreviewCallback 这个在framework中定义的接口有没有 设置了setPreviewCallback，设置则调用，这里接口中
的 onPreviewFrame方法需要开发者自己实现，这里默认是没有实现的，需要特殊使用的要自己添加，这里是自己的理解，看一下 PreviewCallback 接口的定义： frameworks/base/core/java/android/hardware/Camera.java

  1. /**
  2.      * Callback interface used to deliver copies of preview frames as
  3.      * they are displayed.
  4.      *
  5.      * @see #setPreviewCallback(Camera.PreviewCallback)
  6.      * @see #setOneShotPreviewCallback(Camera.PreviewCallback)
  7.      * @see #setPreviewCallbackWithBuffer(Camera.PreviewCallback)
  8.      * @see #startPreview()
  9.      */
  10.     public interface PreviewCallback
  11.     {
  12.         /**
  13.          * Called as preview frames are displayed. This callback is invoked
  14.          * on the event thread {@link #open(int)} was called from.
  15.          *
  16.          * @param data the contents of the preview frame in the format defined
  17.          * by {@link android.graphics.ImageFormat}, which can be queried
  18.          * with {@link android.hardware.Camera.Parameters#getPreviewFormat()}.
  19.          * If {@link android.hardware.Camera.Parameters#setPreviewFormat(int)}
  20.          * is never called, the default will be the YCbCr_420_SP
  21.          * (NV21) format.
  22.          * @param camera the Camera service object.
  23.          */
  24.         void onPreviewFrame(byte[] data, Camera camera);
  25.     };
另数据采集区与显示区两个缓存区buffer preview数据的投递，以完成preview实时显示是在HAL层完成的 。
takePicture（）处理过程跟preview差不多，只是增加了回调函数返回时候存储图像的动作，这里分析一下takepicture的处理过程：
  1. case CAMERA_MSG_COMPRESSED_IMAGE:
  2.                 if (mJpegCallback != null) {
  3.                     mJpegCallback.onPictureTaken((byte[])msg.obj, mCamera);
  4.                 }
  5.                 return;
mJpegCallback的定义
private PictureCallback mJpegCallback;
走到这里我们又不得不回头看看最起初在调用takepicture的时候是怎么调用的
  1.             try {
  2.                 mCameraDevice.takePicture(mShutterCallback, mRawPictureCallback,
  3.                         mPostViewPictureCallback, new JpegPictureCallback(loc));
  4.             } catch (RuntimeException e ) {
  5.                 e.printStackTrace();
  6.                 return false;
  7.             }
这里大家看到了标准部分就是要使用的 mJpegCallback，但是这个callback是JpegPictureCallback 类，我们定义的 mJpegCallback确是 PictureCallback 类，不是同一个类
所以这个还是必须得说清楚一点，看看JpegPictureCallback 类的定义吧
  1. private final class JpegPictureCallback implements PictureCallback {
  2.         Location mLocation;

  4.         public JpegPictureCallback(Location loc) {
  5.             mLocation = loc;
  6.         }

  8.         public void onPictureTaken(
  9.                 final byte [] jpegData, final android.hardware.Camera camera) {
  10.             if (mPausing) {
  11.                 if (mBurstImages > 0) {
  12.                     resetBurst();
  13.                     mBurstImages = 0;
  14.                     mHandler.sendEmptyMessageDelayed(RELEASE_CAMERA,
  15.                                                      CAMERA_RELEASE_DELAY);
  16.                 }
  17.                 return;
  18.             }

  20.             FocusManager.TempBracketingStates tempState = mFocusManager.getTempBracketingState();
  21.             mJpegPictureCallbackTime = System.currentTimeMillis();
  22.             // If postview callback has arrived, the captured image is displayed
  23.             // in postview callback. If not, the captured image is displayed in
  24.             // raw picture callback.
  25.             if (mPostViewPictureCallbackTime != 0) {
  26.                 mShutterToPictureDisplayedTime =
  27.                         mPostViewPictureCallbackTime - mShutterCallbackTime;
  28.                 mPictureDisplayedToJpegCallbackTime =
  29.                         mJpegPictureCallbackTime - mPostViewPictureCallbackTime;
  30.             } else {
  31.                 mShutterToPictureDisplayedTime =
  32.                         mRawPictureCallbackTime - mShutterCallbackTime;
  33.                 mPictureDisplayedToJpegCallbackTime =
  34.                         mJpegPictureCallbackTime - mRawPictureCallbackTime;
  35.             }
  36.             Log.v(TAG, "mPictureDisplayedToJpegCallbackTime = "
  37.                     + mPictureDisplayedToJpegCallbackTime + "ms");

  39.             if (!mIsImageCaptureIntent) {
  40.                 enableCameraControls(true);

  42.                 if (( tempState != FocusManager.TempBracketingStates.RUNNING ) &&
  43.                       !mCaptureMode.equals(mExposureBracketing) &&
  44.                       !mCaptureMode.equals(mZoomBracketing) &&
  45.                       !mBurstRunning == true) {
  46.                 // We want to show the taken picture for a while, so we wait
  47.                 // for at least 0.5 second before restarting the preview.
  48.                     long delay = 500 - mPictureDisplayedToJpegCallbackTime;
  49.                     if (delay < 0) {
  50.                         startPreview(true);
  51.                         startFaceDetection();
  52.                     } else {
  53.                         mHandler.sendEmptyMessageDelayed(RESTART_PREVIEW, delay);
  54.                     }
  55.                 }

  57.             }

  59.             if (!mIsImageCaptureIntent) {
  60.                 Size s = mParameters.getPictureSize();
  61.                 mImageSaver.addImage(jpegData, mLocation, s.width, s.height);
  62.             } else {
  63.                 mJpegImageData = jpegData;
  64.                 if (!mQuickCapture) {
  65.                     showPostCaptureAlert();
  66.                 } else {
  67.                     doAttach();
  68.                 }
  69.             }

  71.             // Check this in advance of each shot so we don't add to shutter
  72.             // latency. It's true that someone else could write to the SD card in
  73.             // the mean time and fill it, but that could have happened between the
  74.             // shutter press and saving the JPEG too.
  75.             checkStorage();

  77.             if (!mHandler.hasMessages(RESTART_PREVIEW)) {
  78.                 long now = System.currentTimeMillis();
  79.                 mJpegCallbackFinishTime = now - mJpegPictureCallbackTime;
  80.                 Log.v(TAG, "mJpegCallbackFinishTime = "
  81.                         + mJpegCallbackFinishTime + "ms");
  82.                 mJpegPictureCallbackTime = 0;
  83.             }

  85.             if (mCaptureMode.equals(mExposureBracketing) ) {
  86.                 mBurstImages --;
  87.                 if (mBurstImages == 0 ) {
  88.                     mHandler.sendEmptyMessageDelayed(RESTART_PREVIEW, 0);
  89.                 }
  90.             }

  92.           //reset burst in case of exposure bracketing
  93.             if (mCaptureMode.equals(mExposureBracketing) && mBurstImages == 0) {
  94.                 mBurstImages = EXPOSURE_BRACKETING_COUNT;
  95.                 mParameters.set(PARM_BURST, mBurstImages);
  96.                 mCameraDevice.setParameters(mParameters);
  97.             }

  99.             if (mCaptureMode.equals(mZoomBracketing) ) {
  100.                 mBurstImages --;
  101.                 if (mBurstImages == 0 ) {
  102.                     mHandler.sendEmptyMessageDelayed(RESTART_PREVIEW, 0);
  103.                 }
  104.             }

  106.           //reset burst in case of zoom bracketing
  107.             if (mCaptureMode.equals(mZoomBracketing) && mBurstImages == 0) {
  108.                 mBurstImages = ZOOM_BRACKETING_COUNT;
  109.                 mParameters.set(PARM_BURST, mBurstImages);
  110.                 mCameraDevice.setParameters(mParameters);
  111.             }

  113.             if ( tempState == FocusManager.TempBracketingStates.RUNNING ) {
  114.                 mBurstImages --;
  115.                 if (mBurstImages == 0 ) {
  116.                     mHandler.sendEmptyMessageDelayed(RESTART_PREVIEW, 0);
  117.                     mTempBracketingEnabled = true;
  118.                     stopTemporalBracketing();
  119.                 }
  120.             }

  122.             if (mBurstRunning) {
  123.                 mBurstImages --;
  124.                 if (mBurstImages == 0) {
  125.                     resetBurst();
  126.                     mBurstRunning = false;
  127.                     mHandler.sendEmptyMessageDelayed(RESTART_PREVIEW, 0);
  128.                 }
  129.             }
  130.         }
  131.     }
原来他们是父子类之间的关系，那么自然父类可以可以转换为子类的形式，但是子类就不能向父类转换了，这个不懂就没办法了，面向对象的知识
而且这里子类重新实现了父类的方法 onPictureTaken
这里 这个函数不就是handle里面调用的函数了嘛，可以看到上面onPictureTaken的实现过程，其实与preview最大的不同就是我上面标注的部分，
takepicture最终将图片保存下来了
好了，takepicture的过程就说到这里了，下一步要进底层了，HAL和driver之间的那些事，driver做的那些事
Android系统攻城狮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android camera（3）
07-21
android camera（3）自动对焦功能
Android Camera 流程学习记录（五，完结）—— Camera.takePicture() 流程解析
测试0901-1
12-01 809
简介 在前面的几篇笔记中，我已经把 Camera 控制流的部分梳理得比较清楚了。在 Camera 流程中，还有一个重要的部分，即数据流。 Camera API 1 中，数据流主要是通过函数回调的方式，依照从下往上的方向，逐层 return 到 Applications 中。 由于数据流的部分相...
camera.takePicture拍照案例
热门推荐
emerald0106的专栏
03-29 1万+
给大家来一个使用camera.takePicture拍照的案例，这个是使用android.hardware.Camera硬件方式的。 主要源码： package com.android.cameraAndroid; import android.app.Activity; import android.os.Bundle; import java.io.File;
Android 笔记 camera.takePicture()，使用flashMode，改变focusMode，continuous-picture中遇到的问题
super_zq的博客
09-23 1万+
takePicture()的问题在摄像头旧API的使用中，如果要保存全尺寸图像，只能通过takePicture（） 分别是shutterCallback,pictureCallback,pictureCallback 第一个是快门键按下以后，第二个是RAW图像（如果支持的话）生成以后，第三个是jpeg图像生成以后 一般情况，在第三个Callback里面操作保存jpeg的动作，然后操作其他动作，
Camera.takePicture() 流程解析
转载和创作优秀的博客
12-03 930
设置回调函数，主要把数据信息回传过来 /** Set the notification and data callbacks */ void setCallbacks(notify_callback notify_cb, data_callback data_cb, data_callback_timestamp data_cb_timestamp, void* ...
Android 自定义拍照实例（解决竖拍照片横向问题）
11-15
原文：http://blog.csdn.net/u012964281/article/details/41143169
takepicture
03-23
拍照命名软件APP,可以实现android手机的拍照和命名，直接导入eclicpse即可
android拍照保存至SD卡并生成预览（非调用系统拍照功能）
07-23
这是一个自制简易相机的范例，本程序以Activity为基底，在Layout配置1个”拍照”按钮和一个预览取景框。当单击“拍照”按钮，程序将画面截取下来，存储在SD存储卡临时盘中，最后将拍下来的图片文件显示在Activity里...
拍照takepicture
07-05
takepicture
android 的摄像头 和soundPool播放声音实例
08-13
android 的摄像头 和soundPool播放声音实例
高通camera预览拍照流程1
12-11
当指定了Camera的预览类，并开始预览之后，就可以通过takePicture()方法进行拍照 了。它将以异步的方式从Camera中获取图像，具有多个回调类作为参数，并且都可以为 null，下面分别介绍这些参数的意义： • shutter：...
android拍照代码
12-11
android拍照代码实现类
TakePicture.rar
03-24
android app源码，通过悬浮框达到隐藏拍摄效果，界面很简单就两个button，一个开启拍照点击后开启线程并打开悬浮框进行拍照并保存在根目录下，悬浮框1dip基本看不到了。另一个button停止拍照。
Android + <调用相机拍照 & 选择相册> + 数码相机
最新发布
04-27
【TakePicture】项目分为两大部分，分别从不同开发场景出发。 随着市场上不同版本、机型手机的出现，老项目迭代维护成本高。 本Demo最初目的： 实现如下功能之外，为了适配不同版本机型手机； 实测：android 8、9、...
android camera take,android – 如何使用Camera.takePicture()拍摄高分辨率图像？
weixin_35179649的博客
05-27 993
我正在实施一个应用内相机,每次拍摄照片时,我的图像都是320×240,尽管手机的相机能够提供更高的分辨率(Galaxy Nexus).我找不到用于设置分辨率的参数,那么如何解决我所拍摄的图像？以下是相关代码：@Overridepublic void surfaceCreated( SurfaceHolder holder ) {setSurfaceHolder( holder );}@Overri...
android takepicture 参数,【求助】关于camera.takepicture(,,);
weixin_36316642的博客
05-27 407
该楼层疑似违规已被系统折叠隐藏此楼查看此楼public class MainActivity extends Activity implements SurfaceHolder.Callback{SurfaceView sView=null;SurfaceHolder surfaceHolder=null;Camera camera=null;@SuppressWarnings("depreca...
调用Camera.takePicture(null, null, pictureCallback);拍照并保存于sd卡
cm的专栏
12-11 6506
package com.ygy; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.util.Calendar; import java.util.Locale;
android camera api接口
03-31
4. Camera.takePicture()：拍照。 5. Camera.release()：释放摄像头。 6. Camera.Parameters：获取和设置摄像头的参数，例如图像大小、闪光灯模式等。 7. Camera.CameraInfo：获取摄像头的信息，例如摄像头的方向...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值