Android Camera Subsystem - Open - 01

最新推荐文章于 2020-10-28 16:25:00 发布
最新推荐文章于 2020-10-28 16:25:00 发布
阅读量2.2k 收藏 2
点赞数
分类专栏： OS/Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanbird2008/article/details/12967365
版权

 

 

 

sm(BpServiceManager(BpBinder(handle= 0))) = defaultServiceManager()

binder =sm->getServcie(String16(kCameraServiceName))

cs =(BpCameraService(BpBinder))

c->mCamera =cs->connect(…);   // 返回 BpCamera(BpBinder)

最后c->mCamera指向一个BpCamera(BpBinder)

 

1.  frameworks/base/core/java/android/hardware/camera.java

1.1  Open

  public static Camera open(int cameraId) {

       return new Camera(cameraId);

    }

   /**

    * Creates a new Camera object to access the first back-facing camera onthe

    * device. If the device does not have a back-facing camera, this returns

    * null.

    * @see #open(int)

    */

   public static Camera open() {

       int numberOfCameras = getNumberOfCameras();

       CameraInfo cameraInfo = new CameraInfo();

       for (int i = 0; i < numberOfCameras; i++) {

           getCameraInfo(i, cameraInfo);

           if (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK) {

                return new Camera(i);

           }

       }

       return null;

}

1.2 Camera Constructor

   Camera(int cameraId) {

       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;

       }

 

       String packageName = ActivityThread.currentPackageName();

 

       native_setup(newWeakReference<Camera>(this), cameraId, packageName);

}

2.   frameworks/base/core/jni/android_hardware_Camera.cpp

// connect tocamera service

static voidandroid_hardware_Camera_native_setup(JNIEnv *env, jobject thiz,

    jobject weak_this, jint cameraId, jstringclientPackageName)

{

    // Convert jstring to String16

    const char16_t *rawClientName =env->GetStringChars(clientPackageName, NULL);

    jsize rawClientNameLen =env->GetStringLength(clientPackageName);

    String16 clientName(rawClientName,rawClientNameLen);

    env->ReleaseStringChars(clientPackageName,rawClientName);

 

   // 这儿模板实例是Camera

   // Camera::connect()返回一个Camera对象

   // 因此camera是一个Camera对象

 

    sp<Camera>camera = Camera::connect(cameraId, clientName,

           Camera::USE_CALLING_UID);

   

    if (camera == NULL) {

        jniThrowRuntimeException(env,"Fail to connect to camera service");

        return;

    }

 

    // make sure camera hardware is alive

    if (camera->getStatus() != NO_ERROR) {

        jniThrowRuntimeException(env,"Camera initialization failed");

        return;

    }

 

    jclass clazz = env->GetObjectClass(thiz);

    if (clazz == NULL) {

        jniThrowRuntimeException(env,"Can't find android/hardware/Camera");

        return;

    }

 

    // We use a weak reference so the Cameraobject can be garbage collected.

    // The reference is only used as a proxyfor callbacks.

  // 将camera(本地Camera对象)保存在Java上下文

 

 sp<JNICameraContext>context = new JNICameraContext(env, weak_this, clazz, camera);

   context->incStrong((void*)android_hardware_Camera_native_setup);

    camera->setListener(context);

 

    // save context in opaque field

    env->SetIntField(thiz, fields.context,(int)context.get());

}

 

 

 

 

3.   frameworks/av/camera/Camera.cpp

sp<Camera>Camera::connect(int cameraId, const String16& clientPackageName,

        int clientUid)

{

   // 这儿模板实例是Camera

    returnCameraBaseT::connect(cameraId, clientPackageName, clientUid);

}

Notes:

Inframeworks/av/include/camera/CameraBase.cpp

template<typename TCam, typename TCamTraits = CameraTraits<TCam> >

class CameraBase: public IBinder::DeathRecipient

{

typedef CameraBase<TCam>        CameraBaseT;

};

4.   frameworks/av/camera/CameraBase.cpp

4.1  connect

template<typename TCam, typename TCamTraits>

sp<TCam>CameraBase<TCam, TCamTraits>::connect(int cameraId,

                                         constString16& clientPackageName,

                                              int clientUid)

{

   // 上层模板实例是Camera,因此这儿TCam就是 Camera

    ALOGV("%s: connect",__FUNCTION__);

 

//模板实例是一个Camera,因此c是一个Camera对象

 

    sp<TCam> c = new TCam(cameraId);

 

    sp<TCamCallbacks> cl = c;

 

    constsp<ICameraService>& cs = getCameraService();

 

  //这儿getCameraService 返回的是一个BpCameraService对象，并将一个BpBinder

    // 对象赋值给BpCameraService对象的成员变量mRemote,

     //这些是通过getCameraService调用defaultServiceManager()及interface_cast函数来实现的

 

    if (cs != 0) {  // mCamera定义在 CameraBase类中

 

       c->mCamera =cs->connect(cl, cameraId, clientPackageName, clientUid);

 

// 这里 cs->connect返回的是一个BpCamera对象，因此 c->mCamera保存的是一个BpCamera对象。

//  BpCamera也有一个mRemote对象，也指向一个BpBinder对象（看下面BpCameraService::connect，

//  这个BpBinder就是依据reply中得到的BnBinder（BnCameraService）生成的对应的本地接口BpBinder），

//  也就是说在这儿得到Service的response.

 

    }

    if (c->mCamera != 0) {

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

        c->mStatus = NO_ERROR;

    } else {

        c.clear();

    }

    return c;

}

