status_t OMX::allocateNode( const char *name, const sp<IOMXObserver> &observer, node_id *node) { Mutex::Autolock autoLock(mLock); *node = 0; OMXNodeInstance *instance = new OMXNodeInstance(this, observer); OMX_COMPONENTTYPE *handle; OMX_ERRORTYPE err = mMaster->makeComponentInstance( name, &OMXNodeInstance::kCallbacks, instance, &handle); if (err != OMX_ErrorNone) { ALOGV("FAILED to allocate omx component '%s'", name); instance->onGetHandleFailed(); return UNKNOWN_ERROR; } *node = makeNodeID(instance); mDispatchers.add(*node, new CallbackDispatcher(instance)); instance->setHandle(*node, handle); mLiveNodes.add(observer->asBinder(), instance); observer->asBinder()->linkToDeath(this); return OK; }
status_t setCamera(const sp<ICamera>& camera, const sp<ICameraRecordingProxy>& proxy) { LOGV("setCamera(%p,%p)", camera.get(), proxy.get()); Parcel data, reply; data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor()); data.writeStrongBinder(camera->asBinder()); data.writeStrongBinder(proxy->asBinder()); remote()->transact(SET_CAMERA, data, &reply); return reply.readInt32(); }
// pass the buffered SurfaceTexture to the camera service // TODO(XX): Find a good name for this tap-in/tap-out buffer source status_t setBufferSource(const sp<ISurfaceTexture>& tapin, const sp<ISurfaceTexture>& tapout) { ALOGV("setBufferSource"); Parcel data, reply; data.writeInterfaceToken(ICamera::getInterfaceDescriptor()); data.writeStrongBinder(tapin->asBinder()); data.writeStrongBinder(tapout->asBinder()); remote()->transact(SET_BUFFER_SOURCE, data, &reply); return reply.readInt32(); }
virtual int RegisterObserver(sp<IRTCNode> node) { Parcel data, reply; data.writeInterfaceToken(IRTCNode::getInterfaceDescriptor()); #if ANDROID_SDK_VERSION >=23 data.writeStrongBinder(node->asBinder(node.get())); #else data.writeStrongBinder(node->asBinder()); #endif remote()->transact(kIDResigerObs, data, &reply); return reply.readInt32(); }
status_t OMX::allocateNode( const char *name, const sp<IOMXObserver> &observer, node_id *node) { ALOGV("%s(%d) try mLock", __FUNCTION__, __LINE__); Mutex::Autolock autoLock(mLock); ALOGV("%s(%d) get mLock", __FUNCTION__, __LINE__); *node = 0; OMXNodeInstance *instance = new OMXNodeInstance(this, observer); OMX_COMPONENTTYPE *handle; #if 0//def CC_SUPPORT_MTK_ANDROID_RM /* To unlock mLock is because preemption flow might have allocateNode => callback (need held mlock) It is ok because mLock seems to protect mDispatchers, mLiveNodes, ... check OMX::freeNode for reference */ mLock.unlock(); ALOGV("%s(%d) free mLock", __FUNCTION__, __LINE__); #endif OMX_ERRORTYPE err = mMaster->makeComponentInstance( name, &OMXNodeInstance::kCallbacks, instance, &handle); #if 0//def CC_SUPPORT_MTK_ANDROID_RM mLock.lock(); ALOGV("%s(%d) get mLock", __FUNCTION__, __LINE__); #endif if (err != OMX_ErrorNone) { ALOGV("FAILED to allocate omx component '%s'", name); instance->onGetHandleFailed(); ALOGV("%s(%d) free mLock", __FUNCTION__, __LINE__); return UNKNOWN_ERROR; } *node = makeNodeID(instance); mDispatchers.add(*node, new CallbackDispatcher(instance)); instance->setHandle(*node, handle); mLiveNodes.add(observer->asBinder(), instance); observer->asBinder()->linkToDeath(this); ALOGV("%s(%d) free mLock", __FUNCTION__, __LINE__); return OK; }
status_t setDataSource(const sp<IStreamSource> &source) { Parcel data, reply; data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor()); data.writeStrongBinder(source->asBinder()); remote()->transact(SET_DATA_SOURCE_STREAM, data, &reply); return reply.readInt32(); }
virtual status_t useBuffer( node_id node, OMX_U32 port_index, const sp<IMemory> ¶ms, buffer_id *buffer, size_t size) { #else virtual status_t useBuffer( node_id node, OMX_U32 port_index, const sp<IMemory> ¶ms, buffer_id *buffer) { #endif Parcel data, reply; data.writeInterfaceToken(IOMX::getInterfaceDescriptor()); data.writeIntPtr((intptr_t)node); data.writeInt32(port_index); data.writeStrongBinder(params->asBinder()); #if defined(TARGET_OMAP4) data.writeInt32(size); #endif remote()->transact(USE_BUFFER, data, &reply); status_t err = reply.readInt32(); if (err != OK) { *buffer = 0; return err; } *buffer = (void*)reply.readIntPtr(); return err; }
void Process::Stub::SmartProxy::unbindService(const sp<Intent>& intent, const sp<IRemoteCallback>& callback) { if (mRemote->runsOnSameThread()) { mStub->unbindService(intent, RemoteCallback::Stub::asInterface(callback->asBinder())); } else { mProxy->unbindService(intent, callback); } }
void Process::Stub::SmartProxy::bindService(const sp<Intent>& intent, const sp<ServiceConnection>& conn, int32_t flags, const sp<IRemoteCallback>& callback) { if (mRemote->runsOnSameThread()) { mStub->bindService(intent, conn, flags, RemoteCallback::Stub::asInterface(callback->asBinder())); } else { mProxy->bindService(intent, conn, flags, callback); } }
void ChatSession::Advise(const sp<IChatSessionEvents>& eventSink) { int callerPid = GetCallerPID(); _TRACE("ChatSession::Advise >>(%s,pid:%d)",DISPLAY_STRING16(m_wszSessionName),callerPid); if (eventSink == NULL){ _TRACE("ChatSession::Advise << E_INVALIDARG"); return; } String16 userName = eventSink->GetUserName(); if(userName.size()&& !m_bAllowAnonymousAccess){ _TRACE("ChatSession::Advise << E_ACCESSDENIED"); return; } sp<IBinder> binder = eventSink->asBinder(); binder->linkToDeath(this); _TRACE("**ADD(cse:%p binder:%p) ",eventSink.get(),binder.get()); _TRACE("add user %s",DISPLAY_STRING16(userName)); Fire_OnNewUser(userName); //ChatWorker::getInstance().Defer_OnNewUser(this,userName); Mutex::Autolock _lock(m_csAdviseLock); m_Listeners.add(callerPid,binder); _TRACE("ChatSession::Advise << S_OK"); return; }
virtual void unregisterWriter(const sp<IMemory>& shared) { Parcel data, reply; data.writeInterfaceToken(IMediaLogService::getInterfaceDescriptor()); data.writeStrongBinder(shared->asBinder()); status_t status = remote()->transact(UNREGISTER_WRITER, data, &reply); // FIXME ignores status }
void CameraService::removeClient(const sp<ICameraClient>& cameraClient) { int callingPid = getCallingPid(); LOG1("CameraService::removeClient E (pid %d)", callingPid); for (int i = 0; i < mNumberOfCameras; i++) { // Declare this before the lock to make absolutely sure the // destructor won't be called with the lock held. sp<Client> client; Mutex::Autolock lock(mServiceLock); // This happens when we have already disconnected (or this is // just another unused camera). if (mClient[i] == 0) continue; // Promote mClient. It can fail if we are called from this path: // Client::~Client() -> disconnect() -> removeClient(). client = mClient[i].promote(); if (client == 0) { mClient[i].clear(); continue; } if (cameraClient->asBinder() == client->getCameraClient()->asBinder()) { // Found our camera, clear and leave. LOG1("removeClient: clear camera %d", i); mClient[i].clear(); break; } } LOG1("CameraService::removeClient X (pid %d)", callingPid); }
virtual bool authenticateSurfaceTexture( const sp<ISurfaceTexture>& surfaceTexture) const { Parcel data, reply; int err = NO_ERROR; err = data.writeInterfaceToken( ISurfaceComposer::getInterfaceDescriptor()); if (err != NO_ERROR) { LOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing " "interface descriptor: %s (%d)", strerror(-err), -err); return false; } err = data.writeStrongBinder(surfaceTexture->asBinder()); if (err != NO_ERROR) { LOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing " "strong binder to parcel: %s (%d)", strerror(-err), -err); return false; } err = remote()->transact(BnSurfaceComposer::AUTHENTICATE_SURFACE, data, &reply); if (err != NO_ERROR) { LOGE("ISurfaceComposer::authenticateSurfaceTexture: error " "performing transaction: %s (%d)", strerror(-err), -err); return false; } int32_t result = 0; err = reply.readInt32(&result); if (err != NO_ERROR) { LOGE("ISurfaceComposer::authenticateSurfaceTexture: error " "retrieving result: %s (%d)", strerror(-err), -err); return false; } return result != 0; }
status_t ProCamera2Client::createStream(int width, int height, int format, const sp<IGraphicBufferProducer>& bufferProducer, /*out*/ int* streamId) { if (streamId) { *streamId = -1; } ATRACE_CALL(); ALOGV("%s (w = %d, h = %d, f = 0x%x)", __FUNCTION__, width, height, format); status_t res; if ( (res = checkPid(__FUNCTION__) ) != OK) return res; Mutex::Autolock icl(mBinderSerializationLock); if (!mDevice.get()) return DEAD_OBJECT; sp<IBinder> binder; sp<ANativeWindow> window; if (bufferProducer != 0) { binder = bufferProducer->asBinder(); window = new Surface(bufferProducer); } return mDevice->createStream(window, width, height, format, /*size*/1, streamId); }
// set the Surface that the preview will use status_t CameraService::Client::setPreviewDisplay(const sp<Surface>& surface) { LOG1("setPreviewDisplay(%p) (pid %d)", surface.get(), getCallingPid()); sp<IBinder> binder(surface != 0 ? surface->asBinder() : 0); sp<ANativeWindow> window(surface); return setPreviewWindow(binder, window); }
virtual status_t setObserver(const sp<IHDCPObserver> &observer) { Parcel data, reply; data.writeInterfaceToken(IHDCP::getInterfaceDescriptor()); data.writeStrongBinder(observer->asBinder()); remote()->transact(HDCP_SET_OBSERVER, data, &reply); return reply.readInt32(); }
void Process::Stub::Proxy::bindService(const sp<Intent>& intent, const sp<ServiceConnection>& conn, int32_t flags, const sp<IRemoteCallback>& callback) { sp<Bundle> data = new Bundle(); data->putObject("intent", intent); data->putObject("conn", conn); data->putInt("flags", flags); data->putBinder("binder", callback->asBinder()); mRemote->transact(MSG_BIND_SERVICE, data, nullptr, FLAG_ONEWAY); }
status_t setVideoSurface(const sp<ISurface>& surface) { Parcel data, reply; data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor()); data.writeStrongBinder(surface->asBinder()); remote()->transact(SET_VIDEO_SURFACE, data, &reply); return reply.readInt32(); }
virtual status_t connect(const sp<ICameraClient>& cameraClient) { Parcel data, reply; data.writeInterfaceToken(ICamera::getInterfaceDescriptor()); data.writeStrongBinder(cameraClient->asBinder()); remote()->transact(CONNECT, data, &reply); return reply.readInt32(); }
void releaseRecordingFrame(const sp<IMemory>& mem) { ALOGV("releaseRecordingFrame"); Parcel data, reply; data.writeInterfaceToken(ICamera::getInterfaceDescriptor()); data.writeStrongBinder(mem->asBinder()); remote()->transact(RELEASE_RECORDING_FRAME, data, &reply); }
virtual void setUser(const sp<IStreamBufferUser> &user) { Parcel data, reply; data.writeInterfaceToken(IStreamBuffer::getInterfaceDescriptor()); data.writeStrongBinder(user->asBinder()); AGILE_LOGD("enter!"); remote()->transact(SET_USER, data, &reply); AGILE_LOGD("exit!"); }
void GPUHardware::registerCallbackLocked(const sp<IGPUCallback>& callback, Client& client) { sp<IBinder> binder = callback->asBinder(); if (mRegisteredClients.add(binder, client.pid) >= 0) { binder->linkToDeath(this); } }
virtual status_t registerFlipListener(sp<IPageFlipListener> listener) { Parcel data, reply; data.writeInterfaceToken(IHwWidiPlane::getInterfaceDescriptor()); data.writeStrongBinder(listener->asBinder()); remote()->transact(REGISTER_FLIP_LISTENER, data, &reply); return reply.readInt32(); }
void BpGpsdService::hello(sp<IGpsdClient> aListener) { android::Parcel data, reply; android::String16 name(GPSD_SERVICE_NAME); data.writeInterfaceToken(name); data.writeStrongBinder(aListener->asBinder()); remote()->transact(BnGpsdService::GET_GPS, data, &reply); }
virtual void Advise(const sp<IChatSessionEvents>& eventSink) { Parcel data, reply; data.writeInterfaceToken(IChatSession::getInterfaceDescriptor()); // data.writeInt32((int32_t)getpid()); data.writeStrongBinder(eventSink->asBinder()); remote()->transact(ICS_Advise, data, &reply); }
void BatteryPropertiesRegistrar::registerListener(const sp<IBatteryPropertiesListener>& listener) { { if (listener == NULL) return; Mutex::Autolock _l(mRegistrationLock); // check whether this is a duplicate for (size_t i = 0; i < mListeners.size(); i++) { if (mListeners[i]->asBinder() == listener->asBinder()) { return; } } mListeners.add(listener); listener->asBinder()->linkToDeath(this); } healthd_battery_update(); }
// generic data callback from camera service to app with image data void dataCallback(int32_t msgType, const sp<IMemory>& imageData) { LOGV("dataCallback"); Parcel data, reply; data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor()); data.writeInt32(msgType); data.writeStrongBinder(imageData->asBinder()); remote()->transact(DATA_CALLBACK, data, &reply, IBinder::FLAG_ONEWAY); }
// pass the buffered ISurface to the camera service status_t setPreviewDisplay(const sp<ISurface>& surface) { LOGV("setPreviewDisplay"); Parcel data, reply; data.writeInterfaceToken(ICamera::getInterfaceDescriptor()); data.writeStrongBinder(surface->asBinder()); remote()->transact(SET_PREVIEW_DISPLAY, data, &reply); return reply.readInt32(); }
status_t setListener(const sp<IMediaPlayerClient>& listener) { LOGV("setListener(%p)", listener.get()); Parcel data, reply; data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor()); data.writeStrongBinder(listener->asBinder()); remote()->transact(SET_LISTENER, data, &reply); return reply.readInt32(); }
status_t setPreviewSurface(const sp<ISurface>& surface) { LOGV("setPreviewSurface(%p)", surface.get()); Parcel data, reply; data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor()); data.writeStrongBinder(surface->asBinder()); remote()->transact(SET_PREVIEW_SURFACE, data, &reply); return reply.readInt32(); }