RILCall(const Parcel& data) {
state = static_cast<RIL_CallState>(data.readInt32());
index = data.readInt32();
toa = data.readInt32();
isMpty = (data.readInt32() != 0);
isMT = (data.readInt32() != 0);
als = data.readInt32();
isVoice = data.readInt32();
isVoicePrivacy = data.readInt32();
number = data.readString16();
numberPresentation = data.readInt32();
name = data.readString16();
namePresentation = data.readInt32();
hasUusInfo = (data.readInt32() != 0);
if (hasUusInfo) {
// ### TODO: Check this with something that has UUS
uusType = static_cast<RIL_UUS_Type>(data.readInt32());
uusDcs = static_cast<RIL_UUS_DCS>(data.readInt32());
uusLength = data.readInt32();
uusData = NULL;
if (uusLength > 0) {
uusData = new char[uusLength];
data.read(uusData, uusLength);
}
}
}
status_t BnSensorServer::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case GET_SENSOR_LIST: {
CHECK_INTERFACE(ISensorServer, data, reply);
const String16& opPackageName = data.readString16();
Vector<Sensor> v(getSensorList(opPackageName));
size_t n = v.size();
reply->writeUint32(static_cast<uint32_t>(n));
for (size_t i = 0; i < n; i++) {
reply->write(v[i]);
}
return NO_ERROR;
}
case CREATE_SENSOR_EVENT_CONNECTION: {
CHECK_INTERFACE(ISensorServer, data, reply);
String8 packageName = data.readString8();
int32_t mode = data.readInt32();
const String16& opPackageName = data.readString16();
sp<ISensorEventConnection> connection(createSensorEventConnection(packageName, mode,
opPackageName));
reply->writeStrongBinder(IInterface::asBinder(connection));
return NO_ERROR;
}
case ENABLE_DATA_INJECTION: {
CHECK_INTERFACE(ISensorServer, data, reply);
int32_t ret = isDataInjectionEnabled();
reply->writeInt32(static_cast<int32_t>(ret));
return NO_ERROR;
}
}
return BBinder::onTransact(code, data, reply, flags);
}
// Notes about data transaction:
// Java Binder Wrapper call readInt32 before reading return data
// It treet this in value as exception code
// OnTransact method support this feature
status_t BnOpenCVEngine::onTransact(uint32_t code, const Parcel& data, android::Parcel* reply, uint32_t flags)
{
LOGD("OpenCVEngine::OnTransact(%u,%u)", code, flags);
switch(code)
{
case OCVE_GET_ENGINE_VERSION:
{
LOGD("OpenCVEngine OCVE_GET_ENGINE_VERSION request");
CHECK_INTERFACE(IOpenCVEngine, data, reply);
LOGD("OpenCVEngine::GetVersion()");
reply->writeInt32(0);
return reply->writeInt32(GetVersion());
} break;
case OCVE_GET_LIB_PATH_BY_VERSION:
{
LOGD("OpenCVEngine OCVE_GET_LIB_PATH_BY_VERSION request");
CHECK_INTERFACE(IOpenCVEngine, data, reply);
const String16 version = data.readString16();
LOGD("OpenCVEngine::GetLibPathByVersion(%s)", String8(version).string());
String16 path = GetLibPathByVersion(version);
reply->writeInt32(0);
return reply->writeString16(path);
} break;
case OCVE_GET_LIB_LIST:
{
LOGD("OpenCVEngine OCVE_GET_LIB_LIST request");
CHECK_INTERFACE(IOpenCVEngine, data, reply);
const String16 version = data.readString16();
LOGD("OpenCVEngine::GetLibraryList(%s)", String8(version).string());
String16 path = GetLibraryList(version);
reply->writeInt32(0);
return reply->writeString16(path);
} break;
case OCVE_INSTALL_VERSION:
{
LOGD("OpenCVEngine OCVE_INSTALL_VERSION request");
CHECK_INTERFACE(IOpenCVEngine, data, reply);
const String16 version = data.readString16();
LOGD("OpenCVEngine::InstallVersion(%s)", String8(version).string());
bool result = InstallVersion(version);
reply->writeInt32(0);
int res = reply->writeInt32(static_cast<int32_t>(result));
LOGD("InstallVersion call to Binder finished with res %d", res);
return res;
} break;
default:
{
LOGD("OpenCVEngine unknown request");
return BBinder::onTransact(code, data, reply, flags);
}
}
return android::NO_ERROR;
}
status_t BBinder::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t /*flags*/)
{
switch (code) {
case INTERFACE_TRANSACTION:
reply->writeString16(getInterfaceDescriptor());
return NO_ERROR;
case DUMP_TRANSACTION: {
int fd = data.readFileDescriptor();
int argc = data.readInt32();
Vector<String16> args;
for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
args.add(data.readString16());
}
return dump(fd, args);
}
case SHELL_COMMAND_TRANSACTION: {
int in = data.readFileDescriptor();
int out = data.readFileDescriptor();
int err = data.readFileDescriptor();
int argc = data.readInt32();
Vector<String16> args;
for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
args.add(data.readString16());
}
sp<IShellCallback> shellCallback = IShellCallback::asInterface(
data.readStrongBinder());
sp<IResultReceiver> resultReceiver = IResultReceiver::asInterface(
data.readStrongBinder());
// XXX can't add virtuals until binaries are updated.
//return shellCommand(in, out, err, args, resultReceiver);
(void)in;
(void)out;
(void)err;
if (resultReceiver != NULL) {
resultReceiver->send(INVALID_OPERATION);
}
return NO_ERROR;
}
case SYSPROPS_TRANSACTION: {
report_sysprop_change();
return NO_ERROR;
}
default:
return UNKNOWN_TRANSACTION;
}
}
status_t BBinder::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case INTERFACE_TRANSACTION:
reply->writeString16(getInterfaceDescriptor());
return NO_ERROR;
case DUMP_TRANSACTION: {
int fd = data.readFileDescriptor();
int argc = data.readInt32();
Vector<String16> args;
for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
args.add(data.readString16());
}
return dump(fd, args);
}
case SYSPROPS_TRANSACTION: {
report_sysprop_change();
return NO_ERROR;
}
default:
return UNKNOWN_TRANSACTION;
}
}
status_t Status::readFromParcel(const Parcel& parcel) {
status_t status = parcel.readInt32(&mException);
if (status != OK) {
setFromStatusT(status);
return status;
}
// Skip over fat response headers. Not used (or propagated) in native code.
if (mException == EX_HAS_REPLY_HEADER) {
// Note that the header size includes the 4 byte size field.
const int32_t header_start = parcel.dataPosition();
int32_t header_size;
status = parcel.readInt32(&header_size);
if (status != OK) {
setFromStatusT(status);
return status;
}
parcel.setDataPosition(header_start + header_size);
// And fat response headers are currently only used when there are no
// exceptions, so act like there was no error.
mException = EX_NONE;
}
if (mException == EX_NONE) {
return status;
}
// The remote threw an exception. Get the message back.
mMessage = String8(parcel.readString16());
return status;
}
status_t ArcHmbPlayerBinder::onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
ALOGE("ArcHmbPlayerBinder::onTransact(%i) %i", code, flags);
/*
* Before executing actual method, check whether the RPC are from expected client.
* Client will write interface token, to identify interface to which those methods
* belong.
*/
if (!data.enforceInterface(ArcHmbPlayerInterface::DESCRIPTOR)) {
ALOGE("failed to check Interface, you might call wrong service, this is for '%s'",
String8(ArcHmbPlayerInterface::DESCRIPTOR).string());
return BAD_TYPE;
}
data.print(aout);
endl(aout);
switch(code) {
case ArcHmbPlayerInterface::PRINT: {
String16 msg = data.readString16();
print(String8(msg).string());
return NO_ERROR;
}
case ArcHmbPlayerInterface::ADD: {
int32_t a = data.readInt32();
int32_t b = data.readInt32();
int32_t sum = add(a, b);
ALOGE("ArcHmbPlayerBinder:onTransact add(%i, %i) = %i", a, b, sum);
reply->print(aout); endl(aout);
reply->writeInt32(sum);
return NO_ERROR;
}
default:
ALOGE("ArcHmbPlayerBinder, bad requesting code, no match found");
}
return BBinder::onTransact(code, data, reply, flags);
}
/* BnHelloWorld */
status_t BnHelloWorld::onTransact(uint32_t code,
const Parcel &data,
Parcel *reply,
uint32_t flags)
{
LOGE("OnTransact(%u,%u)", code, flags);
CHECK_INTERFACE(IHelloWorld, data, reply);
switch(code) {
case HW_HELLOTHERE: {
/**
* Checking permissions is always a good idea.
*
* Note that the native client will also be granted these permissions in two cases
* 1) you run the client code as root or system user.
* 2) you run the client code as user who was granted this permission.
* @see http://github.com/keesj/gomo/wiki/AndroidSecurity for more information
**/
if (checkCallingPermission(String16("org.credil.helloworldservice.permissions.CALL_HELLOTHERE")) == false){
return PERMISSION_DENIED;
}
String16 str = data.readString16();
hellothere(String8(str).string());
///reply->writeString16(str);
return NO_ERROR;
} break;
case RETURN_INT_SHANQUAN:{
if (checkCallingPermission(String16("org.credil.helloworldservice.permissions.CALL_HELLOTHERE")) == false){
return PERMISSION_DENIED;
}
String16 str = data.readString16();
helloint(String8(str).string());
int tmp= str.size();
printf("servie str.size():%i\n",tmp);
status_t status = reply->writeInt32(tmp);
if( status == NO_ERROR)
printf("file:%s,line:%i,no error\n",__FILE__,__LINE__);
else
printf("file:%s,line:%i, error\n",__FILE__,__LINE__);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
return NO_ERROR;
}
status_t BnServiceManager::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
//printf("ServiceManager received: "); data.print();
switch(code) {
case GET_SERVICE_TRANSACTION: {
CHECK_INTERFACE(IServiceManager, data, reply);
String16 which = data.readString16();
sp<IBinder> b = const_cast<BnServiceManager*>(this)->getService(which);
reply->writeStrongBinder(b);
return NO_ERROR;
} break;
case CHECK_SERVICE_TRANSACTION: {
CHECK_INTERFACE(IServiceManager, data, reply);
String16 which = data.readString16();
sp<IBinder> b = const_cast<BnServiceManager*>(this)->checkService(which);
reply->writeStrongBinder(b);
return NO_ERROR;
} break;
case ADD_SERVICE_TRANSACTION: {
CHECK_INTERFACE(IServiceManager, data, reply);
String16 which = data.readString16();
sp<IBinder> b = data.readStrongBinder();
status_t err = addService(which, b);
reply->writeInt32(err);
return NO_ERROR;
} break;
case LIST_SERVICES_TRANSACTION: {
CHECK_INTERFACE(IServiceManager, data, reply);
Vector<String16> list = listServices();
const size_t N = list.size();
reply->writeInt32(N);
for (size_t i=0; i<N; i++) {
reply->writeString16(list[i]);
}
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
void PhoneMachine::receiveUnsolicited(const Parcel& data)
{
int message = data.readInt32();
int ivalue = 0;
String16 svalue;
UnsolicitedMessages flags = UM_NONE;
MAPTYPE *pmap = eventmap;
SLOGD("<<< Unsolicited message=%s [%d]\n", rilMessageStr(message), message);
while (pmap->flags != UM_NONE && message != pmap->message)
pmap++;
if (pmap->flags)
flags = pmap->flags;
switch (message) {
case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
ivalue = data.readInt32();
SLOGD(" RIL Radio state changed to %d\n", ivalue);
if (ivalue == RADIO_STATE_OFF) {
RILRequest * request = new RILRequest(NULL, -1, RIL_REQUEST_RADIO_POWER);
request->writeInt(1); // One value
request->writeInt(1); // Turn the radio on
sendToRILD(request);
}
break;
case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED:
sendToRILD(new RILRequest(NULL, -1, RIL_REQUEST_GET_CURRENT_CALLS));
break;
case RIL_UNSOL_NITZ_TIME_RECEIVED:
svalue = data.readString16();
break;
case RIL_UNSOL_SIGNAL_STRENGTH:
ivalue = data.readInt32();
SLOGD(" Signal strength changed %d\n", ivalue);
break;
#if defined(SHORT_PLATFORM_VERSION) && (SHORT_PLATFORM_VERSION == 23)
#else
case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED:
break;
case RIL_UNSOL_RIL_CONNECTED: {
int n = data.readInt32(); // Number of integers
ivalue = data.readInt32(); // RIL Version
SLOGD(" RIL connected version=%d\n", ivalue);
break;
}
#endif
default:
SLOGD("### Unhandled unsolicited message received from RIL: %d\n", message);
break;
}
if (flags)
mService->broadcastUnsolicited(flags, message, ivalue, svalue);
}
static jint _setResult(JNIEnv* env, jobject obj, jobject java_result)
{
sp<DMRDeviceClient> dmr_device = getDMRDeviceClient(env, obj);
if (dmr_device == NULL ) {
return UNKNOWN_ERROR;
}
Parcel *result = parcelForJavaObject(env, java_result);
String8 order(result->readString16());
return dmr_device->setResult(order);
}
status_t BnChatSessionManager::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
status_t result = 0x80000000;
_TRACE("ChatSessionManager::onTransact[pid:%d] >>:code 0x%x",GetCallerPID(),code); //data.print();
switch(code) {
case ICSM_GetSessionNames: {
CHECK_INTERFACE(IChatSessionManager, data, reply);
Vector<String16> list = GetSessionNames();
const size_t N = list.size();
reply->writeInt32(N);
for (size_t i=0; i<N; i++) {
reply->writeString16(list[i]);
}
result = NO_ERROR;
} break;
case ICSM_FindSession: {
CHECK_INTERFACE(IChatSessionManager, data, reply);
String16 name = data.readString16();
BOOL bDontCreate = data.readInt32();
BOOL bAllowAnonymousAccess = data.readInt32();
sp<IChatSession> b = FindSession(name,bDontCreate,bAllowAnonymousAccess);
reply->writeStrongBinder(b->asBinder());
result = NO_ERROR;
} break;
case ICSM_DeleteSession: {
CHECK_INTERFACE(IChatSessionManager, data, reply);
String16 name = data.readString16();
status_t err = DeleteSession(name);
reply->writeInt32(err);
result = NO_ERROR;
} break;
default:
result = BBinder::onTransact(code, data, reply, flags);
}
_TRACE("ChatSessionManager::onTransact[pid:%d] <<:result %d",GetCallerPID(),result); //reply.print();
return result;
}
status_t BnMountServiceListener::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case TRANSACTION_onUsbMassStorageConnectionChanged: {
CHECK_INTERFACE(IMountServiceListener, data, reply);
bool connected = (data.readInt32() != 0);
onUsbMassStorageConnectionChanged(connected);
reply->writeNoException();
return NO_ERROR;
} break;
case TRANSACTION_onStorageStateChanged: {
CHECK_INTERFACE(IMountServiceListener, data, reply);
String16 path = data.readString16();
String16 oldState = data.readString16();
String16 newState = data.readString16();
onStorageStateChanged(path, oldState, newState);
reply->writeNoException();
return NO_ERROR;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t Service::onTransact(uint32_t code,
const Parcel &data,
Parcel *reply,
uint32_t flags)
{
CHECK_INTERFACE(IHelloWorld, data, reply);
if (code == HW_SAYHELLO)
{
if (checkCallingPermission(String16("cn.bjtu.helloworldservice.permissions.CALL_SAYHELLO")) == false)
return PERMISSION_DENIED;
String16 str = data.readString16();
sayHello(String8(str).string());
return NO_ERROR;
}
return BBinder::onTransact(code, data, reply, flags);
}
status_t PVPlayerExtensionHandler::queryExtnIface(const Parcel& data, Parcel& reply)
{
String16 iface= data.readString16();
IDispatch* extPtr = NULL;
extPtr = mPVPlayerExtnIfaceRegistry.createExtension(iface,*this);
if (extPtr){
LOGV("PVPlayerExtensionHandler::queryExtnIface extIface=%d",(int32_t)extPtr);
status_t status = reply.writeInt32(NO_ERROR);
if (NO_ERROR != status){
return INVALID_OPERATION;
}
iExtensionInstancesList.add_element(extPtr);
return reply.writeInt32((int32_t)extPtr);
} else {
return reply.writeInt32(NAME_NOT_FOUND);
}
}
status_t BnPermissionController::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
//printf("PermissionController received: "); data.print();
switch(code) {
case CHECK_PERMISSION_TRANSACTION: {
CHECK_INTERFACE(IPermissionController, data, reply);
String16 permission = data.readString16();
int32_t pid = data.readInt32();
int32_t uid = data.readInt32();
bool res = checkPermission(permission, pid, uid);
// write exception
reply->writeInt32(0);
reply->writeInt32(res ? 1 : 0);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnChatSessionEvents::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
status_t result = 0x80000000;
_TRACE("ChatSessionEvents::onTransact[pid:%d] >>:code 0x%x",GetCallerPID(),code); //data.print();
switch(code) {
case ICSE_OnNewUser: {
CHECK_INTERFACE(IChatSessionEvents, data, reply);
String16 name = data.readString16();
OnNewUser(name);
result = NO_ERROR;
} break;
case ICSE_OnUserLeft: {
CHECK_INTERFACE(IChatSessionEvents, data, reply);
String16 name = data.readString16();
OnUserLeft(name);
result = NO_ERROR;
} break;
case ICSE_OnNewStatement: {
CHECK_INTERFACE(IChatSessionEvents, data, reply);
String16 name = data.readString16();
String16 statement = data.readString16();
OnNewStatement(name,statement);
result = NO_ERROR;
} break;
case ICSE_Sync_OnNewStatement: {
CHECK_INTERFACE(IChatSessionEvents, data, reply);
String16 name = data.readString16();
String16 statement = data.readString16();
status_t err = Sync_OnNewStatement(name,statement);
reply->writeInt32(err);
result = NO_ERROR;
} break;
case ICSE_GetUserName: {
CHECK_INTERFACE(IChatSessionEvents, data, reply);
String16 name = GetUserName();
reply->writeString16(name);
result = NO_ERROR;
} break;
default:
result = BBinder::onTransact(code, data, reply, flags);
}
_TRACE("ChatSessionEvents::onTransact[pid:%d] <<:result %d",GetCallerPID(),result); //reply.print();
return result;
}
status_t BnCameraService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case GET_NUMBER_OF_CAMERAS: {
CHECK_INTERFACE(ICameraService, data, reply);
reply->writeNoException();
reply->writeInt32(getNumberOfCameras());
return NO_ERROR;
} break;
case GET_CAMERA_INFO: {
CHECK_INTERFACE(ICameraService, data, reply);
CameraInfo cameraInfo = CameraInfo();
memset(&cameraInfo, 0, sizeof(cameraInfo));
status_t result = getCameraInfo(data.readInt32(), &cameraInfo);
reply->writeNoException();
reply->writeInt32(result);
// Fake a parcelable object here
reply->writeInt32(1); // means the parcelable is included
reply->writeInt32(cameraInfo.facing);
reply->writeInt32(cameraInfo.orientation);
return NO_ERROR;
} break;
case GET_CAMERA_CHARACTERISTICS: {
CHECK_INTERFACE(ICameraService, data, reply);
CameraMetadata info;
status_t result = getCameraCharacteristics(data.readInt32(), &info);
reply->writeNoException();
reply->writeInt32(result);
// out-variables are after exception and return value
reply->writeInt32(1); // means the parcelable is included
info.writeToParcel(reply);
return NO_ERROR;
} break;
case CONNECT: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<ICameraClient> cameraClient =
interface_cast<ICameraClient>(data.readStrongBinder());
int32_t cameraId = data.readInt32();
const String16 clientName = data.readString16();
int32_t clientUid = data.readInt32();
sp<ICamera> camera;
status_t status = connect(cameraClient, cameraId,
clientName, clientUid, /*out*/ camera);
reply->writeNoException();
reply->writeInt32(status);
if (camera != NULL) {
reply->writeInt32(1);
reply->writeStrongBinder(camera->asBinder());
} else {
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case CONNECT_PRO: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<IProCameraCallbacks> cameraClient =
interface_cast<IProCameraCallbacks>(data.readStrongBinder());
int32_t cameraId = data.readInt32();
const String16 clientName = data.readString16();
int32_t clientUid = data.readInt32();
sp<IProCameraUser> camera;
status_t status = connectPro(cameraClient, cameraId,
clientName, clientUid, /*out*/ camera);
reply->writeNoException();
reply->writeInt32(status);
if (camera != NULL) {
reply->writeInt32(1);
reply->writeStrongBinder(camera->asBinder());
} else {
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case CONNECT_DEVICE: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<ICameraDeviceCallbacks> cameraClient =
interface_cast<ICameraDeviceCallbacks>(data.readStrongBinder());
int32_t cameraId = data.readInt32();
const String16 clientName = data.readString16();
int32_t clientUid = data.readInt32();
sp<ICameraDeviceUser> camera;
status_t status = connectDevice(cameraClient, cameraId,
clientName, clientUid, /*out*/ camera);
reply->writeNoException();
reply->writeInt32(status);
if (camera != NULL) {
reply->writeInt32(1);
reply->writeStrongBinder(camera->asBinder());
} else {
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case ADD_LISTENER: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<ICameraServiceListener> listener =
interface_cast<ICameraServiceListener>(data.readStrongBinder());
reply->writeNoException();
reply->writeInt32(addListener(listener));
return NO_ERROR;
} break;
case REMOVE_LISTENER: {
CHECK_INTERFACE(ICameraService, data, reply);
sp<ICameraServiceListener> listener =
interface_cast<ICameraServiceListener>(data.readStrongBinder());
reply->writeNoException();
reply->writeInt32(removeListener(listener));
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnChatSession::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
status_t result = 0x80000000;
_TRACE("ChatSession::onTransact[pid:%d] >>:code 0x%x",GetCallerPID(),code); //data.print();
switch(code) {
case ICS_getName: {
CHECK_INTERFACE(IChatSession, data, reply);
//CHECKOUT_CALLER(data);
String16 name = const_cast<BnChatSession*>(this)->GetName();
reply->writeString16(name);
result = NO_ERROR;
} break;
case ICS_GetStatements: {
CHECK_INTERFACE(IChatSession, data, reply);
//CHECKOUT_CALLER(data);
Vector<String16> list = GetStatements();
const size_t N = list.size();
reply->writeInt32(N);
_TRACE("GetStatements num %u",(unsigned int)N);
for (size_t i=0; i<N; i++) {
reply->writeString16(list[i]);
}
result = NO_ERROR;
} break;
case ICS_Say: {
CHECK_INTERFACE(IChatSession, data, reply);
//CHECKOUT_CALLER(data);
String16 statement = data.readString16();
status_t err = Say(statement);
reply->writeInt32(err);
result = NO_ERROR;
} break;
case ICS_AsyncSay: {
CHECK_INTERFACE(IChatSession, data, reply);
//CHECKOUT_CALLER(data);
String16 statement = data.readString16();
AsyncSay(statement);
result = NO_ERROR;
} break;
case ICS_Advise: {
CHECK_INTERFACE(IChatSession, data, reply);
sp<IChatSessionEvents> eventSink = interface_cast<IChatSessionEvents>(data.readStrongBinder());
Advise(eventSink);
result = NO_ERROR;
} break;
case ICS_Unadvise: {
CHECK_INTERFACE(IChatSession, data, reply);
//CHECKOUT_CALLER(data);
status_t err = Unadvise();
reply->writeInt32(err);
result = NO_ERROR;
} break;
default:
result = BBinder::onTransact(code, data, reply, flags);
}
_TRACE("ChatSession::onTransact[pid:%d] <<:result %d",GetCallerPID(),result); //reply.print();
return result;
}
status_t BnPermissionController::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case CHECK_PERMISSION_TRANSACTION: {
CHECK_INTERFACE(IPermissionController, data, reply);
String16 permission = data.readString16();
int32_t pid = data.readInt32();
int32_t uid = data.readInt32();
bool res = checkPermission(permission, pid, uid);
reply->writeNoException();
reply->writeInt32(res ? 1 : 0);
return NO_ERROR;
} break;
case NOTE_OP_TRANSACTION: {
CHECK_INTERFACE(IPermissionController, data, reply);
String16 op = data.readString16();
int32_t uid = data.readInt32();
String16 packageName = data.readString16();
int32_t res = noteOp(op, uid, packageName);
reply->writeNoException();
reply->writeInt32(res);
return NO_ERROR;
} break;
case GET_PACKAGES_FOR_UID_TRANSACTION: {
CHECK_INTERFACE(IPermissionController, data, reply);
int32_t uid = data.readInt32();
Vector<String16> packages;
getPackagesForUid(uid, packages);
reply->writeNoException();
size_t size = packages.size();
reply->writeInt32(size);
for (size_t i = 0; i < size; i++) {
reply->writeString16(packages[i]);
}
return NO_ERROR;
} break;
case IS_RUNTIME_PERMISSION_TRANSACTION: {
CHECK_INTERFACE(IPermissionController, data, reply);
String16 permission = data.readString16();
const bool res = isRuntimePermission(permission);
reply->writeNoException();
reply->writeInt32(res ? 1 : 0);
return NO_ERROR;
} break;
case GET_PACKAGE_UID_TRANSACTION: {
CHECK_INTERFACE(IPermissionController, data, reply);
String16 package = data.readString16();
int flags = data.readInt32();
const int uid = getPackageUid(package, flags);
reply->writeNoException();
reply->writeInt32(uid);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnAppOpsService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
//printf("AppOpsService received: "); data.print();
switch(code) {
case CHECK_OPERATION_TRANSACTION: {
CHECK_INTERFACE(IAppOpsService, data, reply);
int32_t code = data.readInt32();
int32_t uid = data.readInt32();
String16 packageName = data.readString16();
int32_t res = checkOperation(code, uid, packageName);
reply->writeNoException();
reply->writeInt32(res);
return NO_ERROR;
} break;
case NOTE_OPERATION_TRANSACTION: {
CHECK_INTERFACE(IAppOpsService, data, reply);
int32_t code = data.readInt32();
int32_t uid = data.readInt32();
String16 packageName = data.readString16();
int32_t res = noteOperation(code, uid, packageName);
reply->writeNoException();
reply->writeInt32(res);
return NO_ERROR;
} break;
case START_OPERATION_TRANSACTION: {
CHECK_INTERFACE(IAppOpsService, data, reply);
sp<IBinder> token = data.readStrongBinder();
int32_t code = data.readInt32();
int32_t uid = data.readInt32();
String16 packageName = data.readString16();
int32_t res = startOperation(token, code, uid, packageName);
reply->writeNoException();
reply->writeInt32(res);
return NO_ERROR;
} break;
case FINISH_OPERATION_TRANSACTION: {
CHECK_INTERFACE(IAppOpsService, data, reply);
sp<IBinder> token = data.readStrongBinder();
int32_t code = data.readInt32();
int32_t uid = data.readInt32();
String16 packageName = data.readString16();
finishOperation(token, code, uid, packageName);
reply->writeNoException();
return NO_ERROR;
} break;
case START_WATCHING_MODE_TRANSACTION: {
CHECK_INTERFACE(IAppOpsService, data, reply);
int32_t op = data.readInt32();
String16 packageName = data.readString16();
sp<IAppOpsCallback> callback = interface_cast<IAppOpsCallback>(data.readStrongBinder());
startWatchingMode(op, packageName, callback);
reply->writeNoException();
return NO_ERROR;
} break;
case STOP_WATCHING_MODE_TRANSACTION: {
CHECK_INTERFACE(IAppOpsService, data, reply);
sp<IAppOpsCallback> callback = interface_cast<IAppOpsCallback>(data.readStrongBinder());
stopWatchingMode(callback);
reply->writeNoException();
return NO_ERROR;
} break;
case GET_TOKEN_TRANSACTION: {
CHECK_INTERFACE(IAppOpsService, data, reply);
sp<IBinder> clientToken = data.readStrongBinder();
sp<IBinder> token = getToken(clientToken);
reply->writeNoException();
reply->writeStrongBinder(token);
return NO_ERROR;
} break;
case PERMISSION_TO_OP_CODE_TRANSACTION: {
CHECK_INTERFACE(IAppOpsService, data, reply);
String16 permission = data.readString16();
const int32_t opCode = permissionToOpCode(permission);
reply->writeNoException();
reply->writeInt32(opCode);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnMMSdkService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case CONNECT_IMAGETRANSFORMUSER: {
CHECK_INTERFACE(IMMSdkService, data, reply);
sp<NSImageTransform::IImageTransformUser> client;
status_t status = connectImageTransformUser(client);
reply->writeNoException();
reply->writeInt32(status);
if (client != 0)
{
reply->writeInt32(1);
reply->writeStrongBinder(client->asBinder());
}
else
{
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case CONNECT_EFFECT: {
CHECK_INTERFACE(IMMSdkService, data, reply);
String16 clientName(data.readString16());
sp<NSEffect::IEffectUser> client;
status_t status = connectEffect(String16(clientName), client);
reply->writeNoException();
reply->writeInt32(status);
if (client != 0)
{
reply->writeInt32(1);
reply->writeStrongBinder(client->asBinder());
}
else
{
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case CONNECT_GESTURE: {
CHECK_INTERFACE(IMMSdkService, data, reply);
sp<NSGesture::IGestureUser> client;
status_t status = connectGesture(client);
reply->writeNoException();
reply->writeInt32(status);
if (client != 0)
{
reply->writeInt32(1);
reply->writeStrongBinder(client->asBinder());
}
else
{
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case CONNECT_HEARTRATE: {
CHECK_INTERFACE(IMMSdkService, data, reply);
sp<NSHeartrate::IHeartrateUser> client;
status_t status = connectHeartrate(client);
reply->writeNoException();
reply->writeInt32(status);
if (client != 0)
{
reply->writeInt32(1);
reply->writeStrongBinder(client->asBinder());
}
else
{
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case DISCONNECT_HEARTRATE: {
CHECK_INTERFACE(IMMSdkService, data, reply);
status_t status = disconnectHeartrate();
reply->writeNoException();
reply->writeInt32(status);
return status;
} break;
case GET_MMSDK_FEAUTRE_MANAGER: {
CHECK_INTERFACE(IMMSdkService, data, reply);
sp<NSCam::IFeatureManager> client;
status_t status = connectFeatureManager(client);
reply->writeNoException();
reply->writeInt32(status);
if (client != 0)
{
reply->writeInt32(1);
reply->writeStrongBinder(client->asBinder());
}
else
{
reply->writeInt32(0);
}
return NO_ERROR;
} break;
case REGISTER_CAMERA_1_DEVICE: {
int callingPid = android::IPCThreadState::self()->getCallingPid();
if (callingPid != getpid())
{
status_t status = NO_ERROR;
ALOGW("Reject, (calling, current) = (%d, %d) only trust the device on the same process",
callingPid, getpid());
reply->writeNoException();
reply->writeInt32(status);
return NO_ERROR;
}
CHECK_INTERFACE(IMMSdkService, data, reply);
NSCam::ICamDevice *pDevice = NULL;
data.read(reinterpret_cast<NSCam::ICamDevice*>(pDevice), sizeof(NSCam::ICamDevice *));
status_t status = registerCamera1Device(pDevice);
reply->writeNoException();
reply->writeInt32(status);
return status;
} break;
case UNREGISTER_CAMERA_1_DEVICE: {
int callingPid = android::IPCThreadState::self()->getCallingPid();
if (callingPid != getpid())
{
status_t status = NO_ERROR;
ALOGW("Reject, (calling, current) = (%d, %d) only trust the device on the same process",
callingPid, getpid());
reply->writeNoException();
reply->writeInt32(status);
return NO_ERROR;
}
//
CHECK_INTERFACE(IMMSdkService, data, reply);
//NSCam::ICamDevice *pDevice = reinterpret_cast<NSCam::ICamDevice*>(data.readPointer());
NSCam::ICamDevice *pDevice = NULL;
data.read(reinterpret_cast<NSCam::ICamDevice*>(pDevice), sizeof(NSCam::ICamDevice *));
status_t status = unRegisterCamera1Device(pDevice);
reply->writeNoException();
reply->writeInt32(status);
return NO_ERROR;
}break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
void PhoneMachine::receiveSolicited(const Parcel& data)
{
int serial = data.readInt32();
int result = data.readInt32();
RILRequest *request = getPending(serial);
if (!request) {
SLOGW("receiveSolicited: not requested serial=%d result=%d\n", serial, result);
return;
}
SLOGV("<<< Solicited message=%s [%d] serial=%d result=%d\n", rilMessageStr(request->message()),
request->message(), serial, result);
int token = request->token();
int message = request->message();
int ivalue = 0;
Parcel extra;
switch (message) {
case RIL_REQUEST_GET_SIM_STATUS:
ivalue = data.readInt32(); // Store the card state
break;
case RIL_REQUEST_GET_CURRENT_CALLS: {
// We retrieve audio information for the client.
// We also update the AudioFlinger audio state appropriately based
// on the current call state
ivalue = data.readInt32(); // How many calls there are
audio_mode_t audio_mode = AUDIO_MODE_NORMAL;
for (int i = 0 ; i < ivalue ; i++) {
RILCall call(data);
CallState call_state(call.state, call.index,
call.number, call.numberPresentation,
call.name, call.namePresentation);
call_state.writeToParcel(&extra);
if (call.state == RIL_CALL_INCOMING)
audio_mode = AUDIO_MODE_RINGTONE;
else if (call.state == RIL_CALL_ACTIVE || call.state == RIL_CALL_DIALING || call.state == RIL_CALL_ALERTING)
audio_mode = AUDIO_MODE_IN_CALL;
}
SLOGV(" %d calls, audio_mode=%d\n", ivalue, audio_mode);
updateAudioMode(audio_mode);
break;
}
case RIL_REQUEST_DIAL:
case RIL_REQUEST_HANGUP:
case RIL_REQUEST_ANSWER:
case RIL_REQUEST_UDUB:
case RIL_REQUEST_SET_MUTE:
break;
case RIL_REQUEST_GET_MUTE:
ivalue = data.readInt32();
break;
case RIL_REQUEST_SIGNAL_STRENGTH:
// In actuality, we should probably read all 12 signal strengths
ivalue = data.readInt32();
break;
#if defined(SHORT_PLATFORM_VERSION) && (SHORT_PLATFORM_VERSION == 23)
#else
case RIL_REQUEST_VOICE_REGISTRATION_STATE:
ivalue = data.readInt32(); // Starts with the number of strings
for (int i = 0 ; i < ivalue ; i++)
extra.writeString16(data.readString16());
break;
#endif
case RIL_REQUEST_OPERATOR: {
ivalue = data.readInt32();
assert(ivalue == 3);
extra.writeString16(data.readString16());
extra.writeString16(data.readString16());
extra.writeString16(data.readString16());
break;
}
case RIL_REQUEST_RADIO_POWER:
SLOGV(" RIL Radio Power\n");
// No response....
break;
default:
SLOGV("Unhandled RIL request %d\n", message);
break;
}
if (request->client() != NULL) {
SLOGV(" Passing solicited message to client token=%d message=%d result=%d ivalue=%d...\n",
token, message, result, ivalue);
request->client()->Response( token, message, result, ivalue, extra );
}
delete request;
}
status_t BnMediaRecorder::onTransact(
uint32_t code, const Parcel& data, Parcel* reply,
uint32_t flags)
{
switch (code) {
case RELEASE: {
ALOGV("RELEASE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(release());
return NO_ERROR;
} break;
case INIT: {
ALOGV("INIT");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(init());
return NO_ERROR;
} break;
case CLOSE: {
ALOGV("CLOSE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(close());
return NO_ERROR;
} break;
case RESET: {
ALOGV("RESET");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(reset());
return NO_ERROR;
} break;
case STOP: {
ALOGV("STOP");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(stop());
return NO_ERROR;
} break;
case START: {
ALOGV("START");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(start());
return NO_ERROR;
} break;
case PREPARE: {
ALOGV("PREPARE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(prepare());
return NO_ERROR;
} break;
case GET_MAX_AMPLITUDE: {
ALOGV("GET_MAX_AMPLITUDE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int max = 0;
status_t ret = getMaxAmplitude(&max);
reply->writeInt32(max);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case SET_VIDEO_SOURCE: {
ALOGV("SET_VIDEO_SOURCE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int vs = data.readInt32();
reply->writeInt32(setVideoSource(vs));
return NO_ERROR;
} break;
case SET_AUDIO_SOURCE: {
ALOGV("SET_AUDIO_SOURCE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int as = data.readInt32();
reply->writeInt32(setAudioSource(as));
return NO_ERROR;
} break;
case SET_OUTPUT_FORMAT: {
ALOGV("SET_OUTPUT_FORMAT");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int of = data.readInt32();
reply->writeInt32(setOutputFormat(of));
return NO_ERROR;
} break;
case SET_VIDEO_ENCODER: {
ALOGV("SET_VIDEO_ENCODER");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int ve = data.readInt32();
reply->writeInt32(setVideoEncoder(ve));
return NO_ERROR;
} break;
case SET_AUDIO_ENCODER: {
ALOGV("SET_AUDIO_ENCODER");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int ae = data.readInt32();
reply->writeInt32(setAudioEncoder(ae));
return NO_ERROR;
} break;
case SET_OUTPUT_FILE_FD: {
ALOGV("SET_OUTPUT_FILE_FD");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int fd = dup(data.readFileDescriptor());
int64_t offset = data.readInt64();
int64_t length = data.readInt64();
reply->writeInt32(setOutputFile(fd, offset, length));
::close(fd);
return NO_ERROR;
} break;
case SET_VIDEO_SIZE: {
ALOGV("SET_VIDEO_SIZE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int width = data.readInt32();
int height = data.readInt32();
reply->writeInt32(setVideoSize(width, height));
return NO_ERROR;
} break;
case SET_VIDEO_FRAMERATE: {
ALOGV("SET_VIDEO_FRAMERATE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int frames_per_second = data.readInt32();
reply->writeInt32(setVideoFrameRate(frames_per_second));
return NO_ERROR;
} break;
case SET_PARAMETERS: {
ALOGV("SET_PARAMETER");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(setParameters(data.readString8()));
return NO_ERROR;
} break;
case SET_LISTENER: {
ALOGV("SET_LISTENER");
CHECK_INTERFACE(IMediaRecorder, data, reply);
sp<IMediaRecorderClient> listener =
interface_cast<IMediaRecorderClient>(data.readStrongBinder());
reply->writeInt32(setListener(listener));
return NO_ERROR;
} break;
case SET_CLIENT_NAME: {
ALOGV("SET_CLIENT_NAME");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(setClientName(data.readString16()));
return NO_ERROR;
}
case SET_PREVIEW_SURFACE: {
ALOGV("SET_PREVIEW_SURFACE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
sp<IGraphicBufferProducer> surface = interface_cast<IGraphicBufferProducer>(
data.readStrongBinder());
reply->writeInt32(setPreviewSurface(surface));
return NO_ERROR;
} break;
case SET_CAMERA: {
ALOGV("SET_CAMERA");
CHECK_INTERFACE(IMediaRecorder, data, reply);
sp<ICamera> camera = interface_cast<ICamera>(data.readStrongBinder());
sp<ICameraRecordingProxy> proxy =
interface_cast<ICameraRecordingProxy>(data.readStrongBinder());
reply->writeInt32(setCamera(camera, proxy));
return NO_ERROR;
} break;
case SET_INPUT_SURFACE: {
ALOGV("SET_INPUT_SURFACE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
sp<IGraphicBufferConsumer> surface = interface_cast<IGraphicBufferConsumer>(
data.readStrongBinder());
reply->writeInt32(setInputSurface(surface));
return NO_ERROR;
} break;
case QUERY_SURFACE_MEDIASOURCE: {
ALOGV("QUERY_SURFACE_MEDIASOURCE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
// call the mediaserver side to create
// a surfacemediasource
sp<IGraphicBufferProducer> surfaceMediaSource = querySurfaceMediaSource();
// The mediaserver might have failed to create a source
int returnedNull= (surfaceMediaSource == NULL) ? 1 : 0 ;
reply->writeInt32(returnedNull);
if (!returnedNull) {
reply->writeStrongBinder(IInterface::asBinder(surfaceMediaSource));
}
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}