4.2getCameraService

// establishbinder interface to camera service

template<typename TCam, typename TCamTraits>

constsp<ICameraService>& CameraBase<TCam,TCamTraits>::getCameraService()

{

    Mutex::Autolock _l(gLock);

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

       sp<IServiceManager>sm = defaultServiceManager();

// sm是一个BpServiceManager, 并且BpServiceManager的mRemote成员变量

// 将指向一个BpBinder(handle = 0), 0代表 ServiceManager.

        sp<IBinder> binder;

        do {

//这儿从getService()返回的binder是一个BpBinder对象.服务端返回的

//是一个BnCameraService？之类的BnBinder对象，客户端在checkService中

//将通过readStrongBinder来依据这个BnBinder对象来生成本地接口BpBinder对象。

 

           binder =sm->getService(String16(kCameraServiceName));

            if (binder != 0) {

                break;

            }

            ALOGW("CameraService notpublished, waiting...");

            usleep(kCameraServicePollDelay);

        } while(true);

        if (gDeathNotifier == NULL) {

            gDeathNotifier = newDeathNotifier();

        }

        binder->linkToDeath(gDeathNotifier);

// interface_cast函数将生成一个BpCameraService对象，并把binder(BpBinder对象)

//赋值给mRemote成员变量，即gCameraService是一个BpCameraService对象。

       gCameraService= interface_cast<ICameraService>(binder);

    }

    ALOGE_IF(gCameraService == 0, "noCameraService!?");

    return gCameraService;

}

 

首先取得跨进程的IServiceManager，然后取得camera service（这个service在mediaserver启动时注册）。最重要的，把这个返回的binder对象经过interface_cast<ICameraService>处理，生成一个BpCameraService对象,并将binder对象赋值给BpCameraService的成员变量mRemote. Interface_cast在 frameworks/native/include/binder/IInterface.h中实现。

 

namespaceandroid {

 

//----------------------------------------------------------------------

 

class IInterface: public virtual RefBase

{

public:

            IInterface();

            sp<IBinder>         asBinder();

            sp<const IBinder>   asBinder() const;

           

protected:

    virtual                     ~IInterface();

    virtual IBinder*            onAsBinder() = 0;

};

 

//----------------------------------------------------------------------

 

template<typenameINTERFACE>

inlinesp<INTERFACE> interface_cast(const sp<IBinder>& obj)

{

    return INTERFACE::asInterface(obj);

}

 

//----------------------------------------------------------------------

 

template<typenameINTERFACE>

classBnInterface : public INTERFACE, public BBinder

{

public:

    virtual sp<IInterface>      queryLocalInterface(const String16&_descriptor);

    virtual const String16&     getInterfaceDescriptor() const;

 

protected:

    virtual IBinder*            onAsBinder();

};

 

//----------------------------------------------------------------------

 

template<typenameINTERFACE>

classBpInterface : public INTERFACE, public BpRefBase

{

public:

                               BpInterface(const sp<IBinder>& remote);

 

protected:

    virtual IBinder*            onAsBinder();

};

 

//----------------------------------------------------------------------

 

#defineDECLARE_META_INTERFACE(INTERFACE)                               \

    static const android::String16descriptor;                          \

    static android::sp<I##INTERFACE>asInterface(                       \

            constandroid::sp<android::IBinder>& obj);                  \

    virtual const android::String16&getInterfaceDescriptor() const;    \

    I##INTERFACE();                                                    \

    virtual ~I##INTERFACE();                                            \

 

 

#defineIMPLEMENT_META_INTERFACE(INTERFACE, NAME)                       \

    const android::String16 I##INTERFACE::descriptor(NAME);             \

    const android::String16&                                            \

           I##INTERFACE::getInterfaceDescriptor() const {              \

        return I##INTERFACE::descriptor;                                \

    }                                                                  \

    android::sp<I##INTERFACE>I##INTERFACE::asInterface(               \

            constandroid::sp<android::IBinder>& obj)                   \

    {                                                                   \

        android::sp<I##INTERFACE>intr;                                 \

        if (obj != NULL) {                                              \

           intr =static_cast<I##INTERFACE*>(                          \

               obj->queryLocalInterface(                               \

                       I##INTERFACE::descriptor).get());               \

            if (intr == NULL) {                                         \

               intr =new Bp##INTERFACE(obj);                         \

            }                                                          \

        }                                                              \

        return intr;                                                    \

    }                                                                  \

    I##INTERFACE::I##INTERFACE() { }                                    \

    I##INTERFACE::~I##INTERFACE() { }                                   \

 

 

#define CHECK_INTERFACE(interface,data, reply)                         \

    if (!data.checkInterface(this)) { returnPERMISSION_DENIED; }       \

 

 

//----------------------------------------------------------------------

// Nouser-serviceable parts after this...

 

template<typenameINTERFACE>

inlinesp<IInterface> BnInterface<INTERFACE>::queryLocalInterface(

        const String16& _descriptor)

{

    if (_descriptor == INTERFACE::descriptor)return this;

    return NULL;

}

 

template<typenameINTERFACE>

inline const String16&BnInterface<INTERFACE>::getInterfaceDescriptor() const

{

    return INTERFACE::getInterfaceDescriptor();

}

 

template<typenameINTERFACE>

IBinder*BnInterface<INTERFACE>::onAsBinder()

{

    return this;

}

 

template<typenameINTERFACE>

inlineBpInterface<INTERFACE>::BpInterface(const sp<IBinder>& remote)

    : BpRefBase(remote)

{

}

 

template<typenameINTERFACE>

inline IBinder*BpInterface<INTERFACE>::onAsBinder()

{

    return remote();

}

   

//----------------------------------------------------------------------

 

}; // namespaceandroid

 

