IMediaPlayerService.cpp revision 81e68448f3361eaf8618930471fdc3c21bdf5cbc 
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/IDrm.h>
25#include <media/IHDCP.h>
26#include <media/IMediaHTTPService.h>
27#include <media/IMediaPlayerService.h>
28#include <media/IMediaRecorder.h>
29#include <media/IOMX.h>
30#include <media/IRemoteDisplay.h>
31#include <media/IRemoteDisplayClient.h>
32#include <media/IStreamSource.h>
33
34#include <utils/Errors.h>  // for status_t
35#include <utils/String8.h>
36
37namespace android {
38
39enum {
40    CREATE = IBinder::FIRST_CALL_TRANSACTION,
41    DECODE_URL,
42    DECODE_FD,
43    CREATE_MEDIA_RECORDER,
44    CREATE_METADATA_RETRIEVER,
45    GET_OMX,
46    MAKE_CRYPTO,
47    MAKE_DRM,
48    MAKE_HDCP,
49    ADD_BATTERY_DATA,
50    PULL_BATTERY_DATA,
51    LISTEN_FOR_REMOTE_DISPLAY,
52};
53
54class BpMediaPlayerService: public BpInterface<IMediaPlayerService>
55{
56public:
57    BpMediaPlayerService(const sp<IBinder>& impl)
58        : BpInterface<IMediaPlayerService>(impl)
59    {
60    }
61
62    virtual sp<IMediaMetadataRetriever> createMetadataRetriever()
63    {
64        Parcel data, reply;
65        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
66        remote()->transact(CREATE_METADATA_RETRIEVER, data, &reply);
67        return interface_cast<IMediaMetadataRetriever>(reply.readStrongBinder());
68    }
69
70    virtual sp<IMediaPlayer> create(
71            const sp<IMediaPlayerClient>& client, int audioSessionId) {
72        Parcel data, reply;
73        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
74        data.writeStrongBinder(client->asBinder());
75        data.writeInt32(audioSessionId);
76
77        remote()->transact(CREATE, data, &reply);
78        return interface_cast<IMediaPlayer>(reply.readStrongBinder());
79    }
80
81    virtual sp<IMediaRecorder> createMediaRecorder()
82    {
83        Parcel data, reply;
84        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
85        remote()->transact(CREATE_MEDIA_RECORDER, data, &reply);
86        return interface_cast<IMediaRecorder>(reply.readStrongBinder());
87    }
88
89    virtual status_t decode(
90            const sp<IMediaHTTPService> &httpService,
91            const char* url,
92            uint32_t *pSampleRate,
93            int* pNumChannels,
94            audio_format_t* pFormat,
95            const sp<IMemoryHeap>& heap,
96            size_t *pSize)
97    {
98        Parcel data, reply;
99        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
100        data.writeInt32(httpService != NULL);
101        if (httpService != NULL) {
102            data.writeStrongBinder(httpService->asBinder());
103        }
104        data.writeCString(url);
105        data.writeStrongBinder(heap->asBinder());
106        status_t status = remote()->transact(DECODE_URL, data, &reply);
107        if (status == NO_ERROR) {
108            status = (status_t)reply.readInt32();
109            if (status == NO_ERROR) {
110                *pSampleRate = uint32_t(reply.readInt32());
111                *pNumChannels = reply.readInt32();
112                *pFormat = (audio_format_t)reply.readInt32();
113                *pSize = (size_t)reply.readInt32();
114            }
115        }
116        return status;
117    }
118
119    virtual status_t decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate,
120                               int* pNumChannels, audio_format_t* pFormat,
121                               const sp<IMemoryHeap>& heap, size_t *pSize)
122    {
123        Parcel data, reply;
124        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
125        data.writeFileDescriptor(fd);
126        data.writeInt64(offset);
127        data.writeInt64(length);
128        data.writeStrongBinder(heap->asBinder());
129        status_t status = remote()->transact(DECODE_FD, data, &reply);
130        if (status == NO_ERROR) {
131            status = (status_t)reply.readInt32();
132            if (status == NO_ERROR) {
133                *pSampleRate = uint32_t(reply.readInt32());
134                *pNumChannels = reply.readInt32();
135                *pFormat = (audio_format_t)reply.readInt32();
136                *pSize = (size_t)reply.readInt32();
137            }
138        }
139        return status;
140    }
141
142    virtual sp<IOMX> getOMX() {
143        Parcel data, reply;
144        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
145        remote()->transact(GET_OMX, data, &reply);
146        return interface_cast<IOMX>(reply.readStrongBinder());
147    }
148
149    virtual sp<ICrypto> makeCrypto() {
150        Parcel data, reply;
151        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
152        remote()->transact(MAKE_CRYPTO, data, &reply);
153        return interface_cast<ICrypto>(reply.readStrongBinder());
154    }
155
156    virtual sp<IDrm> makeDrm() {
157        Parcel data, reply;
158        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
159        remote()->transact(MAKE_DRM, data, &reply);
160        return interface_cast<IDrm>(reply.readStrongBinder());
161    }
162
163    virtual sp<IHDCP> makeHDCP(bool createEncryptionModule) {
164        Parcel data, reply;
165        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
166        data.writeInt32(createEncryptionModule);
167        remote()->transact(MAKE_HDCP, data, &reply);
168        return interface_cast<IHDCP>(reply.readStrongBinder());
169    }
170
171    virtual void addBatteryData(uint32_t params) {
172        Parcel data, reply;
173        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
174        data.writeInt32(params);
175        remote()->transact(ADD_BATTERY_DATA, data, &reply);
176    }
177
178    virtual status_t pullBatteryData(Parcel* reply) {
179        Parcel data;
180        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
181        return remote()->transact(PULL_BATTERY_DATA, data, reply);
182    }
183
184    virtual sp<IRemoteDisplay> listenForRemoteDisplay(const sp<IRemoteDisplayClient>& client,
185            const String8& iface)
186    {
187        Parcel data, reply;
188        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
189        data.writeStrongBinder(client->asBinder());
190        data.writeString8(iface);
191        remote()->transact(LISTEN_FOR_REMOTE_DISPLAY, data, &reply);
192        return interface_cast<IRemoteDisplay>(reply.readStrongBinder());
193    }
194};
195
196IMPLEMENT_META_INTERFACE(MediaPlayerService, "android.media.IMediaPlayerService");
197
198// ----------------------------------------------------------------------
199
200status_t BnMediaPlayerService::onTransact(
201    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
202{
203    switch (code) {
204        case CREATE: {
205            CHECK_INTERFACE(IMediaPlayerService, data, reply);
206            sp<IMediaPlayerClient> client =
207                interface_cast<IMediaPlayerClient>(data.readStrongBinder());
208            int audioSessionId = data.readInt32();
209            sp<IMediaPlayer> player = create(client, audioSessionId);
210            reply->writeStrongBinder(player->asBinder());
211            return NO_ERROR;
212        } break;
213        case DECODE_URL: {
214            CHECK_INTERFACE(IMediaPlayerService, data, reply);
215            sp<IMediaHTTPService> httpService;
216            if (data.readInt32()) {
217                httpService =
218                    interface_cast<IMediaHTTPService>(data.readStrongBinder());
219            }
220            const char* url = data.readCString();
221            sp<IMemoryHeap> heap = interface_cast<IMemoryHeap>(data.readStrongBinder());
222            uint32_t sampleRate;
223            int numChannels;
224            audio_format_t format;
225            size_t size;
226            status_t status =
227                decode(httpService,
228                       url,
229                       &sampleRate,
230                       &numChannels,
231                       &format,
232                       heap,
233                       &size);
234            reply->writeInt32(status);
235            if (status == NO_ERROR) {
236                reply->writeInt32(sampleRate);
237                reply->writeInt32(numChannels);
238                reply->writeInt32((int32_t)format);
239                reply->writeInt32((int32_t)size);
240            }
241            return NO_ERROR;
242        } break;
243        case DECODE_FD: {
244            CHECK_INTERFACE(IMediaPlayerService, data, reply);
245            int fd = dup(data.readFileDescriptor());
246            int64_t offset = data.readInt64();
247            int64_t length = data.readInt64();
248            sp<IMemoryHeap> heap = interface_cast<IMemoryHeap>(data.readStrongBinder());
249            uint32_t sampleRate;
250            int numChannels;
251            audio_format_t format;
252            size_t size;
253            status_t status = decode(fd, offset, length, &sampleRate, &numChannels, &format,
254                                     heap, &size);
255            reply->writeInt32(status);
256            if (status == NO_ERROR) {
257                reply->writeInt32(sampleRate);
258                reply->writeInt32(numChannels);
259                reply->writeInt32((int32_t)format);
260                reply->writeInt32((int32_t)size);
261            }
262            return NO_ERROR;
263        } break;
264        case CREATE_MEDIA_RECORDER: {
265            CHECK_INTERFACE(IMediaPlayerService, data, reply);
266            sp<IMediaRecorder> recorder = createMediaRecorder();
267            reply->writeStrongBinder(recorder->asBinder());
268            return NO_ERROR;
269        } break;
270        case CREATE_METADATA_RETRIEVER: {
271            CHECK_INTERFACE(IMediaPlayerService, data, reply);
272            sp<IMediaMetadataRetriever> retriever = createMetadataRetriever();
273            reply->writeStrongBinder(retriever->asBinder());
274            return NO_ERROR;
275        } break;
276        case GET_OMX: {
277            CHECK_INTERFACE(IMediaPlayerService, data, reply);
278            sp<IOMX> omx = getOMX();
279            reply->writeStrongBinder(omx->asBinder());
280            return NO_ERROR;
281        } break;
282        case MAKE_CRYPTO: {
283            CHECK_INTERFACE(IMediaPlayerService, data, reply);
284            sp<ICrypto> crypto = makeCrypto();
285            reply->writeStrongBinder(crypto->asBinder());
286            return NO_ERROR;
287        } break;
288        case MAKE_DRM: {
289            CHECK_INTERFACE(IMediaPlayerService, data, reply);
290            sp<IDrm> drm = makeDrm();
291            reply->writeStrongBinder(drm->asBinder());
292            return NO_ERROR;
293        } break;
294        case MAKE_HDCP: {
295            CHECK_INTERFACE(IMediaPlayerService, data, reply);
296            bool createEncryptionModule = data.readInt32();
297            sp<IHDCP> hdcp = makeHDCP(createEncryptionModule);
298            reply->writeStrongBinder(hdcp->asBinder());
299            return NO_ERROR;
300        } break;
301        case ADD_BATTERY_DATA: {
302            CHECK_INTERFACE(IMediaPlayerService, data, reply);
303            uint32_t params = data.readInt32();
304            addBatteryData(params);
305            return NO_ERROR;
306        } break;
307        case PULL_BATTERY_DATA: {
308            CHECK_INTERFACE(IMediaPlayerService, data, reply);
309            pullBatteryData(reply);
310            return NO_ERROR;
311        } break;
312        case LISTEN_FOR_REMOTE_DISPLAY: {
313            CHECK_INTERFACE(IMediaPlayerService, data, reply);
314            sp<IRemoteDisplayClient> client(
315                    interface_cast<IRemoteDisplayClient>(data.readStrongBinder()));
316            String8 iface(data.readString8());
317            sp<IRemoteDisplay> display(listenForRemoteDisplay(client, iface));
318            reply->writeStrongBinder(display->asBinder());
319            return NO_ERROR;
320        } break;
321        default:
322            return BBinder::onTransact(code, data, reply, flags);
323    }
324}
325
326// ----------------------------------------------------------------------------
327
328}; // namespace android
329