status_t BnDrmIOService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
switch (code) {
case WRITE_TO_FILE:
{
CHECK_INTERFACE(IDrmIOService, data, reply);
writeToFile(data.readString8(), data.readString8());
return DRM_NO_ERROR;
}
case READ_FROM_FILE:
{
CHECK_INTERFACE(IDrmIOService, data, reply);
String8 dataBuffer = readFromFile(data.readString8());
reply->writeString8(dataBuffer);
return DRM_NO_ERROR;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnSurfaceComposerClient::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case CREATE_SURFACE: {
CHECK_INTERFACE(ISurfaceComposerClient, data, reply);
surface_data_t params;
String8 name = data.readString8();
DisplayID display = data.readInt32();
uint32_t w = data.readInt32();
uint32_t h = data.readInt32();
PixelFormat format = data.readInt32();
uint32_t flags = data.readInt32();
sp<ISurface> s = createSurface(¶ms, name, display, w, h,
format, flags);
params.writeToParcel(reply);
reply->writeStrongBinder(s->asBinder());
return NO_ERROR;
} break;
case DESTROY_SURFACE: {
CHECK_INTERFACE(ISurfaceComposerClient, data, reply);
reply->writeInt32( destroySurface( data.readInt32() ) );
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnAudioPolicyServiceClient::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case PORT_LIST_UPDATE: {
CHECK_INTERFACE(IAudioPolicyServiceClient, data, reply);
onAudioPortListUpdate();
return NO_ERROR;
} break;
case PATCH_LIST_UPDATE: {
CHECK_INTERFACE(IAudioPolicyServiceClient, data, reply);
onAudioPatchListUpdate();
return NO_ERROR;
} break;
case MIX_STATE_UPDATE: {
CHECK_INTERFACE(IAudioPolicyServiceClient, data, reply);
String8 regId = data.readString8();
int32_t state = data.readInt32();
onDynamicPolicyMixStateUpdate(regId, state);
return NO_ERROR;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
static void android_view_InputChannel_nativeReadFromParcel(JNIEnv* env, jobject obj,
jobject parcelObj) {
if (android_view_InputChannel_getNativeInputChannel(env, obj) != NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"This object already has a native input channel.");
return;
}
Parcel* parcel = parcelForJavaObject(env, parcelObj);
if (parcel) {
bool isInitialized = parcel->readInt32();
if (isInitialized) {
String8 name = parcel->readString8();
int rawFd = parcel->readFileDescriptor();
int dupFd = dup(rawFd);
if (dupFd < 0) {
ALOGE("Error %d dup channel fd %d.", errno, rawFd);
jniThrowRuntimeException(env,
"Could not read input channel file descriptors from parcel.");
return;
}
InputChannel* inputChannel = new InputChannel(name.string(), dupFd);
NativeInputChannel* nativeInputChannel = new NativeInputChannel(inputChannel);
android_view_InputChannel_setNativeInputChannel(env, obj, nativeInputChannel);
}
}
}
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);
}
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 BnPrivateAfGlueHandler::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case HANDLE_SET_PARAMETERS: {
CHECK_INTERFACE(IPrivateAfGlueHandler, data, reply);
audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32();
String8 keyValuePairs(data.readString8());
reply->writeInt32(handleSetParameters(ioHandle, keyValuePairs));
return NO_ERROR;
} break;
case HANDLE_GET_PARAMETERS: {
CHECK_INTERFACE(IPrivateAfGlueHandler, data, reply);
audio_io_handle_t ioHandle = (audio_io_handle_t) data.readInt32();
String8 keys(data.readString8());
reply->writeString8(handleGetParameters(ioHandle, keys));
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
};
status_t BnSurfaceComposerClient::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case CREATE_SURFACE: {
CHECK_INTERFACE(ISurfaceComposerClient, data, reply);
String8 name = data.readString8();
uint32_t w = data.readInt32();
uint32_t h = data.readInt32();
PixelFormat format = data.readInt32();
uint32_t flags = data.readInt32();
sp<IBinder> handle;
sp<IGraphicBufferProducer> gbp;
status_t result = createSurface(name, w, h, format, flags,
&handle, &gbp);
reply->writeStrongBinder(handle);
reply->writeStrongBinder(gbp->asBinder());
reply->writeInt32(result);
return NO_ERROR;
} break;
case DESTROY_SURFACE: {
CHECK_INTERFACE(ISurfaceComposerClient, data, reply);
reply->writeInt32(destroySurface( data.readStrongBinder() ) );
return NO_ERROR;
} break;
case CLEAR_LAYER_FRAME_STATS: {
CHECK_INTERFACE(ISurfaceComposerClient, data, reply);
sp<IBinder> handle = data.readStrongBinder();
status_t result = clearLayerFrameStats(handle);
reply->writeInt32(result);
return NO_ERROR;
} break;
case GET_LAYER_FRAME_STATS: {
CHECK_INTERFACE(ISurfaceComposerClient, data, reply);
sp<IBinder> handle = data.readStrongBinder();
FrameStats stats;
status_t result = getLayerFrameStats(handle, &stats);
reply->write(stats);
reply->writeInt32(result);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
static void android_view_InputChannel_nativeReadFromParcel(JNIEnv* env, jobject obj,
jobject parcelObj) {
if (android_view_InputChannel_getNativeInputChannel(env, obj) != NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"This object already has a native input channel.");
return;
}
Parcel* parcel = parcelForJavaObject(env, parcelObj);
if (parcel) {
bool isInitialized = parcel->readInt32();
if (isInitialized) {
String8 name = parcel->readString8();
int32_t parcelAshmemFd = parcel->readFileDescriptor();
int32_t ashmemFd = dup(parcelAshmemFd);
if (ashmemFd < 0) {
ALOGE("Error %d dup ashmem fd %d.", errno, parcelAshmemFd);
}
int32_t parcelReceivePipeFd = parcel->readFileDescriptor();
int32_t receivePipeFd = dup(parcelReceivePipeFd);
if (receivePipeFd < 0) {
ALOGE("Error %d dup receive pipe fd %d.", errno, parcelReceivePipeFd);
}
int32_t parcelSendPipeFd = parcel->readFileDescriptor();
int32_t sendPipeFd = dup(parcelSendPipeFd);
if (sendPipeFd < 0) {
ALOGE("Error %d dup send pipe fd %d.", errno, parcelSendPipeFd);
}
if (ashmemFd < 0 || receivePipeFd < 0 || sendPipeFd < 0) {
if (ashmemFd >= 0) ::close(ashmemFd);
if (receivePipeFd >= 0) ::close(receivePipeFd);
if (sendPipeFd >= 0) ::close(sendPipeFd);
jniThrowRuntimeException(env,
"Could not read input channel file descriptors from parcel.");
return;
}
InputChannel* inputChannel = new InputChannel(name, ashmemFd,
receivePipeFd, sendPipeFd);
NativeInputChannel* nativeInputChannel = new NativeInputChannel(inputChannel);
android_view_InputChannel_setNativeInputChannel(env, obj, nativeInputChannel);
}
}
}
status_t BnCameraRecordingProxy::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case START_RECORDING: {
ALOGV("START_RECORDING");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
sp<ICameraRecordingProxyListener> listener =
interface_cast<ICameraRecordingProxyListener>(data.readStrongBinder());
reply->writeInt32(startRecording(listener));
return NO_ERROR;
} break;
case STOP_RECORDING: {
ALOGV("STOP_RECORDING");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
stopRecording();
return NO_ERROR;
} break;
case RELEASE_RECORDING_FRAME: {
ALOGV("RELEASE_RECORDING_FRAME");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
sp<IMemory> mem = interface_cast<IMemory>(data.readStrongBinder());
releaseRecordingFrame(mem);
return NO_ERROR;
} break;
#ifndef ANDROID_DEFAULT_CODE
case GET_PARAMETERS: {
ALOGV("GET_PARAMETERS");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeString8(getParameters());
return NO_ERROR;
} break;
case SET_PARAMETERS: {
ALOGV("SET_PARAMETERS");
CHECK_INTERFACE(ICamera, data, reply);
String8 params(data.readString8());
reply->writeInt32(setParameters(params));
return NO_ERROR;
} break;
#endif
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnDrmServiceListener::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
switch (code) {
case NOTIFY:
{
CHECK_INTERFACE(IDrmServiceListener, data, reply);
int uniqueId = data.readInt32();
int type = data.readInt32();
const String8& message = data.readString8();
status_t status = notify(DrmInfoEvent(uniqueId, type, message));
reply->writeInt32(status);
return DRM_NO_ERROR;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
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);
}
}
status_t BnSurfaceComposer::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case CREATE_CONNECTION: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
sp<IBinder> b = createConnection()->asBinder();
reply->writeStrongBinder(b);
} break;
case CREATE_GRAPHIC_BUFFER_ALLOC: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
sp<IBinder> b = createGraphicBufferAlloc()->asBinder();
reply->writeStrongBinder(b);
} break;
case SET_TRANSACTION_STATE: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
size_t count = data.readInt32();
ComposerState s;
Vector<ComposerState> state;
state.setCapacity(count);
for (size_t i=0 ; i<count ; i++) {
s.read(data);
state.add(s);
}
count = data.readInt32();
DisplayState d;
Vector<DisplayState> displays;
displays.setCapacity(count);
for (size_t i=0 ; i<count ; i++) {
d.read(data);
displays.add(d);
}
uint32_t flags = data.readInt32();
setTransactionState(state, displays, flags);
} break;
case BOOT_FINISHED: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
bootFinished();
} break;
case CAPTURE_SCREEN: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
sp<IBinder> display = data.readStrongBinder();
uint32_t reqWidth = data.readInt32();
uint32_t reqHeight = data.readInt32();
uint32_t minLayerZ = data.readInt32();
uint32_t maxLayerZ = data.readInt32();
sp<IMemoryHeap> heap;
uint32_t w, h;
PixelFormat f;
status_t res = captureScreen(display, &heap, &w, &h, &f,
reqWidth, reqHeight, minLayerZ, maxLayerZ);
reply->writeStrongBinder(heap->asBinder());
reply->writeInt32(w);
reply->writeInt32(h);
reply->writeInt32(f);
reply->writeInt32(res);
} break;
case AUTHENTICATE_SURFACE: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
sp<ISurfaceTexture> surfaceTexture =
interface_cast<ISurfaceTexture>(data.readStrongBinder());
int32_t result = authenticateSurfaceTexture(surfaceTexture) ? 1 : 0;
reply->writeInt32(result);
} break;
case CREATE_DISPLAY_EVENT_CONNECTION: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
sp<IDisplayEventConnection> connection(createDisplayEventConnection());
reply->writeStrongBinder(connection->asBinder());
return NO_ERROR;
} break;
case CREATE_DISPLAY: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
String8 displayName = data.readString8();
bool secure = bool(data.readInt32());
sp<IBinder> display(createDisplay(displayName, secure));
reply->writeStrongBinder(display);
return NO_ERROR;
} break;
case GET_BUILT_IN_DISPLAY: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
int32_t id = data.readInt32();
sp<IBinder> display(getBuiltInDisplay(id));
reply->writeStrongBinder(display);
return NO_ERROR;
} break;
case BLANK: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
sp<IBinder> display = data.readStrongBinder();
blank(display);
} break;
case UNBLANK: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
sp<IBinder> display = data.readStrongBinder();
unblank(display);
} break;
case GET_DISPLAY_INFO: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
DisplayInfo info;
sp<IBinder> display = data.readStrongBinder();
status_t result = getDisplayInfo(display, &info);
memcpy(reply->writeInplace(sizeof(DisplayInfo)), &info, sizeof(DisplayInfo));
reply->writeInt32(result);
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
return NO_ERROR;
}
status_t BnDrmManagerService::onTransact(
uint32_t code, const Parcel& data,
Parcel* reply, uint32_t flags) {
LOGV("Entering BnDrmManagerService::onTransact with code %d", code);
switch (code) {
case ADD_UNIQUEID:
{
LOGV("BnDrmManagerService::onTransact :ADD_UNIQUEID");
CHECK_INTERFACE(IDrmManagerService, data, reply);
int uniqueId = addUniqueId(data.readInt32());
reply->writeInt32(uniqueId);
return DRM_NO_ERROR;
}
case REMOVE_UNIQUEID:
{
LOGV("BnDrmManagerService::onTransact :REMOVE_UNIQUEID");
CHECK_INTERFACE(IDrmManagerService, data, reply);
removeUniqueId(data.readInt32());
return DRM_NO_ERROR;
}
case LOAD_PLUGINS:
{
LOGV("BnDrmManagerService::onTransact :LOAD_PLUGINS");
CHECK_INTERFACE(IDrmManagerService, data, reply);
status_t status = loadPlugIns(data.readInt32());
reply->writeInt32(status);
return DRM_NO_ERROR;
}
case LOAD_PLUGINS_FROM_PATH:
{
LOGV("BnDrmManagerService::onTransact :LOAD_PLUGINS_FROM_PATH");
CHECK_INTERFACE(IDrmManagerService, data, reply);
status_t status = loadPlugIns(data.readInt32(), data.readString8());
reply->writeInt32(status);
return DRM_NO_ERROR;
}
case SET_DRM_SERVICE_LISTENER:
{
LOGV("BnDrmManagerService::onTransact :SET_DRM_SERVICE_LISTENER");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
const sp<IDrmServiceListener> drmServiceListener
= interface_cast<IDrmServiceListener> (data.readStrongBinder());
status_t status = setDrmServiceListener(uniqueId, drmServiceListener);
reply->writeInt32(status);
return DRM_NO_ERROR;
}
case UNLOAD_PLUGINS:
{
LOGV("BnDrmManagerService::onTransact :UNLOAD_PLUGINS");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
status_t status = unloadPlugIns(uniqueId);
reply->writeInt32(status);
return DRM_NO_ERROR;
}
case INSTALL_DRM_ENGINE:
{
LOGV("BnDrmManagerService::onTransact :INSTALL_DRM_ENGINE");
CHECK_INTERFACE(IDrmManagerService, data, reply);
status_t status = installDrmEngine(data.readInt32(), data.readString8());
reply->writeInt32(status);
return DRM_NO_ERROR;
}
case GET_CONSTRAINTS_FROM_CONTENT:
{
LOGV("BnDrmManagerService::onTransact :GET_CONSTRAINTS_FROM_CONTENT");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
const String8 path = data.readString8();
DrmConstraints* drmConstraints = getConstraints(uniqueId, &path, data.readInt32());
if (NULL != drmConstraints) {
//Filling DRM Constraints contents
reply->writeInt32(drmConstraints->getCount());
DrmConstraints::KeyIterator keyIt = drmConstraints->keyIterator();
while (keyIt.hasNext()) {
const String8 key = keyIt.next();
reply->writeString8(key);
const char* value = drmConstraints->getAsByteArray(&key);
int bufferSize = 0;
if (NULL != value) {
bufferSize = strlen(value);
}
reply->writeInt32(bufferSize + 1);
reply->write(value, bufferSize + 1);
}
}
delete drmConstraints; drmConstraints = NULL;
return DRM_NO_ERROR;
}
case CAN_HANDLE:
{
LOGV("BnDrmManagerService::onTransact :CAN_HANDLE");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
const String8 path = data.readString8();
const String8 mimeType = data.readString8();
bool result = canHandle(uniqueId, path, mimeType);
reply->writeInt32(result);
return DRM_NO_ERROR;
}
case PROCESS_DRM_INFO:
{
LOGV("BnDrmManagerService::onTransact :PROCESS_DRM_INFO");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
//Filling DRM info
const int infoType = data.readInt32();
const int bufferSize = data.readInt32();
char* buffer = NULL;
if (0 < bufferSize) {
buffer = (char *)data.readInplace(bufferSize);
}
const DrmBuffer drmBuffer(buffer, bufferSize);
DrmInfo* drmInfo = new DrmInfo(infoType, drmBuffer, data.readString8());
const int size = data.readInt32();
for (int index = 0; index < size; ++index) {
const String8 key(data.readString8());
const String8 value(data.readString8());
drmInfo->put(key, (value == String8("NULL")) ? String8("") : value);
}
DrmInfoStatus* drmInfoStatus = processDrmInfo(uniqueId, drmInfo);
if (NULL != drmInfoStatus) {
//Filling DRM Info Status contents
reply->writeInt32(drmInfoStatus->statusCode);
reply->writeString8(drmInfoStatus->mimeType);
if (NULL != drmInfoStatus->drmBuffer) {
const DrmBuffer* drmBuffer = drmInfoStatus->drmBuffer;
const int bufferSize = drmBuffer->length;
reply->writeInt32(bufferSize);
if (0 < bufferSize) {
reply->write(drmBuffer->data, bufferSize);
}
delete [] drmBuffer->data;
delete drmBuffer; drmBuffer = NULL;
}
}
delete drmInfo; drmInfo = NULL;
delete drmInfoStatus; drmInfoStatus = NULL;
return DRM_NO_ERROR;
}
case ACQUIRE_DRM_INFO:
{
LOGV("BnDrmManagerService::onTransact :ACQUIRE_DRM_INFO");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
//Filling DRM info Request
DrmInfoRequest* drmInfoRequest = new DrmInfoRequest(data.readInt32(), data.readString8());
const int size = data.readInt32();
for (int index = 0; index < size; ++index) {
const String8 key(data.readString8());
const String8 value(data.readString8());
drmInfoRequest->put(key, (value == String8("NULL")) ? String8("") : value);
}
DrmInfo* drmInfo = acquireDrmInfo(uniqueId, drmInfoRequest);
if (NULL != drmInfo) {
//Filling DRM Info
const DrmBuffer drmBuffer = drmInfo->getData();
reply->writeInt32(drmInfo->getInfoType());
const int bufferSize = drmBuffer.length;
reply->writeInt32(bufferSize);
if (0 < bufferSize) {
reply->write(drmBuffer.data, bufferSize);
}
reply->writeString8(drmInfo->getMimeType());
reply->writeInt32(drmInfo->getCount());
DrmInfo::KeyIterator keyIt = drmInfo->keyIterator();
while (keyIt.hasNext()) {
const String8 key = keyIt.next();
reply->writeString8(key);
const String8 value = drmInfo->get(key);
reply->writeString8((value == String8("")) ? String8("NULL") : value);
}
delete [] drmBuffer.data;
}
delete drmInfoRequest; drmInfoRequest = NULL;
delete drmInfo; drmInfo = NULL;
return DRM_NO_ERROR;
}
case SAVE_RIGHTS:
{
LOGV("BnDrmManagerService::onTransact :SAVE_RIGHTS");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
//Filling DRM Rights
const int bufferSize = data.readInt32();
const DrmBuffer drmBuffer((char *)data.readInplace(bufferSize), bufferSize);
const String8 mimeType(data.readString8());
const String8 accountId(data.readString8());
const String8 subscriptionId(data.readString8());
const String8 rightsPath(data.readString8());
const String8 contentPath(data.readString8());
DrmRights drmRights(drmBuffer,
((mimeType == String8("NULL")) ? String8("") : mimeType),
((accountId == String8("NULL")) ? String8("") : accountId),
((subscriptionId == String8("NULL")) ? String8("") : subscriptionId));
const status_t status = saveRights(uniqueId, drmRights,
((rightsPath == String8("NULL")) ? String8("") : rightsPath),
((contentPath == String8("NULL")) ? String8("") : contentPath));
reply->writeInt32(status);
return DRM_NO_ERROR;
}
case GET_ORIGINAL_MIMETYPE:
{
LOGV("BnDrmManagerService::onTransact :GET_ORIGINAL_MIMETYPE");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const String8 originalMimeType = getOriginalMimeType(data.readInt32(), data.readString8());
reply->writeString8(originalMimeType);
return DRM_NO_ERROR;
}
case GET_DRM_OBJECT_TYPE:
{
LOGV("BnDrmManagerService::onTransact :GET_DRM_OBJECT_TYPE");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int drmObjectType
= getDrmObjectType(data.readInt32(), data.readString8(), data.readString8());
reply->writeInt32(drmObjectType);
return DRM_NO_ERROR;
}
case CHECK_RIGHTS_STATUS:
{
LOGV("BnDrmManagerService::onTransact :CHECK_RIGHTS_STATUS");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int result
= checkRightsStatus(data.readInt32(), data.readString8(), data.readInt32());
reply->writeInt32(result);
return DRM_NO_ERROR;
}
case CONSUME_RIGHTS:
{
LOGV("BnDrmManagerService::onTransact :CONSUME_RIGHTS");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
DecryptHandle handle;
handle.decryptId = data.readInt32();
handle.mimeType = data.readString8();
handle.decryptApiType = data.readInt32();
handle.status = data.readInt32();
handle.decryptInfo = NULL;
const int bufferLength = data.readInt32();
if (INVALID_BUFFER_LENGTH != bufferLength) {
handle.decryptInfo = new DecryptInfo();
handle.decryptInfo->decryptBufferLength = bufferLength;
}
const status_t status
= consumeRights(uniqueId, &handle, data.readInt32(),
static_cast<bool>(data.readInt32()));
reply->writeInt32(status);
delete handle.decryptInfo; handle.decryptInfo = NULL;
return DRM_NO_ERROR;
}
case SET_PLAYBACK_STATUS:
{
LOGV("BnDrmManagerService::onTransact :SET_PLAYBACK_STATUS");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
DecryptHandle handle;
handle.decryptId = data.readInt32();
handle.mimeType = data.readString8();
handle.decryptApiType = data.readInt32();
handle.status = data.readInt32();
handle.decryptInfo = NULL;
const int bufferLength = data.readInt32();
if (INVALID_BUFFER_LENGTH != bufferLength) {
handle.decryptInfo = new DecryptInfo();
handle.decryptInfo->decryptBufferLength = bufferLength;
}
const status_t status
= setPlaybackStatus(uniqueId, &handle, data.readInt32(), data.readInt32());
reply->writeInt32(status);
delete handle.decryptInfo; handle.decryptInfo = NULL;
return DRM_NO_ERROR;
}
case VALIDATE_ACTION:
{
LOGV("BnDrmManagerService::onTransact :VALIDATE_ACTION");
CHECK_INTERFACE(IDrmManagerService, data, reply);
bool result = validateAction(
data.readInt32(),
data.readString8(),
data.readInt32(),
ActionDescription(data.readInt32(), data.readInt32()));
reply->writeInt32(result);
return DRM_NO_ERROR;
}
case REMOVE_RIGHTS:
{
LOGV("BnDrmManagerService::onTransact :REMOVE_RIGHTS");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const status_t status = removeRights(data.readInt32(), data.readString8());
reply->writeInt32(status);
return DRM_NO_ERROR;
}
case REMOVE_ALL_RIGHTS:
{
LOGV("BnDrmManagerService::onTransact :REMOVE_ALL_RIGHTS");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const status_t status = removeAllRights(data.readInt32());
reply->writeInt32(status);
return DRM_NO_ERROR;
}
case OPEN_CONVERT_SESSION:
{
LOGV("BnDrmManagerService::onTransact :OPEN_CONVERT_SESSION");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int convertId = openConvertSession(data.readInt32(), data.readString8());
reply->writeInt32(convertId);
return DRM_NO_ERROR;
}
case CONVERT_DATA:
{
LOGV("BnDrmManagerService::onTransact :CONVERT_DATA");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
const int convertId = data.readInt32();
//Filling input data
const int bufferSize = data.readInt32();
DrmBuffer* inputData = new DrmBuffer((char *)data.readInplace(bufferSize), bufferSize);
DrmConvertedStatus* drmConvertedStatus = convertData(uniqueId, convertId, inputData);
if (NULL != drmConvertedStatus) {
//Filling Drm Converted Ststus
reply->writeInt32(drmConvertedStatus->statusCode);
reply->writeInt32(drmConvertedStatus->offset);
if (NULL != drmConvertedStatus->convertedData) {
const DrmBuffer* convertedData = drmConvertedStatus->convertedData;
const int bufferSize = convertedData->length;
reply->writeInt32(bufferSize);
if (0 < bufferSize) {
reply->write(convertedData->data, bufferSize);
}
delete [] convertedData->data;
delete convertedData; convertedData = NULL;
}
}
delete inputData; inputData = NULL;
delete drmConvertedStatus; drmConvertedStatus = NULL;
return DRM_NO_ERROR;
}
case CLOSE_CONVERT_SESSION:
{
LOGV("BnDrmManagerService::onTransact :CLOSE_CONVERT_SESSION");
CHECK_INTERFACE(IDrmManagerService, data, reply);
DrmConvertedStatus* drmConvertedStatus
= closeConvertSession(data.readInt32(), data.readInt32());
if (NULL != drmConvertedStatus) {
//Filling Drm Converted Ststus
reply->writeInt32(drmConvertedStatus->statusCode);
reply->writeInt32(drmConvertedStatus->offset);
if (NULL != drmConvertedStatus->convertedData) {
const DrmBuffer* convertedData = drmConvertedStatus->convertedData;
const int bufferSize = convertedData->length;
reply->writeInt32(bufferSize);
if (0 < bufferSize) {
reply->write(convertedData->data, bufferSize);
}
delete [] convertedData->data;
delete convertedData; convertedData = NULL;
}
}
delete drmConvertedStatus; drmConvertedStatus = NULL;
return DRM_NO_ERROR;
}
case GET_ALL_SUPPORT_INFO:
{
LOGV("BnDrmManagerService::onTransact :GET_ALL_SUPPORT_INFO");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
int length = 0;
DrmSupportInfo* drmSupportInfoArray = NULL;
status_t status = getAllSupportInfo(uniqueId, &length, &drmSupportInfoArray);
reply->writeInt32(length);
for (int i = 0; i < length; ++i) {
DrmSupportInfo drmSupportInfo = drmSupportInfoArray[i];
reply->writeInt32(drmSupportInfo.getFileSuffixCount());
DrmSupportInfo::FileSuffixIterator fileSuffixIt
= drmSupportInfo.getFileSuffixIterator();
while (fileSuffixIt.hasNext()) {
reply->writeString8(fileSuffixIt.next());
}
reply->writeInt32(drmSupportInfo.getMimeTypeCount());
DrmSupportInfo::MimeTypeIterator mimeTypeIt = drmSupportInfo.getMimeTypeIterator();
while (mimeTypeIt.hasNext()) {
reply->writeString8(mimeTypeIt.next());
}
reply->writeString8(drmSupportInfo.getDescription());
}
delete [] drmSupportInfoArray; drmSupportInfoArray = NULL;
reply->writeInt32(status);
return DRM_NO_ERROR;
}
case OPEN_DECRYPT_SESSION:
{
LOGV("BnDrmManagerService::onTransact :OPEN_DECRYPT_SESSION");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
const int fd = data.readFileDescriptor();
DecryptHandle* handle
= openDecryptSession(uniqueId, fd, data.readInt32(), data.readInt32());
if (NULL != handle) {
reply->writeInt32(handle->decryptId);
reply->writeString8(handle->mimeType);
reply->writeInt32(handle->decryptApiType);
reply->writeInt32(handle->status);
if (NULL != handle->decryptInfo) {
reply->writeInt32(handle->decryptInfo->decryptBufferLength);
delete handle->decryptInfo; handle->decryptInfo = NULL;
}
} else {
LOGE("NULL decryptHandle is returned");
}
delete handle; handle = NULL;
return DRM_NO_ERROR;
}
case CLOSE_DECRYPT_SESSION:
{
LOGV("BnDrmManagerService::onTransact :CLOSE_DECRYPT_SESSION");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
DecryptHandle* handle = new DecryptHandle();
handle->decryptId = data.readInt32();
handle->mimeType = data.readString8();
handle->decryptApiType = data.readInt32();
handle->status = data.readInt32();
handle->decryptInfo = NULL;
const int bufferLength = data.readInt32();
if (INVALID_BUFFER_LENGTH != bufferLength) {
handle->decryptInfo = new DecryptInfo();
handle->decryptInfo->decryptBufferLength = bufferLength;
}
const status_t status = closeDecryptSession(uniqueId, handle);
reply->writeInt32(status);
return DRM_NO_ERROR;
}
case INITIALIZE_DECRYPT_UNIT:
{
LOGV("BnDrmManagerService::onTransact :INITIALIZE_DECRYPT_UNIT");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
DecryptHandle handle;
handle.decryptId = data.readInt32();
handle.mimeType = data.readString8();
handle.decryptApiType = data.readInt32();
handle.status = data.readInt32();
handle.decryptInfo = NULL;
const int bufferLength = data.readInt32();
if (INVALID_BUFFER_LENGTH != bufferLength) {
handle.decryptInfo = new DecryptInfo();
handle.decryptInfo->decryptBufferLength = bufferLength;
}
const int decryptUnitId = data.readInt32();
//Filling Header info
const int bufferSize = data.readInt32();
DrmBuffer* headerInfo = NULL;
headerInfo = new DrmBuffer((char *)data.readInplace(bufferSize), bufferSize);
const status_t status
= initializeDecryptUnit(uniqueId, &handle, decryptUnitId, headerInfo);
reply->writeInt32(status);
delete handle.decryptInfo; handle.decryptInfo = NULL;
delete headerInfo; headerInfo = NULL;
return DRM_NO_ERROR;
}
case DECRYPT:
{
LOGV("BnDrmManagerService::onTransact :DECRYPT");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
DecryptHandle handle;
handle.decryptId = data.readInt32();
handle.mimeType = data.readString8();
handle.decryptApiType = data.readInt32();
handle.status = data.readInt32();
handle.decryptInfo = NULL;
const int bufferLength = data.readInt32();
if (INVALID_BUFFER_LENGTH != bufferLength) {
handle.decryptInfo = new DecryptInfo();
handle.decryptInfo->decryptBufferLength = bufferLength;
}
const int decryptUnitId = data.readInt32();
const int decBufferSize = data.readInt32();
const int encBufferSize = data.readInt32();
DrmBuffer* encBuffer
= new DrmBuffer((char *)data.readInplace(encBufferSize), encBufferSize);
char* buffer = NULL;
buffer = new char[decBufferSize];
DrmBuffer* decBuffer = new DrmBuffer(buffer, decBufferSize);
DrmBuffer* IV = NULL;
if (0 != data.dataAvail()) {
const int ivBufferlength = data.readInt32();
IV = new DrmBuffer((char *)data.readInplace(ivBufferlength), ivBufferlength);
}
const status_t status
= decrypt(uniqueId, &handle, decryptUnitId, encBuffer, &decBuffer, IV);
reply->writeInt32(status);
const int size = decBuffer->length;
reply->writeInt32(size);
reply->write(decBuffer->data, size);
delete handle.decryptInfo; handle.decryptInfo = NULL;
delete encBuffer; encBuffer = NULL;
delete decBuffer; decBuffer = NULL;
delete [] buffer; buffer = NULL;
delete IV; IV = NULL;
return DRM_NO_ERROR;
}
case FINALIZE_DECRYPT_UNIT:
{
LOGV("BnDrmManagerService::onTransact :FINALIZE_DECRYPT_UNIT");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
DecryptHandle handle;
handle.decryptId = data.readInt32();
handle.mimeType = data.readString8();
handle.decryptApiType = data.readInt32();
handle.status = data.readInt32();
handle.decryptInfo = NULL;
const int bufferLength = data.readInt32();
if (INVALID_BUFFER_LENGTH != bufferLength) {
handle.decryptInfo = new DecryptInfo();
handle.decryptInfo->decryptBufferLength = bufferLength;
}
const status_t status = finalizeDecryptUnit(uniqueId, &handle, data.readInt32());
reply->writeInt32(status);
delete handle.decryptInfo; handle.decryptInfo = NULL;
return DRM_NO_ERROR;
}
case PREAD:
{
LOGV("BnDrmManagerService::onTransact :READ");
CHECK_INTERFACE(IDrmManagerService, data, reply);
const int uniqueId = data.readInt32();
DecryptHandle handle;
handle.decryptId = data.readInt32();
handle.mimeType = data.readString8();
handle.decryptApiType = data.readInt32();
handle.status = data.readInt32();
handle.decryptInfo = NULL;
const int bufferLength = data.readInt32();
if (INVALID_BUFFER_LENGTH != bufferLength) {
handle.decryptInfo = new DecryptInfo();
handle.decryptInfo->decryptBufferLength = bufferLength;
}
const int numBytes = data.readInt32();
char* buffer = new char[numBytes];
const off_t offset = data.readInt32();
ssize_t result = pread(uniqueId, &handle, buffer, numBytes, offset);
reply->writeInt32(result);
if (0 < result) {
reply->write(buffer, result);
}
delete handle.decryptInfo; handle.decryptInfo = NULL;
delete [] buffer, buffer = NULL;
return DRM_NO_ERROR;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnMediaRecorder::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case RELEASE: {
LOGV("RELEASE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(release());
return NO_ERROR;
}
break;
case INIT: {
LOGV("INIT");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(init());
return NO_ERROR;
}
break;
case CLOSE: {
LOGV("CLOSE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(close());
return NO_ERROR;
}
break;
case RESET: {
LOGV("RESET");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(reset());
return NO_ERROR;
}
break;
case STOP: {
LOGV("STOP");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(stop());
return NO_ERROR;
}
break;
case START: {
LOGV("START");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(start());
return NO_ERROR;
}
break;
case PREPARE: {
LOGV("PREPARE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(prepare());
return NO_ERROR;
}
break;
case GET_MAX_AMPLITUDE: {
LOGV("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: {
LOGV("SET_VIDEO_SOURCE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int vs = data.readInt32();
reply->writeInt32(setVideoSource(vs));
return NO_ERROR;
}
break;
case SET_AUDIO_SOURCE: {
LOGV("SET_AUDIO_SOURCE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int as = data.readInt32();
reply->writeInt32(setAudioSource(as));
return NO_ERROR;
}
break;
case SET_OUTPUT_FORMAT: {
LOGV("SET_OUTPUT_FORMAT");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int of = data.readInt32();
reply->writeInt32(setOutputFormat(of));
return NO_ERROR;
}
break;
case SET_VIDEO_ENCODER: {
LOGV("SET_VIDEO_ENCODER");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int ve = data.readInt32();
reply->writeInt32(setVideoEncoder(ve));
return NO_ERROR;
}
break;
case SET_AUDIO_ENCODER: {
LOGV("SET_AUDIO_ENCODER");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int ae = data.readInt32();
reply->writeInt32(setAudioEncoder(ae));
return NO_ERROR;
}
break;
case SET_OUTPUT_FILE_PATH: {
LOGV("SET_OUTPUT_FILE_PATH");
CHECK_INTERFACE(IMediaRecorder, data, reply);
const char* path = data.readCString();
reply->writeInt32(setOutputFile(path));
return NO_ERROR;
}
break;
case SET_OUTPUT_FILE_FD: {
LOGV("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));
return NO_ERROR;
}
break;
case SET_VIDEO_SIZE: {
LOGV("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: {
LOGV("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: {
LOGV("SET_PARAMETER");
CHECK_INTERFACE(IMediaRecorder, data, reply);
reply->writeInt32(setParameters(data.readString8()));
return NO_ERROR;
}
break;
case SET_LISTENER: {
LOGV("SET_LISTENER");
CHECK_INTERFACE(IMediaRecorder, data, reply);
sp<IMediaPlayerClient> listener =
interface_cast<IMediaPlayerClient>(data.readStrongBinder());
reply->writeInt32(setListener(listener));
return NO_ERROR;
}
break;
case SET_PREVIEW_SURFACE: {
LOGV("SET_PREVIEW_SURFACE");
CHECK_INTERFACE(IMediaRecorder, data, reply);
sp<ISurface> surface = interface_cast<ISurface>(data.readStrongBinder());
reply->writeInt32(setPreviewSurface(surface));
return NO_ERROR;
}
break;
case SET_CAMERA: {
LOGV("SET_CAMERA");
CHECK_INTERFACE(IMediaRecorder, data, reply);
sp<ICamera> camera = interface_cast<ICamera>(data.readStrongBinder());
reply->writeInt32(setCamera(camera));
return NO_ERROR;
}
break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
// Server
status_t BnPeripheralManager::onTransact(uint32_t code, const Parcel &data,
Parcel *reply, uint32_t flags) {
switch (code) {
case PM_REGISTER: {
CHECK_INTERFACE(IPeripheralManager, data, reply);
sp<IPeriperalManagerCb> notifier;
int64_t clientId, state;
String8 devName = data.readString8();
String8 clientName = data.readString8();
notifier = interface_cast <IPeriperalManagerCb> (data.readStrongBinder());
int32_t ret = registar(devName, clientName, notifier, &clientId, &state);
reply->writeInt64(clientId);
reply->writeInt64(state);
reply->writeInt32(ret);
return NO_ERROR;
break;
}
case PM_UNREGISTER: {
CHECK_INTERFACE(IPeripheralManager, data, reply);
int64_t clientId = data.readInt64();
int32_t ret = unregister(clientId);
reply->writeInt32(ret);
return NO_ERROR;
break;
}
case PM_CONNECT: {
CHECK_INTERFACE(IPeripheralManager, data, reply);
int64_t clientId = data.readInt64();
int32_t ret = connect(clientId);
reply->writeInt32(ret);
return NO_ERROR;
break;
}
case PM_DISCONNECT: {
CHECK_INTERFACE(IPeripheralManager, data, reply);
int64_t clientId = data.readInt64();
int32_t ret = disconnect(clientId);
reply->writeInt32(ret);
return NO_ERROR;
break;
}
case PM_ACKNOWLEDGE: {
CHECK_INTERFACE(IPeripheralManager, data, reply);
int64_t clientId = data.readInt64();
int32_t event = data.readInt32();
int32_t ret = acknowledge(clientId, event);
reply->writeInt32(ret);
return NO_ERROR;
break;
}
case PM_SHUTDOWN: {
CHECK_INTERFACE(IPeripheralManager, data, reply);
int32_t ret = shutdown();
reply->writeInt32(ret);
return NO_ERROR;
break;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnGraphicBufferConsumer::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case ACQUIRE_BUFFER: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
BufferItem item;
int64_t presentWhen = data.readInt64();
uint64_t maxFrameNumber = data.readUint64();
status_t result = acquireBuffer(&item, presentWhen, maxFrameNumber);
status_t err = reply->write(item);
if (err) return err;
reply->writeInt32(result);
return NO_ERROR;
}
case DETACH_BUFFER: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
int slot = data.readInt32();
int result = detachBuffer(slot);
reply->writeInt32(result);
return NO_ERROR;
}
case ATTACH_BUFFER: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
sp<GraphicBuffer> buffer = new GraphicBuffer();
data.read(*buffer.get());
int slot = -1;
int result = attachBuffer(&slot, buffer);
reply->writeInt32(slot);
reply->writeInt32(result);
return NO_ERROR;
}
case RELEASE_BUFFER: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
int buf = data.readInt32();
uint64_t frameNumber = static_cast<uint64_t>(data.readInt64());
sp<Fence> releaseFence = new Fence();
status_t err = data.read(*releaseFence);
if (err) return err;
status_t result = releaseBuffer(buf, frameNumber,
EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, releaseFence);
reply->writeInt32(result);
return NO_ERROR;
}
case CONSUMER_CONNECT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
sp<IConsumerListener> consumer = IConsumerListener::asInterface( data.readStrongBinder() );
bool controlledByApp = data.readInt32();
status_t result = consumerConnect(consumer, controlledByApp);
reply->writeInt32(result);
return NO_ERROR;
}
case CONSUMER_DISCONNECT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
status_t result = consumerDisconnect();
reply->writeInt32(result);
return NO_ERROR;
}
case GET_RELEASED_BUFFERS: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint64_t slotMask = 0;
status_t result = getReleasedBuffers(&slotMask);
reply->writeInt64(static_cast<int64_t>(slotMask));
reply->writeInt32(result);
return NO_ERROR;
}
case SET_DEFAULT_BUFFER_SIZE: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t width = data.readUint32();
uint32_t height = data.readUint32();
status_t result = setDefaultBufferSize(width, height);
reply->writeInt32(result);
return NO_ERROR;
}
case SET_MAX_BUFFER_COUNT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
int bufferCount = data.readInt32();
status_t result = setMaxBufferCount(bufferCount);
reply->writeInt32(result);
return NO_ERROR;
}
case SET_MAX_ACQUIRED_BUFFER_COUNT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
int maxAcquiredBuffers = data.readInt32();
status_t result = setMaxAcquiredBufferCount(maxAcquiredBuffers);
reply->writeInt32(result);
return NO_ERROR;
}
case SET_CONSUMER_NAME: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
setConsumerName( data.readString8() );
return NO_ERROR;
}
case SET_DEFAULT_BUFFER_FORMAT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
PixelFormat defaultFormat = static_cast<PixelFormat>(data.readInt32());
status_t result = setDefaultBufferFormat(defaultFormat);
reply->writeInt32(result);
return NO_ERROR;
}
case SET_DEFAULT_BUFFER_DATA_SPACE: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
android_dataspace defaultDataSpace =
static_cast<android_dataspace>(data.readInt32());
status_t result = setDefaultBufferDataSpace(defaultDataSpace);
reply->writeInt32(result);
return NO_ERROR;
}
case SET_CONSUMER_USAGE_BITS: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t usage = data.readUint32();
status_t result = setConsumerUsageBits(usage);
reply->writeInt32(result);
return NO_ERROR;
}
case SET_TRANSFORM_HINT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t hint = data.readUint32();
status_t result = setTransformHint(hint);
reply->writeInt32(result);
return NO_ERROR;
}
case GET_SIDEBAND_STREAM: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
sp<NativeHandle> stream = getSidebandStream();
reply->writeInt32(static_cast<int32_t>(stream != NULL));
if (stream != NULL) {
reply->writeNativeHandle(stream->handle());
}
return NO_ERROR;
}
case GET_OCCUPANCY_HISTORY: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
bool forceFlush = false;
status_t error = data.readBool(&forceFlush);
if (error != NO_ERROR) {
return error;
}
std::vector<OccupancyTracker::Segment> history;
status_t result = getOccupancyHistory(forceFlush, &history);
error = reply->writeParcelableVector(history);
if (error != NO_ERROR) {
return error;
}
error = reply->writeInt32(result);
if (error != NO_ERROR) {
return error;
}
return NO_ERROR;
}
case DISCARD_FREE_BUFFERS: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
status_t result = discardFreeBuffers();
status_t error = reply->writeInt32(result);
return error;
}
case DUMP: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
String8 result = data.readString8();
String8 prefix = data.readString8();
static_cast<IGraphicBufferConsumer*>(this)->dumpState(result, prefix);
reply->writeString8(result);
return NO_ERROR;
}
}
return BBinder::onTransact(code, data, reply, flags);
}
status_t BnMediaPlayerService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case CREATE_URL: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
pid_t pid = data.readInt32();
sp<IMediaPlayerClient> client =
interface_cast<IMediaPlayerClient>(data.readStrongBinder());
const char* url = data.readCString();
KeyedVector<String8, String8> headers;
int32_t numHeaders = data.readInt32();
for (int i = 0; i < numHeaders; ++i) {
String8 key = data.readString8();
String8 value = data.readString8();
headers.add(key, value);
}
sp<IMediaPlayer> player = create(
pid, client, url, numHeaders > 0 ? &headers : NULL);
reply->writeStrongBinder(player->asBinder());
return NO_ERROR;
} break;
case CREATE_FD: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
pid_t pid = data.readInt32();
sp<IMediaPlayerClient> client = interface_cast<IMediaPlayerClient>(data.readStrongBinder());
int fd = dup(data.readFileDescriptor());
int64_t offset = data.readInt64();
int64_t length = data.readInt64();
sp<IMediaPlayer> player = create(pid, client, fd, offset, length);
reply->writeStrongBinder(player->asBinder());
return NO_ERROR;
} break;
case DECODE_URL: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
const char* url = data.readCString();
uint32_t sampleRate;
int numChannels;
int format;
sp<IMemory> player = decode(url, &sampleRate, &numChannels, &format);
reply->writeInt32(sampleRate);
reply->writeInt32(numChannels);
reply->writeInt32(format);
reply->writeStrongBinder(player->asBinder());
return NO_ERROR;
} break;
case DECODE_FD: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
int fd = dup(data.readFileDescriptor());
int64_t offset = data.readInt64();
int64_t length = data.readInt64();
uint32_t sampleRate;
int numChannels;
int format;
sp<IMemory> player = decode(fd, offset, length, &sampleRate, &numChannels, &format);
reply->writeInt32(sampleRate);
reply->writeInt32(numChannels);
reply->writeInt32(format);
reply->writeStrongBinder(player->asBinder());
return NO_ERROR;
} break;
case SNOOP: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
sp<IMemory> snooped_audio = snoop();
reply->writeStrongBinder(snooped_audio->asBinder());
return NO_ERROR;
} break;
case CREATE_MEDIA_RECORDER: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
pid_t pid = data.readInt32();
sp<IMediaRecorder> recorder = createMediaRecorder(pid);
reply->writeStrongBinder(recorder->asBinder());
return NO_ERROR;
} break;
case CREATE_METADATA_RETRIEVER: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
pid_t pid = data.readInt32();
sp<IMediaMetadataRetriever> retriever = createMetadataRetriever(pid);
reply->writeStrongBinder(retriever->asBinder());
return NO_ERROR;
} break;
case GET_OMX: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
sp<IOMX> omx = getOMX();
reply->writeStrongBinder(omx->asBinder());
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnCamera::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case DISCONNECT: {
LOGV("DISCONNECT");
CHECK_INTERFACE(ICamera, data, reply);
disconnect();
return NO_ERROR;
} break;
case SET_PREVIEW_DISPLAY: {
LOGV("SET_PREVIEW_DISPLAY");
CHECK_INTERFACE(ICamera, data, reply);
sp<ISurface> surface = interface_cast<ISurface>(data.readStrongBinder());
reply->writeInt32(setPreviewDisplay(surface));
return NO_ERROR;
} break;
case SET_FRAME_CALLBACK_FLAG: {
LOGV("SET_FRAME_CALLBACK_TYPE");
CHECK_INTERFACE(ICamera, data, reply);
int frame_callback_flag = data.readInt32();
setFrameCallbackFlag(frame_callback_flag);
return NO_ERROR;
} break;
case START_PREVIEW: {
LOGV("START_PREVIEW");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(startPreview());
return NO_ERROR;
} break;
case STOP_PREVIEW: {
LOGV("STOP_PREVIEW");
CHECK_INTERFACE(ICamera, data, reply);
stopPreview();
return NO_ERROR;
} break;
case AUTO_FOCUS: {
LOGV("AUTO_FOCUS");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(autoFocus());
return NO_ERROR;
} break;
case TAKE_PICTURE: {
LOGV("TAKE_PICTURE");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(takePicture());
return NO_ERROR;
} break;
case SET_PARAMETERS: {
LOGV("SET_PARAMETERS");
CHECK_INTERFACE(ICamera, data, reply);
String8 params(data.readString8());
reply->writeInt32(setParameters(params));
return NO_ERROR;
} break;
case GET_PARAMETERS: {
LOGV("GET_PARAMETERS");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeString8(getParameters());
return NO_ERROR;
} break;
case CONNECT: {
CHECK_INTERFACE(ICamera, data, reply);
sp<ICameraClient> cameraClient = interface_cast<ICameraClient>(data.readStrongBinder());
reply->writeInt32(connect(cameraClient));
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnMediaMetadataRetriever::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case DISCONNECT: {
CHECK_INTERFACE(IMediaMetadataRetriever, data, reply);
disconnect();
return NO_ERROR;
} break;
case SET_DATA_SOURCE_URL: {
CHECK_INTERFACE(IMediaMetadataRetriever, data, reply);
sp<IMediaHTTPService> httpService;
if (data.readInt32()) {
httpService =
interface_cast<IMediaHTTPService>(data.readStrongBinder());
}
const char* srcUrl = data.readCString();
KeyedVector<String8, String8> headers;
size_t numHeaders = (size_t) data.readInt64();
for (size_t i = 0; i < numHeaders; ++i) {
String8 key = data.readString8();
String8 value = data.readString8();
headers.add(key, value);
}
reply->writeInt32(
setDataSource(
httpService, srcUrl, numHeaders > 0 ? &headers : NULL));
return NO_ERROR;
} break;
case SET_DATA_SOURCE_FD: {
CHECK_INTERFACE(IMediaMetadataRetriever, data, reply);
int fd = data.readFileDescriptor();
int64_t offset = data.readInt64();
int64_t length = data.readInt64();
reply->writeInt32(setDataSource(fd, offset, length));
return NO_ERROR;
} break;
case SET_DATA_SOURCE_CALLBACK: {
CHECK_INTERFACE(IMediaMetadataRetriever, data, reply);
sp<IDataSource> source =
interface_cast<IDataSource>(data.readStrongBinder());
reply->writeInt32(setDataSource(source));
return NO_ERROR;
} break;
case GET_FRAME_AT_TIME: {
CHECK_INTERFACE(IMediaMetadataRetriever, data, reply);
int64_t timeUs = data.readInt64();
int option = data.readInt32();
ALOGV("getTimeAtTime: time(%" PRId64 " us) and option(%d)", timeUs, option);
#ifndef DISABLE_GROUP_SCHEDULE_HACK
setSchedPolicy(data);
#endif
sp<IMemory> bitmap = getFrameAtTime(timeUs, option);
if (bitmap != 0) { // Don't send NULL across the binder interface
reply->writeInt32(NO_ERROR);
reply->writeStrongBinder(IInterface::asBinder(bitmap));
} else {
reply->writeInt32(UNKNOWN_ERROR);
}
#ifndef DISABLE_GROUP_SCHEDULE_HACK
restoreSchedPolicy();
#endif
return NO_ERROR;
} break;
case EXTRACT_ALBUM_ART: {
CHECK_INTERFACE(IMediaMetadataRetriever, data, reply);
#ifndef DISABLE_GROUP_SCHEDULE_HACK
setSchedPolicy(data);
#endif
sp<IMemory> albumArt = extractAlbumArt();
if (albumArt != 0) { // Don't send NULL across the binder interface
reply->writeInt32(NO_ERROR);
reply->writeStrongBinder(IInterface::asBinder(albumArt));
} else {
reply->writeInt32(UNKNOWN_ERROR);
}
#ifndef DISABLE_GROUP_SCHEDULE_HACK
restoreSchedPolicy();
#endif
return NO_ERROR;
} break;
case EXTRACT_METADATA: {
CHECK_INTERFACE(IMediaMetadataRetriever, data, reply);
#ifndef DISABLE_GROUP_SCHEDULE_HACK
setSchedPolicy(data);
#endif
int keyCode = data.readInt32();
const char* value = extractMetadata(keyCode);
if (value != NULL) { // Don't send NULL across the binder interface
reply->writeInt32(NO_ERROR);
reply->writeCString(value);
} else {
reply->writeInt32(UNKNOWN_ERROR);
}
#ifndef DISABLE_GROUP_SCHEDULE_HACK
restoreSchedPolicy();
#endif
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnMediaPlayer::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case DISCONNECT: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
disconnect();
return NO_ERROR;
} break;
case SET_VIDEO_SURFACE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
sp<ISurface> surface = interface_cast<ISurface>(data.readStrongBinder());
reply->writeInt32(setVideoSurface(surface));
return NO_ERROR;
} break;
case PREPARE_ASYNC: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(prepareAsync());
return NO_ERROR;
} break;
case START: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(start());
return NO_ERROR;
} break;
case STOP: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(stop());
return NO_ERROR;
} break;
case IS_PLAYING: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
bool state;
status_t ret = isPlaying(&state);
reply->writeInt32(state);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case PAUSE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(pause());
return NO_ERROR;
} break;
case SEEK_TO: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(seekTo(data.readInt32()));
return NO_ERROR;
} break;
case GET_CURRENT_POSITION: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int msec;
status_t ret = getCurrentPosition(&msec);
reply->writeInt32(msec);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case GET_DURATION: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int msec;
status_t ret = getDuration(&msec);
reply->writeInt32(msec);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case RESET: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(reset());
return NO_ERROR;
} break;
case SET_AUDIO_STREAM_TYPE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setAudioStreamType(data.readInt32()));
return NO_ERROR;
} break;
case SET_LOOPING: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setLooping(data.readInt32()));
return NO_ERROR;
} break;
case SET_VOLUME: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setVolume(data.readFloat(), data.readFloat()));
return NO_ERROR;
} break;
case INVOKE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
invoke(data, reply);
return NO_ERROR;
} break;
case SET_METADATA_FILTER: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setMetadataFilter(data));
return NO_ERROR;
} break;
case SUSPEND: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(suspend());
return NO_ERROR;
} break;
case RESUME: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(resume());
return NO_ERROR;
} break;
case GET_METADATA: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
const status_t retcode = getMetadata(data.readInt32(), data.readInt32(), reply);
reply->setDataPosition(0);
reply->writeInt32(retcode);
reply->setDataPosition(0);
return NO_ERROR;
} break;
case SET_AUX_EFFECT_SEND_LEVEL: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setAuxEffectSendLevel(data.readFloat()));
return NO_ERROR;
} break;
case ATTACH_AUX_EFFECT: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(attachAuxEffect(data.readInt32()));
return NO_ERROR;
}break;
case SET_PARAMETERS: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setParameters(data.readString8()));
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnMediaPlayerService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case CREATE: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
sp<IMediaPlayerClient> client =
interface_cast<IMediaPlayerClient>(data.readStrongBinder());
int audioSessionId = data.readInt32();
sp<IMediaPlayer> player = create(client, audioSessionId);
reply->writeStrongBinder(player->asBinder());
return NO_ERROR;
} break;
case DECODE_URL: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
const char* url = data.readCString();
uint32_t sampleRate;
int numChannels;
audio_format_t format;
sp<IMemory> player = decode(url, &sampleRate, &numChannels, &format);
reply->writeInt32(sampleRate);
reply->writeInt32(numChannels);
reply->writeInt32((int32_t) format);
reply->writeStrongBinder(player->asBinder());
return NO_ERROR;
} break;
case DECODE_FD: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
int fd = dup(data.readFileDescriptor());
int64_t offset = data.readInt64();
int64_t length = data.readInt64();
uint32_t sampleRate;
int numChannels;
audio_format_t format;
sp<IMemory> player = decode(fd, offset, length, &sampleRate, &numChannels, &format);
reply->writeInt32(sampleRate);
reply->writeInt32(numChannels);
reply->writeInt32((int32_t) format);
reply->writeStrongBinder(player->asBinder());
return NO_ERROR;
} break;
case CREATE_MEDIA_RECORDER: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
sp<IMediaRecorder> recorder = createMediaRecorder();
reply->writeStrongBinder(recorder->asBinder());
return NO_ERROR;
} break;
case CREATE_METADATA_RETRIEVER: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
sp<IMediaMetadataRetriever> retriever = createMetadataRetriever();
reply->writeStrongBinder(retriever->asBinder());
return NO_ERROR;
} break;
case GET_OMX: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
sp<IOMX> omx = getOMX();
reply->writeStrongBinder(omx->asBinder());
return NO_ERROR;
} break;
case MAKE_CRYPTO: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
sp<ICrypto> crypto = makeCrypto();
reply->writeStrongBinder(crypto->asBinder());
return NO_ERROR;
} break;
case MAKE_DRM: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
sp<IDrm> drm = makeDrm();
reply->writeStrongBinder(drm->asBinder());
return NO_ERROR;
} break;
case MAKE_HDCP: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
bool createEncryptionModule = data.readInt32();
sp<IHDCP> hdcp = makeHDCP(createEncryptionModule);
reply->writeStrongBinder(hdcp->asBinder());
return NO_ERROR;
} break;
case ADD_BATTERY_DATA: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
uint32_t params = data.readInt32();
addBatteryData(params);
return NO_ERROR;
} break;
case PULL_BATTERY_DATA: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
pullBatteryData(reply);
return NO_ERROR;
} break;
case LISTEN_FOR_REMOTE_DISPLAY: {
CHECK_INTERFACE(IMediaPlayerService, data, reply);
sp<IRemoteDisplayClient> client(
interface_cast<IRemoteDisplayClient>(data.readStrongBinder()));
String8 iface(data.readString8());
sp<IRemoteDisplay> display(listenForRemoteDisplay(client, iface));
reply->writeStrongBinder(display->asBinder());
return NO_ERROR;
} break;
case UPDATE_PROXY_CONFIG:
{
CHECK_INTERFACE(IMediaPlayerService, data, reply);
const char *host = NULL;
int32_t port = 0;
const char *exclusionList = NULL;
if (data.readInt32()) {
host = data.readCString();
port = data.readInt32();
exclusionList = data.readCString();
}
reply->writeInt32(updateProxyConfig(host, port, exclusionList));
return OK;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnMediaPlayer::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case DISCONNECT: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
disconnect();
return NO_ERROR;
} break;
case SET_DATA_SOURCE_URL: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
const char* url = data.readCString();
KeyedVector<String8, String8> headers;
int32_t numHeaders = data.readInt32();
for (int i = 0; i < numHeaders; ++i) {
String8 key = data.readString8();
String8 value = data.readString8();
headers.add(key, value);
}
reply->writeInt32(setDataSource(url, numHeaders > 0 ? &headers : NULL));
return NO_ERROR;
} break;
case SET_DATA_SOURCE_FD: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int fd = data.readFileDescriptor();
int64_t offset = data.readInt64();
int64_t length = data.readInt64();
reply->writeInt32(setDataSource(fd, offset, length));
return NO_ERROR;
}
case SET_DATA_SOURCE_STREAM: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
sp<IStreamSource> source =
interface_cast<IStreamSource>(data.readStrongBinder());
reply->writeInt32(setDataSource(source));
return NO_ERROR;
}
case SET_VIDEO_SURFACETEXTURE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
sp<ISurfaceTexture> surfaceTexture =
interface_cast<ISurfaceTexture>(data.readStrongBinder());
reply->writeInt32(setVideoSurfaceTexture(surfaceTexture));
return NO_ERROR;
} break;
case PREPARE_ASYNC: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(prepareAsync());
return NO_ERROR;
} break;
case START: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(start());
return NO_ERROR;
} break;
case STOP: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(stop());
return NO_ERROR;
} break;
case IS_PLAYING: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
bool state;
status_t ret = isPlaying(&state);
reply->writeInt32(state);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case PAUSE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(pause());
return NO_ERROR;
} break;
case SEEK_TO: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(seekTo(data.readInt32()));
return NO_ERROR;
} break;
case GET_CURRENT_POSITION: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int msec;
status_t ret = getCurrentPosition(&msec);
reply->writeInt32(msec);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case GET_DURATION: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int msec;
status_t ret = getDuration(&msec);
reply->writeInt32(msec);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case RESET: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(reset());
return NO_ERROR;
} break;
case SET_AUDIO_STREAM_TYPE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setAudioStreamType(data.readInt32()));
return NO_ERROR;
} break;
case SET_LOOPING: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setLooping(data.readInt32()));
return NO_ERROR;
} break;
case SET_VOLUME: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
float leftVolume = data.readFloat();
float rightVolume = data.readFloat();
reply->writeInt32(setVolume(leftVolume, rightVolume));
return NO_ERROR;
} break;
case INVOKE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
status_t result = invoke(data, reply);
return result;
} break;
case SET_METADATA_FILTER: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setMetadataFilter(data));
return NO_ERROR;
} break;
case GET_METADATA: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
bool update_only = static_cast<bool>(data.readInt32());
bool apply_filter = static_cast<bool>(data.readInt32());
const status_t retcode = getMetadata(update_only, apply_filter, reply);
reply->setDataPosition(0);
reply->writeInt32(retcode);
reply->setDataPosition(0);
return NO_ERROR;
} break;
case SET_AUX_EFFECT_SEND_LEVEL: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setAuxEffectSendLevel(data.readFloat()));
return NO_ERROR;
} break;
case ATTACH_AUX_EFFECT: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(attachAuxEffect(data.readInt32()));
return NO_ERROR;
} break;
case SET_PARAMETER: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int key = data.readInt32();
Parcel request;
if (data.dataAvail() > 0) {
request.appendFrom(
const_cast<Parcel *>(&data), data.dataPosition(), data.dataAvail());
}
request.setDataPosition(0);
reply->writeInt32(setParameter(key, request));
return NO_ERROR;
} break;
case GET_PARAMETER: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
return getParameter(data.readInt32(), reply);
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
void MediaResource::readFromParcel(const Parcel &parcel) {
mType = parcel.readString8();
mSubType = parcel.readString8();
mValue = parcel.readUint64();
}
status_t BnGraphicBufferConsumer::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case ACQUIRE_BUFFER: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
BufferItem item;
int64_t presentWhen = data.readInt64();
status_t result = acquireBuffer(&item, presentWhen);
status_t err = reply->write(item);
if (err) return err;
reply->writeInt32(result);
return NO_ERROR;
} break;
case RELEASE_BUFFER: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
int buf = data.readInt32();
uint64_t frameNumber = data.readInt64();
sp<Fence> releaseFence = new Fence();
status_t err = data.read(*releaseFence);
if (err) return err;
status_t result = releaseBuffer(buf, frameNumber,
EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, releaseFence);
reply->writeInt32(result);
return NO_ERROR;
} break;
case CONSUMER_CONNECT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
sp<IConsumerListener> consumer = IConsumerListener::asInterface( data.readStrongBinder() );
bool controlledByApp = data.readInt32();
status_t result = consumerConnect(consumer, controlledByApp);
reply->writeInt32(result);
return NO_ERROR;
} break;
case CONSUMER_DISCONNECT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
status_t result = consumerDisconnect();
reply->writeInt32(result);
return NO_ERROR;
} break;
case GET_RELEASED_BUFFERS: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t slotMask;
status_t result = getReleasedBuffers(&slotMask);
reply->writeInt32(slotMask);
reply->writeInt32(result);
return NO_ERROR;
} break;
case SET_DEFAULT_BUFFER_SIZE: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t w = data.readInt32();
uint32_t h = data.readInt32();
status_t result = setDefaultBufferSize(w, h);
reply->writeInt32(result);
return NO_ERROR;
} break;
case SET_DEFAULT_MAX_BUFFER_COUNT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t bufferCount = data.readInt32();
status_t result = setDefaultMaxBufferCount(bufferCount);
reply->writeInt32(result);
return NO_ERROR;
} break;
case DISABLE_ASYNC_BUFFER: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
status_t result = disableAsyncBuffer();
reply->writeInt32(result);
return NO_ERROR;
} break;
case SET_MAX_ACQUIRED_BUFFER_COUNT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t maxAcquiredBuffers = data.readInt32();
status_t result = setMaxAcquiredBufferCount(maxAcquiredBuffers);
reply->writeInt32(result);
return NO_ERROR;
} break;
case SET_CONSUMER_NAME: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
setConsumerName( data.readString8() );
return NO_ERROR;
} break;
case SET_DEFAULT_BUFFER_FORMAT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t defaultFormat = data.readInt32();
status_t result = setDefaultBufferFormat(defaultFormat);
reply->writeInt32(result);
return NO_ERROR;
} break;
case SET_CONSUMER_USAGE_BITS: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t usage = data.readInt32();
status_t result = setConsumerUsageBits(usage);
reply->writeInt32(result);
return NO_ERROR;
} break;
case SET_TRANSFORM_HINT: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
uint32_t hint = data.readInt32();
status_t result = setTransformHint(hint);
reply->writeInt32(result);
return NO_ERROR;
} break;
case DUMP: {
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
String8 result = data.readString8();
String8 prefix = data.readString8();
static_cast<IGraphicBufferConsumer*>(this)->dump(result, prefix);
reply->writeString8(result);
return NO_ERROR;
}
}
return BBinder::onTransact(code, data, reply, flags);
}
status_t BnAudioTrack::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case GET_CBLK: {
CHECK_INTERFACE(IAudioTrack, data, reply);
reply->writeStrongBinder(IInterface::asBinder(getCblk()));
return NO_ERROR;
} break;
case START: {
CHECK_INTERFACE(IAudioTrack, data, reply);
reply->writeInt32(start());
return NO_ERROR;
} break;
case STOP: {
CHECK_INTERFACE(IAudioTrack, data, reply);
stop();
return NO_ERROR;
} break;
case FLUSH: {
CHECK_INTERFACE(IAudioTrack, data, reply);
flush();
return NO_ERROR;
} break;
case PAUSE: {
CHECK_INTERFACE(IAudioTrack, data, reply);
pause();
return NO_ERROR;
}
case ATTACH_AUX_EFFECT: {
CHECK_INTERFACE(IAudioTrack, data, reply);
reply->writeInt32(attachAuxEffect(data.readInt32()));
return NO_ERROR;
} break;
case ALLOCATE_TIMED_BUFFER: {
CHECK_INTERFACE(IAudioTrack, data, reply);
sp<IMemory> buffer;
status_t status = allocateTimedBuffer(data.readInt64(), &buffer);
reply->writeInt32(status);
if (status == NO_ERROR) {
reply->writeStrongBinder(IInterface::asBinder(buffer));
}
return NO_ERROR;
} break;
case QUEUE_TIMED_BUFFER: {
CHECK_INTERFACE(IAudioTrack, data, reply);
sp<IMemory> buffer = interface_cast<IMemory>(
data.readStrongBinder());
uint64_t pts = data.readInt64();
reply->writeInt32(queueTimedBuffer(buffer, pts));
return NO_ERROR;
} break;
case SET_MEDIA_TIME_TRANSFORM: {
CHECK_INTERFACE(IAudioTrack, data, reply);
LinearTransform xform;
xform.a_zero = data.readInt64();
xform.b_zero = data.readInt64();
xform.a_to_b_numer = data.readInt32();
xform.a_to_b_denom = data.readInt32();
int target = data.readInt32();
reply->writeInt32(setMediaTimeTransform(xform, target));
return NO_ERROR;
} break;
case SET_PARAMETERS: {
CHECK_INTERFACE(IAudioTrack, data, reply);
String8 keyValuePairs(data.readString8());
reply->writeInt32(setParameters(keyValuePairs));
return NO_ERROR;
} break;
case GET_TIMESTAMP: {
CHECK_INTERFACE(IAudioTrack, data, reply);
AudioTimestamp timestamp;
status_t status = getTimestamp(timestamp);
reply->writeInt32(status);
if (status == NO_ERROR) {
reply->writeInt32(timestamp.mPosition);
reply->writeInt32(timestamp.mTime.tv_sec);
reply->writeInt32(timestamp.mTime.tv_nsec);
}
return NO_ERROR;
} break;
case SIGNAL: {
CHECK_INTERFACE(IAudioTrack, data, reply);
signal();
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnCameraRecordingProxy::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case START_RECORDING: {
ALOGV("START_RECORDING");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
unsigned int id = data.readInt32();
sp<ICameraRecordingProxyListener> listener =
interface_cast<ICameraRecordingProxyListener>(data.readStrongBinder());
reply->writeInt32(startRecording(listener, id));
return NO_ERROR;
} break;
case STOP_RECORDING: {
ALOGV("STOP_RECORDING");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
unsigned int id = data.readInt32();
stopRecording(id);
return NO_ERROR;
} break;
case RELEASE_RECORDING_FRAME: {
ALOGV("RELEASE_RECORDING_FRAME");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
int index = data.readInt32();
sp<IMemory> mem = interface_cast<IMemory>(data.readStrongBinder());
releaseRecordingFrame(mem, index);
return NO_ERROR;
} break;
case SET_PREVIEW_DISPLAY: {
ALOGV("SET_PREVIEW_DISPLAY");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
int hlay = data.readInt32();
reply->writeInt32(setPreviewDisplay(hlay));
return NO_ERROR;
} break;
case SEND_COMMAND: {
ALOGV("SEND_COMMAND");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
int32_t cmd = data.readInt32();
int32_t arg1 = data.readInt32();
int32_t arg2 = data.readInt32();
reply->writeInt32(sendCommand(cmd, arg1, arg2));
return NO_ERROR;
} break;
case LOCK: {
ALOGV("LOCK");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
reply->writeInt32(lock());
return NO_ERROR;
} break;
case UNLOCK: {
ALOGV("UNLOCK");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
reply->writeInt32(unlock());
return NO_ERROR;
} break;
case GET_PARAMETERS: {
ALOGV("GET_PARAMETERS");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
reply->writeString8(getParameters());
return NO_ERROR;
} break;
case SET_PARAMETERS: {
ALOGV("SET_PARAMETERS");
CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
String8 params(data.readString8());
reply->writeInt32(setParameters(params));
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}