5.   frameworks/av/camera/ICameraService.cpp

5.1  BpCameraService::connect

c->mCamera = cs->connect(cl, cameraId,clientPackageName, clientUid);

由于cs是经过interace_cast得到的BpCameraService,因此实际调用 BpCameraService::connect.

 

    // connect to camera service

    virtual sp<ICamera> BpCameraService::connect(constsp<ICameraClient>& cameraClient, int cameraId,

                                const String16&clientPackageName, int clientUid)

    {

        Parcel data, reply;

       data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());

       data.writeStrongBinder(cameraClient->asBinder());

        data.writeInt32(cameraId);

        data.writeString16(clientPackageName);

        data.writeInt32(clientUid);

       remote()->transact(BnCameraService::CONNECT, data, &reply);

       returninterface_cast<ICamera>(reply.readStrongBinder());

 

       // 这里又一次用到了interface_cast,在interface_cast里，

// 将生成一个newBpCamera(binder object)，

// 客户端将从reply中得到的服务端CameraClient对象，

// 经readStrongBinder()生成的相应的本地接口BpBinder对象。

       // in BpCamera构造函数里，实际上是通过其基类BpRefBase的构造函数，

//(CameraClient继承自BnCameraClient，BnCameraClient继承自BBinder)，

// 将这个本地接口(BpBinder)赋值给mRemote成员变量，也就是说BpCamera对象的mRemote成

// 员变量实际上指向从服务器端返回的CameraClient对象向对应的BpBinder本地接口对象

// 这样在BpCamera和 BnCamera之间建立了一一对应的关系。Camera后面的操作，

// 如startPreview等就基于这个对应关系进行binder通讯

 

// BpRefBase::BpRefBase(const sp<IBinder>& o)
//     : mRemote(o.get()), mRefs(NULL), mState(0)
// {
//     extendObjectLifetime(OBJECT_LIFETIME_WEAK);

//    if (mRemote) {
//       mRemote->incStrong(this);          // Removed on first IncStrong().
//        mRefs =mRemote->createWeak(this);  // Held for our entire lifetime.
//    }
//}

 

 

    }

这里remote()函数返回的是mRemote成员变量，它指向一个BpBinder对象。

因此remote()->transact（）实际上调用的是BpBinder::transact()

 

 

6.   frameworks/native/libs/binder/BpBinder.cpp

6.1  BpBinder::transact

 

status_tBpBinder::transact(

    uint32_t code, const Parcel& data,Parcel* reply, uint32_t flags)

{

    // Once a binder has died, it will nevercome back to life.

    if (mAlive) {

       status_t status= IPCThreadState::self()->transact(

           mHandle,code, data, reply, flags);

        if (status == DEAD_OBJECT) mAlive = 0;

        return status;

    }

 

    return DEAD_OBJECT;

}

 

7.   frameworks/native/libs/binder/IPCThreadState.cpp

7.1 IPCThreadState::transact

写数据到binderdriver中

status_tIPCThreadState::transact(int32_t handle,

                                  uint32_tcode, const Parcel& data,

                                  Parcel*reply, uint32_t flags)

{

    status_t err = data.errorCheck();

 

    flags |= TF_ACCEPT_FDS;

 

    IF_LOG_TRANSACTIONS() {

        TextOutput::Bundle _b(alog);

        alog << "BC_TRANSACTION thr" << (void*)pthread_self() << " / hand "

            << handle << " /code " << TypeCode(code) << ": "

            << indent << data<< dedent << endl;

    }

   

    if (err == NO_ERROR) {

        LOG_ONEWAY(">>>> SENDfrom pid %d uid %d %s", getpid(), getuid(),

            (flags & TF_ONE_WAY) == 0 ?"READ REPLY" : "ONE WAY");

       err =writeTransactionData(BC_TRANSACTION, flags, handle, code, data, NULL);

    }

   

    if (err != NO_ERROR) {

        if (reply) reply->setError(err);

        return (mLastError = err);

    }

   

    if ((flags & TF_ONE_WAY) == 0) {

        #if 0

        if (code == 4) { // relayout

           ALOGI(">>>>>> CALLING transaction 4");

        } else {

            ALOGI(">>>>>>CALLING transaction %d", code);

        }

        #endif

        if (reply) {

           err =waitForResponse(reply);

        } else {

            Parcel fakeReply;

            err =waitForResponse(&fakeReply);

        }

        #if 0

        if (code == 4) { // relayout

           ALOGI("<<<<<< RETURNING transaction 4");

        } else {

           ALOGI("<<<<<< RETURNING transaction %d",code);

        }

        #endif

       

        IF_LOG_TRANSACTIONS() {

            TextOutput::Bundle _b(alog);

            alog << "BR_REPLY thr" << (void*)pthread_self() << " / hand "

                << handle <<": ";

            if (reply) alog << indent<< *reply << dedent << endl;

            else alog << "(nonerequested)" << endl;

        }

    } else {

        err = waitForResponse(NULL, NULL);

    }

   

    return err;

}

 

