男士保健品器具:[原创]Android Camera Framework Stream(二)

接下来，我们通过对流程的步步分析来将camera整体串接起来:

1．    首先则看看camera.java的 onCreate函数入口，针对android的所有应用，onCreate函数入口作为跟踪和了解应用架构的首选。

             @Override

    public void onCreate(Bundle icicle) {

        super.onCreate(icicle);

        devlatch = new CountDownLatch(1);

         CountDownLatch()关于这个类，可以简单的理解为它是用来线程之间的等待处理，当然这里采用的计数为1，则可以简单理解为一个计数开关来控制调用了tlatch.await()函数的进程，方式就是将devlatch的计数减为0(countDown() )。

         这里启动了一个线程用来打开camera服务，而打开过程则比较费时(一般在2s左右)，故单独启用一个线程避免应用线程阻塞。

Thread startPreviewThread = new Thread(new Runnable() {

            CountDownLatch tlatch = devlatch;

            public void run() {

                try {

                    mStartPreviewFail = false;

                    ensureCameraDevice();

                    // Wait for framework initialization to be complete before

                    // starting preview

                    try {

                        tlatch.await();

                    } catch (InterruptedException ie) {

                        mStartPreviewFail = true;

                    }

                    startPreview();

                } catch (CameraHardwareException e) {

                    // In eng build, we throw the exception so that test tool

                    // can detect it and report it

                    if ("eng".equals(Build.TYPE)) {

                        throw new RuntimeException(e);

                    }

                    mStartPreviewFail = true;

                }

            }

        });

        startPreviewThread.start();

         在这里，需要跟进ensureCameraDevice();该函数，可以看到其实现为：

    private void ensureCameraDevice() throws CameraHardwareException {

        if (mCameraDevice == null) {

            mCameraDevice = CameraHolder.instance().open();

            mInitialParams = mCameraDevice.getParameters();

        }

    }

         当前mCameraDevice()实例为null,则会调用CameraHolder.instance().open()函数来创建mCameraDevice对象实例。

private android.hardware.Camera mCameraDevice;

         跟进CameraHolder.instance().open()，进入到了CameraHolder类中：

public synchronized android.hardware.Camera open()

            throws CameraHardwareException {

        Assert(mUsers == 0);

        if (mCameraDevice == null) {

            try {

                mCameraDevice = android.hardware.Camera.open();

            } catch (RuntimeException e) {

                Log.e(TAG, "fail to connect Camera", e);

                throw new CameraHardwareException(e);

            }

            mParameters = mCameraDevice.getParameters();

        } else {

……

         下面大概介绍下我对CameraHolder的理解：

         1、CameraHolder对mCameraDevice实例进行短暂的保留(keep()函数中可以设定这个保留时长,一般默认为3000ms)，避免用户在短暂退出camera又重新进入时，缩短camera启动时长(正如之前所说，打开CameraDevice时间较长)

2、CameraHolder并有一个关键的计数mUsers用来保证open()和release()的配套调用，避免多次重复释放或者打开(上层应用的保护措施之一)。

2．    第一步的完成，进而跳转到了android.hardware.Camera类中的open()函数接口调用。

public static Camera open() {

    return new Camera();

}

静态函数，也就可以通过类名直接调用，open()函数中去创建一个Camera的实例。

Camera() {

        mShutterCallback = null;

        mRawImageCallback = null;

        mJpegCallback = null;

        mPreviewCallback = null;

        mPostviewCallback = null;

        mZoomListener = null;

        Looper looper;

        if ((looper = Looper.myLooper()) != null) {

            mEventHandler = new EventHandler(this, looper);

        } else if ((looper = Looper.getMainLooper()) != null) {

            mEventHandler = new EventHandler(this, looper);

        } else {

            mEventHandler = null;

        }

        native_setup(new WeakReference(this));

    }

在Camera构造函数中有这个关键的一步,最开始的一些callback可以认为它们最终被底层调用到(至于具体流程后面会讲到)。EventHandler和Looper我们暂时跳过，知道它是消息处理就行了。最后也就是最为关键的函数接口调用：native_setup

      private native final void native_setup(Object camera_this);

典型的native函数接口声明，说明并非camera类的本地函数实现，也就意味着会通过JNI(Java Native Interface)调用对用C++文件中的函数接口。

3．    通过代码搜索，或者如果你清楚JNI文件路径也可以去该路径下找。

其实这边有个小技巧，虽然不一定都通用，但可以试试看：

java类的package名往往可以作为寻找相应JNI文件的途径：

package android.hardware;

则就可以通过android.hardware.camera.cpp来寻找(其实还是归咎于android的规范命名规则)。

         跳转到android_hardware_Camera.cpp中寻找native_setup()所对应的JNI函数接口：

       static JNINativeMethod camMethods[] = {

  { "native_setup",

    "(Ljava/lang/Object;)V",

    (void*)android_hardware_Camera_native_setup },

  { "native_release",

    "()V",

    (void*)android_hardware_Camera_release },

  { "setPreviewDisplay",

    "(Landroid/view/Surface;)V",

    (void *)android_hardware_Camera_setPreviewDisplay },

         ……

而camMethods[]在什么时候映射的那？继续看：

int register_android_hardware_Camera(JNIEnv *env) {

…..

// Register native functions

    return AndroidRuntime::registerNativeMethods(env, "android/hardware/Camera",

                                           camMethods,NELEM(camMethods));

}

最终在AndroidRuntime.cpp中被调用：

         REG_JNI(register_android_hardware_Camera),

说明如果我们自己要添加JNI接口实现的话，这些地方也需要添加相应的代码(具体在AndroidRuntime.cpp的细节我没深看，也不做介绍)。

简单介绍： JNINativeMethod的第一个成员是一个字符 串，表示了JAVA本地调用方法的名称，这个名称是在JAVA程序中调用的名称；第二个成员也是一个字符串，表示JAVA本地调用方法的参数和返回值；第三个成员是JAVA本地调用方法对应的C语言函数。

         跟进观察android_hardware_Camera_native_setup()函数的实现：

    // connect to camera service

static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)

{

    sp camera = Camera::connect();

    if (camera == NULL) {

        jniThrowException(env, "java/lang/RuntimeException",

                          "Fail to connect to camera service");

        return;

    }

    ….

}

         初步可以认为Camera::connect()的函数调用时返回了一个Camera 的实例对象。

4．    通过上述的跟进流程来到了针对上层应用而言最为直接的类：camera.cpp：

对Camera::connect函数的调用如下：

    sp Camera::connect()

    {

        LOGV("connect");

        sp c = new Camera();

        const sp& cs = getCameraService();

        if (cs != 0) {

            c->mCamera = cs->connect(c);

        }

        if (c->mCamera != 0) {

            c->mCamera->asBinder()->linkToDeath(c);

            c->mStatus = NO_ERROR;

        } else {

            c.clear();

        }

        return c;

    }

首先是创建一个camera对象实例，然后通过调用getCameraService()去取得ICameraService的服务实例：

// establish binder interface to camera service

const sp& Camera::getCameraService()

{

    Mutex::Autolock _l(mLock);

    if (mCameraService.get() == 0) {

        sp sm = defaultServiceManager();

        sp binder;

        do {

            binder = sm->getService(String16("media.camera"));

            if (binder != 0)

                break;

            LOGW("CameraService not published, waiting...");

            usleep(500000); // 0.5 s

        } while(true);

        if (mDeathNotifier == NULL) {

            mDeathNotifier = new DeathNotifier();

        }

        binder->linkToDeath(mDeathNotifier);

        mCameraService = interface_cast(binder);

    }

    LOGE_IF(mCameraService==0, "no CameraService!?");

    return mCameraService;

}

这边就涉及到了ServiceManager()对服务的管理，在这之前Camera的服务已经注册到了ServiceManager中，我们可以通过服务字串(media.camera)来获得camera service(其本质得到的是CameraService的实例对象，虽然通过类型上溯转换成父类ICameraService，对ICameraService对象的函数调用本质是调用到了CameraService的函数实现)。

在得到camera service后，返回之前的步骤：当得到的cs即cameraservice实例存在时，通过调用cs->connect(c)去得到ICamera实例，并赋值给了camera实例的一个类成员ICamera  mCamera：

if (cs != 0) {

    c->mCamera = cs->connect(c);