IMediaPlayerService.cpp revision e104596061b219e9bce6d4db49a9d15242f8d2e5
1/* 2** 3** Copyright 2008, The Android Open Source Project 4** 5** Licensed under the Apache License, Version 2.0 (the "License"); 6** you may not use this file except in compliance with the License. 7** You may obtain a copy of the License at 8** 9** http://www.apache.org/licenses/LICENSE-2.0 10** 11** Unless required by applicable law or agreed to in writing, software 12** distributed under the License is distributed on an "AS IS" BASIS, 13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14** See the License for the specific language governing permissions and 15** limitations under the License. 16*/ 17 18#include <stdint.h> 19#include <sys/types.h> 20 21#include <binder/Parcel.h> 22#include <binder/IMemory.h> 23#include <media/ICrypto.h> 24#include <media/IMediaPlayerService.h> 25#include <media/IMediaRecorder.h> 26#include <media/IOMX.h> 27#include <media/IRemoteDisplay.h> 28#include <media/IRemoteDisplayClient.h> 29#include <media/IStreamSource.h> 30 31#include <utils/Errors.h> // for status_t 32#include <utils/String8.h> 33 34namespace android { 35 36enum { 37 CREATE = IBinder::FIRST_CALL_TRANSACTION, 38 DECODE_URL, 39 DECODE_FD, 40 CREATE_MEDIA_RECORDER, 41 CREATE_METADATA_RETRIEVER, 42 GET_OMX, 43 MAKE_CRYPTO, 44 ENABLE_REMOTE_DISPLAY, 45 ADD_BATTERY_DATA, 46 PULL_BATTERY_DATA, 47 LISTEN_FOR_REMOTE_DISPLAY, 48}; 49 50class BpMediaPlayerService: public BpInterface<IMediaPlayerService> 51{ 52public: 53 BpMediaPlayerService(const sp<IBinder>& impl) 54 : BpInterface<IMediaPlayerService>(impl) 55 { 56 } 57 58 virtual sp<IMediaMetadataRetriever> createMetadataRetriever(pid_t pid) 59 { 60 Parcel data, reply; 61 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 62 data.writeInt32(pid); 63 remote()->transact(CREATE_METADATA_RETRIEVER, data, &reply); 64 return interface_cast<IMediaMetadataRetriever>(reply.readStrongBinder()); 65 } 66 67 virtual sp<IMediaPlayer> create( 68 pid_t pid, const sp<IMediaPlayerClient>& client, int audioSessionId) { 69 Parcel data, reply; 70 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 71 data.writeInt32(pid); 72 data.writeStrongBinder(client->asBinder()); 73 data.writeInt32(audioSessionId); 74 75 remote()->transact(CREATE, data, &reply); 76 return interface_cast<IMediaPlayer>(reply.readStrongBinder()); 77 } 78 79 virtual sp<IMediaRecorder> createMediaRecorder(pid_t pid) 80 { 81 Parcel data, reply; 82 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 83 data.writeInt32(pid); 84 remote()->transact(CREATE_MEDIA_RECORDER, data, &reply); 85 return interface_cast<IMediaRecorder>(reply.readStrongBinder()); 86 } 87 88 virtual sp<IMemory> decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, audio_format_t* pFormat) 89 { 90 Parcel data, reply; 91 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 92 data.writeCString(url); 93 remote()->transact(DECODE_URL, data, &reply); 94 *pSampleRate = uint32_t(reply.readInt32()); 95 *pNumChannels = reply.readInt32(); 96 *pFormat = (audio_format_t) reply.readInt32(); 97 return interface_cast<IMemory>(reply.readStrongBinder()); 98 } 99 100 virtual sp<IMemory> decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, audio_format_t* pFormat) 101 { 102 Parcel data, reply; 103 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 104 data.writeFileDescriptor(fd); 105 data.writeInt64(offset); 106 data.writeInt64(length); 107 remote()->transact(DECODE_FD, data, &reply); 108 *pSampleRate = uint32_t(reply.readInt32()); 109 *pNumChannels = reply.readInt32(); 110 *pFormat = (audio_format_t) reply.readInt32(); 111 return interface_cast<IMemory>(reply.readStrongBinder()); 112 } 113 114 virtual sp<IOMX> getOMX() { 115 Parcel data, reply; 116 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 117 remote()->transact(GET_OMX, data, &reply); 118 return interface_cast<IOMX>(reply.readStrongBinder()); 119 } 120 121 virtual sp<ICrypto> makeCrypto() { 122 Parcel data, reply; 123 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 124 remote()->transact(MAKE_CRYPTO, data, &reply); 125 return interface_cast<ICrypto>(reply.readStrongBinder()); 126 } 127 128 virtual status_t enableRemoteDisplay(const char *iface) { 129 Parcel data, reply; 130 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 131 132 if (iface != NULL) { 133 data.writeInt32(1); 134 data.writeCString(iface); 135 } else { 136 data.writeInt32(0); 137 } 138 139 remote()->transact(ENABLE_REMOTE_DISPLAY, data, &reply); 140 return reply.readInt32(); 141 } 142 143 virtual void addBatteryData(uint32_t params) { 144 Parcel data, reply; 145 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 146 data.writeInt32(params); 147 remote()->transact(ADD_BATTERY_DATA, data, &reply); 148 } 149 150 virtual status_t pullBatteryData(Parcel* reply) { 151 Parcel data; 152 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 153 return remote()->transact(PULL_BATTERY_DATA, data, reply); 154 } 155 156 virtual sp<IRemoteDisplay> listenForRemoteDisplay(const sp<IRemoteDisplayClient>& client, 157 const String8& iface) 158 { 159 Parcel data, reply; 160 data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); 161 data.writeStrongBinder(client->asBinder()); 162 data.writeString8(iface); 163 remote()->transact(LISTEN_FOR_REMOTE_DISPLAY, data, &reply); 164 return interface_cast<IRemoteDisplay>(reply.readStrongBinder()); 165 } 166}; 167 168IMPLEMENT_META_INTERFACE(MediaPlayerService, "android.media.IMediaPlayerService"); 169 170// ---------------------------------------------------------------------- 171 172status_t BnMediaPlayerService::onTransact( 173 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 174{ 175 switch (code) { 176 case CREATE: { 177 CHECK_INTERFACE(IMediaPlayerService, data, reply); 178 pid_t pid = data.readInt32(); 179 sp<IMediaPlayerClient> client = 180 interface_cast<IMediaPlayerClient>(data.readStrongBinder()); 181 int audioSessionId = data.readInt32(); 182 sp<IMediaPlayer> player = create(pid, client, audioSessionId); 183 reply->writeStrongBinder(player->asBinder()); 184 return NO_ERROR; 185 } break; 186 case DECODE_URL: { 187 CHECK_INTERFACE(IMediaPlayerService, data, reply); 188 const char* url = data.readCString(); 189 uint32_t sampleRate; 190 int numChannels; 191 audio_format_t format; 192 sp<IMemory> player = decode(url, &sampleRate, &numChannels, &format); 193 reply->writeInt32(sampleRate); 194 reply->writeInt32(numChannels); 195 reply->writeInt32((int32_t) format); 196 reply->writeStrongBinder(player->asBinder()); 197 return NO_ERROR; 198 } break; 199 case DECODE_FD: { 200 CHECK_INTERFACE(IMediaPlayerService, data, reply); 201 int fd = dup(data.readFileDescriptor()); 202 int64_t offset = data.readInt64(); 203 int64_t length = data.readInt64(); 204 uint32_t sampleRate; 205 int numChannels; 206 audio_format_t format; 207 sp<IMemory> player = decode(fd, offset, length, &sampleRate, &numChannels, &format); 208 reply->writeInt32(sampleRate); 209 reply->writeInt32(numChannels); 210 reply->writeInt32((int32_t) format); 211 reply->writeStrongBinder(player->asBinder()); 212 return NO_ERROR; 213 } break; 214 case CREATE_MEDIA_RECORDER: { 215 CHECK_INTERFACE(IMediaPlayerService, data, reply); 216 pid_t pid = data.readInt32(); 217 sp<IMediaRecorder> recorder = createMediaRecorder(pid); 218 reply->writeStrongBinder(recorder->asBinder()); 219 return NO_ERROR; 220 } break; 221 case CREATE_METADATA_RETRIEVER: { 222 CHECK_INTERFACE(IMediaPlayerService, data, reply); 223 pid_t pid = data.readInt32(); 224 sp<IMediaMetadataRetriever> retriever = createMetadataRetriever(pid); 225 reply->writeStrongBinder(retriever->asBinder()); 226 return NO_ERROR; 227 } break; 228 case GET_OMX: { 229 CHECK_INTERFACE(IMediaPlayerService, data, reply); 230 sp<IOMX> omx = getOMX(); 231 reply->writeStrongBinder(omx->asBinder()); 232 return NO_ERROR; 233 } break; 234 case MAKE_CRYPTO: { 235 CHECK_INTERFACE(IMediaPlayerService, data, reply); 236 sp<ICrypto> crypto = makeCrypto(); 237 reply->writeStrongBinder(crypto->asBinder()); 238 return NO_ERROR; 239 } break; 240 case ENABLE_REMOTE_DISPLAY: { 241 CHECK_INTERFACE(IMediaPlayerService, data, reply); 242 const char *iface = NULL; 243 if (data.readInt32()) { 244 iface = data.readCString(); 245 } 246 reply->writeInt32(enableRemoteDisplay(iface)); 247 return NO_ERROR; 248 } break; 249 case ADD_BATTERY_DATA: { 250 CHECK_INTERFACE(IMediaPlayerService, data, reply); 251 uint32_t params = data.readInt32(); 252 addBatteryData(params); 253 return NO_ERROR; 254 } break; 255 case PULL_BATTERY_DATA: { 256 CHECK_INTERFACE(IMediaPlayerService, data, reply); 257 pullBatteryData(reply); 258 return NO_ERROR; 259 } break; 260 case LISTEN_FOR_REMOTE_DISPLAY: { 261 CHECK_INTERFACE(IMediaPlayerService, data, reply); 262 sp<IRemoteDisplayClient> client( 263 interface_cast<IRemoteDisplayClient>(data.readStrongBinder())); 264 String8 iface(data.readString8()); 265 sp<IRemoteDisplay> display(listenForRemoteDisplay(client, iface)); 266 reply->writeStrongBinder(display->asBinder()); 267 return NO_ERROR; 268 } break; 269 default: 270 return BBinder::onTransact(code, data, reply, flags); 271 } 272} 273 274// ---------------------------------------------------------------------------- 275 276}; // namespace android 277