7.2  IPCThreadState::writeTransactionData

 

status_tIPCThreadState::writeTransactionData(int32_t cmd, uint32_t binderFlags,

    int32_t handle, uint32_t code, const Parcel&data, status_t* statusBuffer)

{

    binder_transaction_data tr;

 

   tr.target.handle =handle;  // handle 标识目的端，其中0标识ServiceManager

    tr.code = code;

    tr.flags = binderFlags;

    tr.cookie = 0;

    tr.sender_pid = 0;

    tr.sender_euid = 0;

   

    const status_t err = data.errorCheck();

    if (err == NO_ERROR) {

        tr.data_size = data.ipcDataSize();

        tr.data.ptr.buffer = data.ipcData();

        tr.offsets_size =data.ipcObjectsCount()*sizeof(size_t);

        tr.data.ptr.offsets = data.ipcObjects();

    } else if (statusBuffer) {

        tr.flags |= TF_STATUS_CODE;

        *statusBuffer = err;

        tr.data_size = sizeof(status_t);

        tr.data.ptr.buffer = statusBuffer;

        tr.offsets_size = 0;

        tr.data.ptr.offsets = NULL;

    } else {

        return (mLastError = err);

    }

 

   // mIn, mOut是连个Parcel对象，发送和接收命令缓冲区。

   // 每个IPCThreadState都有一个mIn, mOut；mIn是用来接收从binder设备

//来的数据，而mOut是用来存储发往binder设备的数据。

//写命令到缓冲区

    mOut.writeInt32(cmd);

    mOut.write(&tr, sizeof(tr));

   

    return NO_ERROR;

}

 

 

 

 

7.3  IPCThreadState:: waitForResponse

 

发送请求与接收响应

status_tIPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult)

{

    int32_t cmd;

    int32_t err;

 

    while (1) {

       if((err=talkWithDriver()) < NO_ERROR) break;

        err = mIn.errorCheck();

        if (err < NO_ERROR) break;

        if (mIn.dataAvail() == 0) continue;

       

        cmd = mIn.readInt32();

       

        IF_LOG_COMMANDS() {

            alog << "ProcessingwaitForResponse Command: "

                << getReturnString(cmd)<< endl;

        }

 

        switch (cmd) {

        case BR_TRANSACTION_COMPLETE:

            if (!reply &&!acquireResult) goto finish;

            break;

       

        case BR_DEAD_REPLY:

            err = DEAD_OBJECT;

            goto finish;

 

        case BR_FAILED_REPLY:

            err = FAILED_TRANSACTION;

            goto finish;

       

        case BR_ACQUIRE_RESULT:

            {

                ALOG_ASSERT(acquireResult !=NULL, "Unexpected brACQUIRE_RESULT");

                const int32_t result =mIn.readInt32();

                if (!acquireResult) continue;

                *acquireResult = result ?NO_ERROR : INVALID_OPERATION;

            }

            goto finish;

       

        case BR_REPLY:

            {

                binder_transaction_data tr;

                err = mIn.read(&tr,sizeof(tr));

                ALOG_ASSERT(err == NO_ERROR,"Not enough command data for brREPLY");

                if (err != NO_ERROR) gotofinish;

 

                if (reply) {

                    if ((tr.flags &TF_STATUS_CODE) == 0) {

                       reply->ipcSetDataReference(

                           reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),

                            tr.data_size,

                           reinterpret_cast<const size_t*>(tr.data.ptr.offsets),

                           tr.offsets_size/sizeof(size_t),

                            freeBuffer, this);

                    } else {

                        err =*static_cast<const status_t*>(tr.data.ptr.buffer);

                        freeBuffer(NULL,

                           reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),

                            tr.data_size,

                            reinterpret_cast<constsize_t*>(tr.data.ptr.offsets),

                           tr.offsets_size/sizeof(size_t), this);

                    }

                } else {

                    freeBuffer(NULL,

                        reinterpret_cast<constuint8_t*>(tr.data.ptr.buffer),

                        tr.data_size,

                       reinterpret_cast<const size_t*>(tr.data.ptr.offsets),

                       tr.offsets_size/sizeof(size_t), this);

                    continue;

                }

            }

            goto finish;

 

        default:

           err =executeCommand(cmd);

            if (err != NO_ERROR) goto finish;

            break;

        }

    }

 

finish:

    if (err != NO_ERROR) {

        if (acquireResult) *acquireResult =err;

        if (reply) reply->setError(err);

        mLastError = err;

    }

   

    return err;

}

 

7.4  IPCThreadState:: talkWithDriver

 

IPCThreadState:: talkWithDriver

