bool NfcMessageHandler::WriteNDEFMessage(Parcel& aParcel, const CommandOptions& aOptions) { int recordCount = aOptions.mRecords.Length(); aParcel.writeInt32(recordCount); for (int i = 0; i < recordCount; i++) { const NDEFRecordStruct& record = aOptions.mRecords[i]; aParcel.writeInt32(static_cast<int32_t>(record.mTnf)); void* data; aParcel.writeInt32(record.mType.Length()); data = aParcel.writeInplace(record.mType.Length()); memcpy(data, record.mType.Elements(), record.mType.Length()); aParcel.writeInt32(record.mId.Length()); data = aParcel.writeInplace(record.mId.Length()); memcpy(data, record.mId.Elements(), record.mId.Length()); aParcel.writeInt32(record.mPayload.Length()); data = aParcel.writeInplace(record.mPayload.Length()); memcpy(data, record.mPayload.Elements(), record.mPayload.Length()); } return true; }
status_t BnAudioFlingerClient::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch (code) { case IO_CONFIG_CHANGED: { CHECK_INTERFACE(IAudioFlingerClient, data, reply); int event = data.readInt32(); audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32(); const void *param2 = NULL; AudioSystem::OutputDescriptor desc; uint32_t stream; if (event == AudioSystem::STREAM_CONFIG_CHANGED) { stream = data.readInt32(); param2 = &stream; ALOGV("STREAM_CONFIG_CHANGED stream %d", stream); } else if (event != AudioSystem::OUTPUT_CLOSED && event != AudioSystem::INPUT_CLOSED) { desc.samplingRate = data.readInt32(); desc.format = data.readInt32(); desc.channels = data.readInt32(); desc.frameCount = data.readInt32(); desc.latency = data.readInt32(); param2 = &desc; } ioConfigChanged(event, ioHandle, param2); return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
TEST_F(MotionEventTest, Parcel) { Parcel parcel; MotionEvent inEvent; initializeEventWithHistory(&inEvent); MotionEvent outEvent; // Round trip. inEvent.writeToParcel(&parcel); parcel.setDataPosition(0); outEvent.readFromParcel(&parcel); ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&outEvent)); }
static void android_os_Parcel_writeInterfaceToken(JNIEnv* env, jclass clazz, jint nativePtr, jstring name) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { // In the current implementation, the token is just the serialized interface name that // the caller expects to be invoking const jchar* str = env->GetStringCritical(name, 0); if (str != NULL) { parcel->writeInterfaceToken(String16((const char16_t*)str, env->GetStringLength(name))); env->ReleaseStringCritical(name, str); } } }
bool NfcMessageHandler::ReadNDEFMessage(const Parcel& aParcel, EventOptions& aOptions) { int32_t recordCount = aParcel.readInt32(); aOptions.mRecords.SetCapacity(recordCount); for (int i = 0; i < recordCount; i++) { int32_t tnf = aParcel.readInt32(); NDEFRecordStruct record; record.mTnf = static_cast<TNF>(tnf); int32_t typeLength = aParcel.readInt32(); record.mType.AppendElements( static_cast<const uint8_t*>(aParcel.readInplace(typeLength)), typeLength); int32_t idLength = aParcel.readInt32(); record.mId.AppendElements( static_cast<const uint8_t*>(aParcel.readInplace(idLength)), idLength); int32_t payloadLength = aParcel.readInt32(); record.mPayload.AppendElements( static_cast<const uint8_t*>(aParcel.readInplace(payloadLength)), payloadLength); aOptions.mRecords.AppendElement(record); } return true; }
status_t BnGraphicBufferAlloc::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { // codes that don't require permission check /* BufferReference just keeps a strong reference to a * GraphicBuffer until it is destroyed (that is, until * no local or remote process have a reference to it). */ class BufferReference : public BBinder { sp<GraphicBuffer> buffer; public: BufferReference(const sp<GraphicBuffer>& buffer) : buffer(buffer) { } }; switch(code) { case CREATE_GRAPHIC_BUFFER: { CHECK_INTERFACE(IGraphicBufferAlloc, data, reply); uint32_t w = data.readInt32(); uint32_t h = data.readInt32(); PixelFormat format = data.readInt32(); uint32_t usage = data.readInt32(); status_t error; sp<GraphicBuffer> result = createGraphicBuffer(w, h, format, usage, &error); reply->writeInt32(error); if (result != 0) { reply->write(*result); // We add a BufferReference to this parcel to make sure the // buffer stays alive until the GraphicBuffer object on // the other side has been created. // This is needed so that the buffer handle can be // registered before the buffer is destroyed on implementations // that do not use file-descriptors to track their buffers. reply->writeStrongBinder( new BufferReference(result) ); } return NO_ERROR; } break; case SET_GRAPHIC_BUFFER_SIZE: { CHECK_INTERFACE(IGraphicBufferAlloc, data, reply); int size = data.readInt32(); setGraphicBufferSize(size); return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
Surface::Surface(const Parcel& parcel, const sp<IBinder>& ref) : SurfaceTextureClient() { mSurface = interface_cast<ISurface>(ref); sp<IBinder> st_binder(parcel.readStrongBinder()); sp<ISurfaceTexture> st; if (st_binder != NULL) { st = interface_cast<ISurfaceTexture>(st_binder); } else if (mSurface != NULL) { st = mSurface->getSurfaceTexture(); } mIdentity = parcel.readInt32(); init(st); }
bool NfcMessageHandler::InitializeNotification(const Parcel& aParcel, EventOptions& aOptions) { aOptions.mStatus = aParcel.readInt32(); aOptions.mMajorVersion = aParcel.readInt32(); aOptions.mMinorVersion = aParcel.readInt32(); if (aOptions.mMajorVersion != NFCD_MAJOR_VERSION || aOptions.mMinorVersion != NFCD_MINOR_VERSION) { NMH_LOG("NFCD version mismatched. majorVersion: %d, minorVersion: %d", aOptions.mMajorVersion, aOptions.mMinorVersion); } return true; }
status_t DisplayState::read(const Parcel& input) { token = input.readStrongBinder(); surface = interface_cast<IGraphicBufferProducer>(input.readStrongBinder()); what = input.readUint32(); layerStack = input.readUint32(); orientation = input.readUint32(); input.read(viewport); input.read(frame); width = input.readUint32(); height = input.readUint32(); return NO_ERROR; }
status_t DisplayState::write(Parcel& output) const { output.writeStrongBinder(token); output.writeStrongBinder(IInterface::asBinder(surface)); output.writeUint32(what); output.writeUint32(layerStack); output.writeUint32(orientation); output.write(viewport); output.write(frame); output.writeUint32(width); output.writeUint32(height); return NO_ERROR; }
status_t onTransact(void *pthis, uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { #define GET_MEMORY 1 android::IBinder *that = (android::IBinder*)pthis; switch(code) { case GET_MEMORY: { //CHECK_INTERFACE(IMemory, data, reply); if (!data.checkInterface(that)) { return PERMISSION_DENIED; } ssize_t offset; size_t size; reply->writeStrongBinder( IInterface::asBinder(IMemory::asInterface(that)->getMemory(&offset, &size)) ); printf("%d,%d\n",offset,size); //important to OOB offset +=0x30000000; size +=0x60000000; reply->writeInt32(offset); reply->writeInt32(size); return NO_ERROR; } break; } return ((ONTRANSACT)g_original)(pthis,code,data,reply,flags); }
status_t BnGpsdService::onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) { sp<IGpsdClient> listener; printf("%s called, code: %d\n", __FUNCTION__, code); switch (code) { case GET_GPS: CHECK_INTERFACE(IGpsdService, data, reply); listener = interface_cast<IGpsdClient>(data.readStrongBinder()); listener->onChanged(234); // listener->show(); // reply->writeInt32(EX_NO_ERROR); return android::NO_ERROR; break; default: return BBinder::onTransact(code, data, reply, flags); } return android::NO_ERROR; }
bool NfcMessageHandler::TechDiscoveredNotification(const Parcel& aParcel, EventOptions& aOptions) { aOptions.mType = NS_ConvertUTF8toUTF16(kTechDiscoveredNotification); aOptions.mSessionId = aParcel.readInt32(); int32_t techCount = aParcel.readInt32(); aOptions.mTechList.AppendElements( static_cast<const uint8_t*>(aParcel.readInplace(techCount)), techCount); int32_t ndefMsgCount = aParcel.readInt32(); if (ndefMsgCount != 0) { ReadNDEFMessage(aParcel, aOptions); } return true; }
bool NfcMessageHandler::TechLostNotification(const Parcel& aParcel, EventOptions& aOptions) { aOptions.mType = NS_ConvertUTF8toUTF16(kTechLostNotification); aOptions.mSessionId = aParcel.readInt32(); return true; }
status_t DashPlayerDriver::invoke(const Parcel &request, Parcel *reply) { status_t ret = INVALID_OPERATION; int32_t methodId; ret = request.readInt32(&methodId); if (ret != OK) { ALOGE("Failed to retrieve the requested method to invoke"); return ret; } switch (methodId) { case KEY_DASH_ADAPTION_PROPERTIES: { ALOGE("calling KEY_DASH_GET_ADAPTION_PROPERTIES"); ret = getParameter(methodId,reply); break; } case KEY_DASH_SET_ADAPTION_PROPERTIES: { ALOGE("calling KEY_DASH_SET_ADAPTION_PROPERTIES"); int32_t val = 0; ret = setParameter(methodId,request); val = (ret == OK)? 1:0; reply->setDataPosition(0); reply->writeInt32(val); break; } default: { ALOGE("Invoke:unHandled requested method%d",methodId); ret = OK; break; } } return ret; }
status_t BnPageFlipListener::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case PAGE_FLIPPED: { CHECK_INTERFACE(IPageFlipListener, data, reply); int64_t time = data.readInt64(); uint32_t orientation = data.readInt32(); pageFlipped(time, orientation); reply->writeNoException(); } break; default: return BBinder::onTransact(code, data, reply, flags); } return NO_ERROR; }
bool NfcMessageHandler::GetDetailsNDEFResponse(const Parcel& aParcel, EventOptions& aOptions) { aOptions.mType = NS_ConvertUTF8toUTF16(kGetDetailsNDEFResponse); aOptions.mStatus = aParcel.readInt32(); aOptions.mSessionId = aParcel.readInt32(); int readOnly = aParcel.readInt32(); aOptions.mIsReadOnly = readOnly & 0xff; aOptions.mCanBeMadeReadOnly = (readOnly >> 8) & 0xff; aOptions.mMaxSupportedLength = aParcel.readInt32(); NS_ENSURE_TRUE(!mRequestIdQueue.IsEmpty(), false); aOptions.mRequestId = mRequestIdQueue[0]; mRequestIdQueue.RemoveElementAt(0); return true; }
status_t BnRTCNode::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case kIDTransport: { rtc_binder_data_t out; out.data = &data; out.reply = reply; // Reserved 4 bytes; reply->writeInt32(0); int ret = Transport(&out); int pos = reply->dataPosition(); reply->setDataPosition(0); reply->writeInt32(ret); reply->setDataPosition(pos); return NO_ERROR; } break; case kIDResigerObs: { CHECK_INTERFACE(IRTCNode, data, reply); sp<IBinder> handle = data.readStrongBinder(); sp<IRTCNode> node = interface_cast<IRTCNode>(handle); int ret = RegisterObserver(node); reply->writeInt32(ret); return NO_ERROR; }break; default: return BBinder::onTransact(code, data, reply, flags); } }
bool NfcMessageHandler::TransceiveRequest(Parcel& aParcel, const CommandOptions& aOptions) { aParcel.writeInt32(static_cast<int32_t>(NfcRequestType::Transceive)); aParcel.writeInt32(aOptions.mSessionId); aParcel.writeInt32(aOptions.mTechnology); uint32_t length = aOptions.mCommand.Length(); aParcel.writeInt32(length); void* data = aParcel.writeInplace(length); memcpy(data, aOptions.mCommand.Elements(), length); mRequestIdQueue.AppendElement(aOptions.mRequestId); return true; }
status_t MediaPlayer::setParameter(int key, const Parcel& request) { ALOGV("MediaPlayer::setParameter(%d)", key); status_t status = INVALID_OPERATION; Mutex::Autolock _l(mLock); if (checkStateForKeySet_l(key) != OK) { return status; } switch (key) { case KEY_PARAMETER_AUDIO_ATTRIBUTES: // save the marshalled audio attributes if (mAudioAttributesParcel != NULL) { delete mAudioAttributesParcel; }; mAudioAttributesParcel = new Parcel(); mAudioAttributesParcel->appendFrom(&request, 0, request.dataSize()); status = OK; break; default: ALOGV_IF(mPlayer == NULL, "setParameter: no active player"); break; } if (mPlayer != NULL) { status = mPlayer->setParameter(key, request); } return status; }
status_t BnRTCBinder::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case kDefault_CALL_ID: { rtc_binder_data_t out; out.data = &data; out.reply = reply; // Reserved 4 bytes reply->writeInt32(0); int ret = Transport(&out); int pos = reply->dataPosition(); reply->setDataPosition(0); // Rewrite 4 bytes reply->writeInt32(ret); reply->setDataPosition(pos); return NO_ERROR; } break; case kDefault_CreateNodeID: { CHECK_INTERFACE(IRTCBinder, data, reply); int type = 0; type = data.readInt32(); sp<IRTCNode> node = NewNode(type); #if ANDROID_SDK_VERSION >=23 reply->writeStrongBinder(node->asBinder(node.get())); #else reply->writeStrongBinder(node->asBinder()); #endif return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
bool NfcMessageHandler::InitializeNotification(const Parcel& aParcel, EventOptions& aOptions) { aOptions.mType = NS_ConvertUTF8toUTF16(kInitializedNotification); aOptions.mStatus = aParcel.readInt32(); aOptions.mMajorVersion = aParcel.readInt32(); aOptions.mMinorVersion = aParcel.readInt32(); if (aOptions.mMajorVersion != NFCD_MAJOR_VERSION && aOptions.mMinorVersion != NFCD_MAJOR_VERSION) { CHROMIUM_LOG("NFCD version mismatched. majorVersion: %d, minorVersion: %d", aOptions.mMajorVersion, aOptions.mMinorVersion); } return true; }
// Server function that handles parcels received from the client status_t AddIntsService::onTransact(uint32_t code, const Parcel &data, Parcel* reply, uint32_t /* flags */) { int val1, val2; status_t rv(0); int cpu; // If server bound to a particular CPU, check that // were executing on that CPU. if (cpu_ != unbound) { cpu = sched_getcpu(); if (cpu != cpu_) { cerr << "server onTransact on CPU " << cpu << " expected CPU " << cpu_ << endl; exit(20); } } // Perform the requested operation switch (code) { case ADD_INTS: val1 = data.readInt32(); val2 = data.readInt32(); reply->writeInt32(val1 + val2); break; default: cerr << "server onTransact unknown code, code: " << code << endl; exit(21); } return rv; }
bool NfcMessageHandler::GeneralResponse(const Parcel& aParcel, EventOptions& aOptions) { const char* type; NS_ENSURE_TRUE(!mPendingReqQueue.IsEmpty(), false); int pendingReq = mPendingReqQueue[0]; mPendingReqQueue.RemoveElementAt(0); switch (pendingReq) { case NfcRequest::WriteNDEFReq: type = kWriteNDEFResponse; break; case NfcRequest::MakeReadOnlyReq: type = kMakeReadOnlyResponse; break; case NfcRequest::FormatReq: type = kFormatResponse; break; default: NMH_LOG("Nfcd, unknown general response %d", pendingReq); return false; } aOptions.mType = NS_ConvertUTF8toUTF16(type); aOptions.mErrorCode = aParcel.readInt32(); aOptions.mSessionId = aParcel.readInt32(); NS_ENSURE_TRUE(!mRequestIdQueue.IsEmpty(), false); aOptions.mRequestId = mRequestIdQueue[0]; mRequestIdQueue.RemoveElementAt(0); return true; }
status_t BnMultiDisplayDecoderConfig::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch (code) { case MDS_SERVER_SET_DECODER_OUTPUT_RESOLUTION: { CHECK_INTERFACE(IMultiDisplayDecoderConfig, data, reply); int sessionId = data.readInt32(); int32_t width = data.readInt32(); int32_t height = data.readInt32(); status_t ret = setDecoderOutputResolution(sessionId, width, height); reply->writeInt32(ret); return NO_ERROR; } break; } // switch return BBinder::onTransact(code, data, reply, flags); }
status_t BnPeriperalManagerCb::onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) { switch (code) { case NOTIFY_CALLBACK: { CHECK_INTERFACE(IPeriperalManagerCb, data, reply); int32_t event = data.readInt32(); notifyCallback(event); data.readExceptionCode(); return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
status_t BnSensorEventConnection::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case GET_SENSOR_CHANNEL: { CHECK_INTERFACE(ISensorEventConnection, data, reply); sp<BitTube> channel(getSensorChannel()); channel->writeToParcel(reply); return NO_ERROR; } case ENABLE_DISABLE: { CHECK_INTERFACE(ISensorEventConnection, data, reply); int handle = data.readInt32(); int enabled = data.readInt32(); nsecs_t samplingPeriodNs = data.readInt64(); nsecs_t maxBatchReportLatencyNs = data.readInt64(); int reservedFlags = data.readInt32(); status_t result = enableDisable(handle, enabled, samplingPeriodNs, maxBatchReportLatencyNs, reservedFlags); reply->writeInt32(result); return NO_ERROR; } case SET_EVENT_RATE: { CHECK_INTERFACE(ISensorEventConnection, data, reply); int handle = data.readInt32(); nsecs_t ns = data.readInt64(); status_t result = setEventRate(handle, ns); reply->writeInt32(result); return NO_ERROR; } case FLUSH_SENSOR: { CHECK_INTERFACE(ISensorEventConnection, data, reply); status_t result = flush(); reply->writeInt32(result); return NO_ERROR; } case CONFIGURE_CHANNEL: { CHECK_INTERFACE(ISensorEventConnection, data, reply); int handle = data.readInt32(); int rateLevel = data.readInt32(); status_t result = configureChannel(handle, rateLevel); reply->writeInt32(result); return NO_ERROR; } case DESTROY: { destroy(); return NO_ERROR; } } return BBinder::onTransact(code, data, reply, flags); }
status_t CameraService::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { // Permission checks switch (code) { //!++ #ifdef MTK_CAMERA_BSP_SUPPORT case BnCameraService::GET_PROPERTY: { CHECK_INTERFACE(ICameraService, data, reply); String8 const key = data.readString8(); String8 value; status_t const status = getProperty(key, value); reply->writeString8(value); reply->writeInt32(status); ALOGD("[GET_PROPERTY] - pid=%d, uid=%d (%s)=(%s) \n", getCallingPid(), getCallingUid(), key.string(), value.string()); return OK; } case BnCameraService::SET_PROPERTY: { CHECK_INTERFACE(ICameraService, data, reply); String8 const key = data.readString8(); String8 const value = data.readString8(); status_t const status = setProperty(key, value); reply->writeInt32(status); ALOGD("[SET_PROPERTY] - pid=%d, uid=%d (%s)=(%s) \n", getCallingPid(), getCallingUid(), key.string(), value.string()); return OK; } #endif //MTK_CAMERA_BSP_SUPPORT //!-- case BnCameraService::CONNECT: const int pid = getCallingPid(); const int self_pid = getpid(); if (pid != self_pid) { // we're called from a different process, do the real check if (!checkCallingPermission( String16("android.permission.CAMERA"))) { const int uid = getCallingUid(); ALOGE("Permission Denial: " "can't use the camera pid=%d, uid=%d", pid, uid); return PERMISSION_DENIED; } } break; } return BnCameraService::onTransact(code, data, reply, flags); }
status_t GonkSchedulePolicyService::onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch (code) { case REQUEST_PRIORITY_TRANSACTION: { CHECK_INTERFACE(ISchedulePolicyService, data, reply); int32_t pid = data.readInt32(); int32_t tid = data.readInt32(); int32_t prio = data.readInt32(); requestPriority(pid, tid, prio); return NO_ERROR; break; } default: return BBinder::onTransact(code, data, reply, flags); } }
static void android_view_InputChannel_nativeWriteToParcel(JNIEnv* env, jobject obj, jobject parcelObj) { Parcel* parcel = parcelForJavaObject(env, parcelObj); if (parcel) { NativeInputChannel* nativeInputChannel = android_view_InputChannel_getNativeInputChannel(env, obj); if (nativeInputChannel) { sp<InputChannel> inputChannel = nativeInputChannel->getInputChannel(); parcel->writeInt32(1); parcel->writeString8(String8(inputChannel->getName().c_str())); parcel->writeDupFileDescriptor(inputChannel->getFd()); } else { parcel->writeInt32(0); } } }