status_tIPCThreadState::talkWithDriver(bool doReceive)

{

    if (mProcess->mDriverFD <= 0) {

        return -EBADF;

    }

   

    binder_write_read bwr;

   

    // Is the read buffer empty?

    const bool needRead = mIn.dataPosition()>= mIn.dataSize();

   

    // We don't want to write anything if weare still reading

    // from data left in the input buffer andthe caller

    // has requested to read the next data.

    const size_t outAvail = (!doReceive ||needRead) ? mOut.dataSize() : 0;

   

    bwr.write_size = outAvail;

    bwr.write_buffer = (long unsignedint)mOut.data();

 

    // This is what we'll read.

    if (doReceive && needRead) {

        bwr.read_size = mIn.dataCapacity();

        bwr.read_buffer = (long unsignedint)mIn.data();

    } else {

        bwr.read_size = 0;

        bwr.read_buffer = 0;

    }

 

    IF_LOG_COMMANDS() {

        TextOutput::Bundle _b(alog);

        if (outAvail != 0) {

            alog << "Sendingcommands to driver: " << indent;

            const void* cmds = (constvoid*)bwr.write_buffer;

            const void* end = ((constuint8_t*)cmds)+bwr.write_size;

            alog << HexDump(cmds,bwr.write_size) << endl;

            while (cmds < end) cmds =printCommand(alog, cmds);

            alog << dedent;

        }

        alog << "Size of receivebuffer: " << bwr.read_size

            << ", needRead: "<< needRead << ", doReceive: " << doReceive<< endl;

    }

   

    // Return immediately if there is nothingto do.

    if ((bwr.write_size == 0) &&(bwr.read_size == 0)) return NO_ERROR;

 

    bwr.write_consumed = 0;

    bwr.read_consumed = 0;

    status_t err;

    do {

        IF_LOG_COMMANDS() {

            alog << "About toread/write, write size = " << mOut.dataSize() << endl;

        }

#if defined(HAVE_ANDROID_OS)

       if(ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0)

            err = NO_ERROR;

        else

            err = -errno;

#else

        err = INVALID_OPERATION;

#endif

        if (mProcess->mDriverFD <= 0) {

            err = -EBADF;

        }

        IF_LOG_COMMANDS() {

            alog << "Finishedread/write, write size = " << mOut.dataSize() << endl;

        }

    } while (err == -EINTR);

 

    IF_LOG_COMMANDS() {

        alog << "Our err: "<< (void*)err << ", write consumed: "

            << bwr.write_consumed<< " (of " << mOut.dataSize()

                           << "),read consumed: " << bwr.read_consumed << endl;

    }

 

    if (err >= NO_ERROR) {

        if (bwr.write_consumed > 0) {

            if (bwr.write_consumed <(ssize_t)mOut.dataSize())

                mOut.remove(0,bwr.write_consumed);

            else

                mOut.setDataSize(0);

        }

        if (bwr.read_consumed > 0) {

            mIn.setDataSize(bwr.read_consumed);

            mIn.setDataPosition(0);

        }

        IF_LOG_COMMANDS() {

            TextOutput::Bundle _b(alog);

            alog << "Remaining datasize: " << mOut.dataSize() << endl;

            alog << "Receivedcommands from driver: " << indent;

            const void* cmds = mIn.data();

            const void* end = mIn.data() +mIn.dataSize();

            alog << HexDump(cmds,mIn.dataSize()) << endl;

            while (cmds < end) cmds =printReturnCommand(alog, cmds);

            alog << dedent;

        }

        return NO_ERROR;

    }

   

    return err;

}

 

7.5  IPCThreadState:: executeCommand

现在假设请求后得到回复响应

status_tIPCThreadState::executeCommand(int32_t cmd)

{

    BBinder* obj;

    RefBase::weakref_type* refs;

    status_t result = NO_ERROR;

   

    switch (cmd) {

    case BR_ERROR:

        result = mIn.readInt32();

        break;

       

    case BR_OK:

        break;

       

    case BR_ACQUIRE:

        refs =(RefBase::weakref_type*)mIn.readInt32();

        obj = (BBinder*)mIn.readInt32();

        ALOG_ASSERT(refs->refBase() == obj,

                   "BR_ACQUIRE: object %pdoes not match cookie %p (expected %p)",

                   refs, obj,refs->refBase());

        obj->incStrong(mProcess.get());

        IF_LOG_REMOTEREFS() {

            LOG_REMOTEREFS("BR_ACQUIREfrom driver on %p", obj);

            obj->printRefs();

        }

        mOut.writeInt32(BC_ACQUIRE_DONE);

        mOut.writeInt32((int32_t)refs);

        mOut.writeInt32((int32_t)obj);

        break;

       

    case BR_RELEASE:

        refs = (RefBase::weakref_type*)mIn.readInt32();

        obj = (BBinder*)mIn.readInt32();

        ALOG_ASSERT(refs->refBase() == obj,

                   "BR_RELEASE: object %pdoes not match cookie %p (expected %p)",

                   refs, obj,refs->refBase());

        IF_LOG_REMOTEREFS() {

            LOG_REMOTEREFS("BR_RELEASEfrom driver on %p", obj);

            obj->printRefs();

        }

        mPendingStrongDerefs.push(obj);

        break;

       

    case BR_INCREFS:

        refs =(RefBase::weakref_type*)mIn.readInt32();

        obj = (BBinder*)mIn.readInt32();

        refs->incWeak(mProcess.get());

        mOut.writeInt32(BC_INCREFS_DONE);

        mOut.writeInt32((int32_t)refs);

        mOut.writeInt32((int32_t)obj);

        break;

       

    case BR_DECREFS:

        refs =(RefBase::weakref_type*)mIn.readInt32();

        obj = (BBinder*)mIn.readInt32();

        // NOTE: This assertion is not valid,because the object may no

        // longer exist (thus the(BBinder*)cast above resulting in a different

        // memory address).

        //ALOG_ASSERT(refs->refBase() ==obj,

        //           "BR_DECREFS: object %p does notmatch cookie %p (expected %p)",

        //           refs, obj, refs->refBase());

        mPendingWeakDerefs.push(refs);

        break;

       

    case BR_ATTEMPT_ACQUIRE:

        refs =(RefBase::weakref_type*)mIn.readInt32();

        obj = (BBinder*)mIn.readInt32();

        

        {

            const bool success =refs->attemptIncStrong(mProcess.get());

            ALOG_ASSERT(success &&refs->refBase() == obj,

                      "BR_ATTEMPT_ACQUIRE: object %p does not match cookie %p (expected%p)",

                       refs, obj,refs->refBase());

           

            mOut.writeInt32(BC_ACQUIRE_RESULT);

            mOut.writeInt32((int32_t)success);

        }

        break;

   

    case BR_TRANSACTION:

        {

            binder_transaction_data tr;

            result = mIn.read(&tr,sizeof(tr));

            ALOG_ASSERT(result == NO_ERROR,

                "Not enough command datafor brTRANSACTION");

            if (result != NO_ERROR) break;

           

            Parcel buffer;

            buffer.ipcSetDataReference(

                reinterpret_cast<constuint8_t*>(tr.data.ptr.buffer),

                tr.data_size,

                reinterpret_cast<constsize_t*>(tr.data.ptr.offsets),

                tr.offsets_size/sizeof(size_t),freeBuffer, this);

           

            const pid_t origPid = mCallingPid;

            const uid_t origUid = mCallingUid;

           

            mCallingPid = tr.sender_pid;

            mCallingUid = tr.sender_euid;

           

            int curPrio =getpriority(PRIO_PROCESS, mMyThreadId);

            if (gDisableBackgroundScheduling) {

                if (curPrio >ANDROID_PRIORITY_NORMAL) {

                    // We have inherited areduced priority from the caller, but do not

                    // want to run in thatstate in this process.  The driver setour

                    // priority already (thoughnot our scheduling class), so bounce

                    // it back to the defaultbefore invoking the transaction.

                    setpriority(PRIO_PROCESS,mMyThreadId, ANDROID_PRIORITY_NORMAL);

                }

            } else {

                if (curPrio >= ANDROID_PRIORITY_BACKGROUND){

                    // We want to use theinherited priority from the caller.

                    // Ensure this thread is inthe background scheduling class,

                    // since the driver won'tmodify scheduling classes for us.

                    // The scheduling group isreset to default by the caller

                    // once this method returnsafter the transaction is complete.

                   set_sched_policy(mMyThreadId, SP_BACKGROUND);

                }

            }

 

            //ALOGI(">>>>TRANSACT from pid %d uid %d\n", mCallingPid, mCallingUid);

           

            Parcel reply;

            IF_LOG_TRANSACTIONS() {

                TextOutput::Bundle _b(alog);

                alog << "BR_TRANSACTIONthr " << (void*)pthread_self()

                    << " / obj" << tr.target.ptr << " / code "

                    << TypeCode(tr.code)<< ": " << indent << buffer

                    << dedent <<endl

                    << "Data addr ="

                    << reinterpret_cast<constuint8_t*>(tr.data.ptr.buffer)

                    << ", offsetsaddr="

                    <<reinterpret_cast<const size_t*>(tr.data.ptr.offsets) << endl;

            }

            if (tr.target.ptr) {

// registered CameraService object, CameraServiceinherit from BBinder

               sp<BBinder> b((BBinder*)tr.cookie);

               conststatus_t error = b->transact(tr.code, buffer, &reply, tr.flags);

                if (error < NO_ERROR)reply.setError(error);

            } else {

                const status_t error =the_context_object->transact(tr.code, buffer, &reply, tr.flags);

                if (error < NO_ERROR)reply.setError(error);

            }

           

            //ALOGI("<<<<TRANSACT from pid %d restore pid %d uid %d\n",

            //     mCallingPid, origPid, origUid);

           

            if ((tr.flags & TF_ONE_WAY) ==0) {

                LOG_ONEWAY("Sending replyto %d!", mCallingPid);

                sendReply(reply, 0);

            } else {

                LOG_ONEWAY("NOT sendingreply to %d!", mCallingPid);

            }

           

            mCallingPid = origPid;

            mCallingUid = origUid;

 

            IF_LOG_TRANSACTIONS() {

                TextOutput::Bundle _b(alog);

                alog << "BC_REPLY thr" << (void*)pthread_self() << " / obj "

                    << tr.target.ptr<< ": " << indent << reply << dedent <<endl;

            }

           

        }

        break;

   

    case BR_DEAD_BINDER:

        {

            BpBinder *proxy =(BpBinder*)mIn.readInt32();

            proxy->sendObituary();

           mOut.writeInt32(BC_DEAD_BINDER_DONE);

            mOut.writeInt32((int32_t)proxy);

        } break;

       

    case BR_CLEAR_DEATH_NOTIFICATION_DONE:

        {

            BpBinder *proxy =(BpBinder*)mIn.readInt32();

           proxy->getWeakRefs()->decWeak(proxy);

        } break;

       

    case BR_FINISHED:

        result = TIMED_OUT;

        break;

       

    case BR_NOOP:

        break;

        

    case BR_SPAWN_LOOPER:

        mProcess->spawnPooledThread(false);

        break;

       

    default:

        printf("*** BAD COMMAND %dreceived from Binder driver\n", cmd);

        result = UNKNOWN_ERROR;

        break;

    }

 

    if (result != NO_ERROR) {

        mLastError = result;

    }

   

    return result;

}

 

 

 

 

fanbird2008
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Android Camera Subsystem 架构（Binder机制）及显示分析
明伟的专栏
07-21 5071
Copyright:http://blog.csdn.net/myzhzygh/article/details/6622419 Contents: 1 Camera Architecture （Binder机制应用） 该部分主要借助Camera Subsystem分享自己对binder的理解。对该部分的阅读不需要太多对Camera子系统的了解，结合大体类图，顺着我的思路也可以学习bind
浅谈Camera subsytem
生于忧患，死于安乐
11-20 3073
文章目录目录相机演变相机架构相机详解相机性能相机调试相机领域相机模组思维拓展     时隔差不多一年时间没写博客了，这边打算将自己的camera学习经验分享一下，内容可能比较多，会分很多节来讲，希望自己能够给点力，把这个系列写完，写好，加油加油！ 目录 这边将会以下面八大要点进行说明，工欲善其事必先利其器，这边先把学习环境搭一下好吧，由于现在最新的系统版本已经更新到12了，我这边随便先搞一下最新的源码下载吧。 浅谈Android12系统源码下载 相机演变 下周或者下下
Android Camera Subsystem - startPreview
fanbird2008的专栏
10-23 2539
startPreview   1．frameworks/base/core/java/android/hardware/Camera.java public native final void startPreview(); 2．frameworks/base/core/jni/android_hardware_Camera.cpp static voidandroid_hardware
Android Camera Subsystem - Open - 02
fanbird2008的专栏
10-23 1730
8.   frameworks/native/libs/binder/Binder.cpp 由于上述b->transact() 中b的实际对象是CameraService（CameraService inherit from BBinder）, 因此调用 BBinder::transact（） ===〉CameraService::onTransact() 因为CameraService
Soc-Camera Subsystem(阅读理解与记录）
fudexiang的博客
10-28 346
1.三要素 camera/camera device/came sensor, 通常指带有I2C接口作为控制与配置，并行或串行总线作为图像数据传输通道的传感器。 camera host, 提供sensor连接的接口。 came host bus, 数据通道，包含时钟，控制总线，图像同步信号等。 2.目的 早期是为host驱动和sensor驱动提供统一的接口，后来sensor API被V4L2标准子设备API代替，这也使得，没有host的情况下，camera驱动代码可以复用。 3.Camera Host AP
wsl-open:在Windows应用程序中，在Windows的Bash上使用xdg-open打开文件。 来自GitLab的只读镜像，请参阅链接
05-13
wsl-open（ :open_file_folder: :right_arrow: :laptop: ） 在Windows GUI应用程序中的的打开文件的实用程序。用法只需使用要打开的文件/目录/ URL运行wsl- open。wsl-open { FILE | DIRECTORY | URL } FILE路径可以...
SubSystem-开源
05-15
"SubSystem-开源"是一个专为PHP环境设计的开源门户系统，特别强调对MySQL数据库的支持。这个项目的主要目的是提供一个轻量级且易定制的首页解决方案，不仅适用于专业的开发人员，也适合那些对编程有一定兴趣但并非...
subsystem-examples
05-19
子系统示例 该存储库显示了如何开始使用。 子系统规范有助于定义，分发和部署由多个OSGi捆绑包组成的应用程序。 此外，规范定义了隔离模型，以防止子系统的实现细节... 假设您要安装由application-subsystem模块构建a
Mozzers SubSystem-开源
04-24
"Mozzers SubSystem"是一个开源项目，旨在提供一个网络工程工具，使得用户能够在自己的网站上快速、便捷地托管无限数量的子域名。这个系统的一大特点是它并不依赖于数据库，但需要PHP环境来运行，这降低了对服务器...
Device-Registration-Subsystem-Frontend
04-29
项目许可证已更新，以删除确认要求DRS前端版权所有（c）2018-2021 Qualcomm Technologies，Inc. 版权所有。 在满足以下条件的情况下，允许以原始和二进制形式进行重新分发和使用，无论是否进行修改（受以下免责声明...
V4L2 soc camera 分析 - 系统架构图
longshan_2009的专栏
06-07 904
转载于：http://blog.csdn.net/kickxxx/article/details/8484498 图1 soc camera 子系统 系统架构图 Soc camera sub-system对应着drivers/media/video/下的soc_camera.c soc_camera_platform.c Soc camera host 是
终于搞定android驱动USB摄像头了！
zhuanghuahui的专栏
07-25 1万+
终于搞定android驱动USB摄像头了！ 多亏了stackoverflow看到的一篇帖子，其中有几句关键的话，然后顺藤摸瓜解决了问题。 帖子大意： 讨论的前提是你的USB摄像头是UVC兼容的（如今大部分摄像头兼容） 默认Android不提供访问外部摄像头的API，所以你要考虑写一个内核到Android应用层通信的中间件。 当你给设备接入了USB摄像头，首先要检查一下几点： 1)你
Android UVC外接摄像头推送-EasyPusher
jyt0551的博客
12-25 4034
最近EasyPusher针对UVC摄像头做了适配.我们结合了UVCCamera与EasyPusher,支持将UVC摄像头的视频推送到RTSP服务器上.在此特别感谢UVCCamera这个牛逼的项目!来看看是怎么操作UVC摄像头的吧.我们实现了一个专门检测UVC摄像头的服务:UVCCameraService类,主要代码如下:监听mUSBMonitor = new USBMonitor(this, new
Android usb camera设备添加
菜鸟程序员GG的专栏
12-18 6460
最近要在我们的某Android设备上添加USB Camera，之前没有神马经验。加上以前做过这个的同事很忙，也不好相处，问了十句话才给我回复一句话这样子的情况，我很郁闷，就把添加的过程全部写出来 本菜鸟也是刚接触Android的开发。所以写的尽量简单明了。、 其实Camera的开发各个书上或者博客上都有写，但是没有写具体如何做。笨鸟我也晃了几天没什么进展。 以下摘抄自我桌上的一本 王
外接 USB 摄像头(UVC Camera)
每一个不曾起舞的日子，都是对生命的辜负
07-30 5045
Android 平台支持使用即插即用的 USB 摄像头（即网络摄像头），但前提是这些摄像头采用标准的Android Camera2 API和摄像头HIDL接口。网络摄像头通常支持USB 视频类 (UVC)驱动程序，并且在 Linux 上，系统采用标准的Video4Linux (V4L)驱动程序控制 UVC 摄像头。 如果系统支持网络摄像头，设备便可用于视频聊天和照片冲印机等轻量级用例。此功能不能替代 Android 手机上典型的内部相机 HAL，也不是为了协助执行涉及高分辨率和高速流式传输...
RK3288 uvc摄像头调试
热门推荐
不喜欢debug的疯子
10-31 1万+
曾经在全志平台上调试过UVC摄像头,当时调试过程比较流畅，丝毫没有碰上异常情况，这一次在RK上碰到较大的困难，下面介绍一下我的调试过程。 首先，不用说当然在内核配置中配置上UVC摄像头，重新编译内核，烧录。 Device Drivers ---> Multimedia support ---> Video For Linux [*] Enable Video Fo
s5p4418调试usb camera设备结果分析与usb驱动简要分析
Eliot_shao的专栏
11-11 2721
第一，开发环境 硬件：三星s5p4418 linux version：3.4.39 ubuntu：14.04 usb camera：whois 第二，usb camera调试结果分析 1，将usb camera驱动打入内核，插上usb camera，系统启动后会在kmesg中有如下提示： [ 1.015000] usb 1-1: New USB device found,
Windows USB摄像头驱动安装与使用
suxiang198的博客
07-11 4509
问题描述：自己的笔记本自带摄像头，但使用时摄像头并不能自由移动，需要移动笔记本电脑。正好身边有一个用过的USB摄像头，于是拿来试用了下。 试用过程：直接插上笔记本的USB接口，Win7弹出自动查找驱动的对话框，但未能进行自动安装，但给出了驱动的下载地址，于是下载和安装了驱动，驱动压缩包名字为DRV_VC0305_VA6241_50hz。解压缩后并未找到Win7的文件夹，于是直接双击setu
ext-ms-win32-subsystem-query-l1-1-0.dll 下载
最新发布
07-28
抱歉，我无法提供 ext-ms-win32-subsystem-query-l1-1-0.dll 文件的下载。这个文件是 Windows 操作系统的一部分，应该来源于官方渠道或者通过操作系统的更新进行获取。 如果您发现 ext-ms-win32-subsystem-query-l1-1-0.dll 文件丢失或损坏，我建议您尝试以下解决方法： 1. 运行系统文件检查器：打开命令提示符（以管理员身份运行）并输入命令 "sfc /scannow"，然后按回车键。这将扫描并修复系统文件中的任何损坏或丢失的文件。 2. 更新操作系统：确保您的操作系统是最新的，通过 Windows 更新进行更新。 3. 如果您需要特定版本的 ext-ms-win32-subsystem-query-l1-1-0.dll，您可以尝试从可信赖的第三方软件库或者开发者网站下载该文件。但请注意，从非官方来源下载 DLL 文件存在风险，可能会导致系统不稳定或安全问题。 如果问题依然存在或者您有其他疑问，请考虑联系 Microsoft 支持或者寻求专业的技术支持。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值