IMediaPlayerService.cpp revision 441a78d5e224e0d67f9b52fa9adc795c6944159b 
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/IMediaPlayerService.h>
27#include <media/IMediaRecorder.h>
28#include <media/IOMX.h>
29#include <media/IRemoteDisplay.h>
30#include <media/IRemoteDisplayClient.h>
31#include <media/IStreamSource.h>
32
33#include <utils/Errors.h>  // for status_t
34#include <utils/String8.h>
35
36namespace android {
37
38enum {
39    CREATE = IBinder::FIRST_CALL_TRANSACTION,
40    DECODE_URL,
41    DECODE_FD,
42    CREATE_MEDIA_RECORDER,
43    CREATE_METADATA_RETRIEVER,
44    GET_OMX,
45    MAKE_CRYPTO,
46    MAKE_DRM,
47    MAKE_HDCP,
48    ADD_BATTERY_DATA,
49    PULL_BATTERY_DATA,
50    LISTEN_FOR_REMOTE_DISPLAY,
51};
52
53class BpMediaPlayerService: public BpInterface<IMediaPlayerService>
54{
55public:
56    BpMediaPlayerService(const sp<IBinder>& impl)
57        : BpInterface<IMediaPlayerService>(impl)
58    {
59    }
60
61    virtual sp<IMediaMetadataRetriever> createMetadataRetriever()
62    {
63        Parcel data, reply;
64        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
65        remote()->transact(CREATE_METADATA_RETRIEVER, data, &reply);
66        return interface_cast<IMediaMetadataRetriever>(reply.readStrongBinder());
67    }
68
69    virtual sp<IMediaPlayer> create(
70            const sp<IMediaPlayerClient>& client, int audioSessionId) {
71        Parcel data, reply;
72        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
73        data.writeStrongBinder(client->asBinder());
74        data.writeInt32(audioSessionId);
75
76        remote()->transact(CREATE, data, &reply);
77        return interface_cast<IMediaPlayer>(reply.readStrongBinder());
78    }
79
80    virtual sp<IMediaRecorder> createMediaRecorder()
81    {
82        Parcel data, reply;
83        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
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 sp<IDrm> makeDrm() {
129        Parcel data, reply;
130        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
131        remote()->transact(MAKE_DRM, data, &reply);
132        return interface_cast<IDrm>(reply.readStrongBinder());
133    }
134
135    virtual sp<IHDCP> makeHDCP(bool createEncryptionModule) {
136        Parcel data, reply;
137        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
138        data.writeInt32(createEncryptionModule);
139        remote()->transact(MAKE_HDCP, data, &reply);
140        return interface_cast<IHDCP>(reply.readStrongBinder());
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            sp<IMediaPlayerClient> client =
179                interface_cast<IMediaPlayerClient>(data.readStrongBinder());
180            int audioSessionId = data.readInt32();
181            sp<IMediaPlayer> player = create(client, audioSessionId);
182            reply->writeStrongBinder(player->asBinder());
183            return NO_ERROR;
184        } break;
185        case DECODE_URL: {
186            CHECK_INTERFACE(IMediaPlayerService, data, reply);
187            const char* url = data.readCString();
188            uint32_t sampleRate;
189            int numChannels;
190            audio_format_t format;
191            sp<IMemory> player = decode(url, &sampleRate, &numChannels, &format);
192            reply->writeInt32(sampleRate);
193            reply->writeInt32(numChannels);
194            reply->writeInt32((int32_t) format);
195            reply->writeStrongBinder(player->asBinder());
196            return NO_ERROR;
197        } break;
198        case DECODE_FD: {
199            CHECK_INTERFACE(IMediaPlayerService, data, reply);
200            int fd = dup(data.readFileDescriptor());
201            int64_t offset = data.readInt64();
202            int64_t length = data.readInt64();
203            uint32_t sampleRate;
204            int numChannels;
205            audio_format_t format;
206            sp<IMemory> player = decode(fd, offset, length, &sampleRate, &numChannels, &format);
207            reply->writeInt32(sampleRate);
208            reply->writeInt32(numChannels);
209            reply->writeInt32((int32_t) format);
210            reply->writeStrongBinder(player->asBinder());
211            return NO_ERROR;
212        } break;
213        case CREATE_MEDIA_RECORDER: {
214            CHECK_INTERFACE(IMediaPlayerService, data, reply);
215            sp<IMediaRecorder> recorder = createMediaRecorder();
216            reply->writeStrongBinder(recorder->asBinder());
217            return NO_ERROR;
218        } break;
219        case CREATE_METADATA_RETRIEVER: {
220            CHECK_INTERFACE(IMediaPlayerService, data, reply);
221            sp<IMediaMetadataRetriever> retriever = createMetadataRetriever();
222            reply->writeStrongBinder(retriever->asBinder());
223            return NO_ERROR;
224        } break;
225        case GET_OMX: {
226            CHECK_INTERFACE(IMediaPlayerService, data, reply);
227            sp<IOMX> omx = getOMX();
228            reply->writeStrongBinder(omx->asBinder());
229            return NO_ERROR;
230        } break;
231        case MAKE_CRYPTO: {
232            CHECK_INTERFACE(IMediaPlayerService, data, reply);
233            sp<ICrypto> crypto = makeCrypto();
234            reply->writeStrongBinder(crypto->asBinder());
235            return NO_ERROR;
236        } break;
237        case MAKE_DRM: {
238            CHECK_INTERFACE(IMediaPlayerService, data, reply);
239            sp<IDrm> drm = makeDrm();
240            reply->writeStrongBinder(drm->asBinder());
241            return NO_ERROR;
242        } break;
243        case MAKE_HDCP: {
244            CHECK_INTERFACE(IMediaPlayerService, data, reply);
245            bool createEncryptionModule = data.readInt32();
246            sp<IHDCP> hdcp = makeHDCP(createEncryptionModule);
247            reply->writeStrongBinder(hdcp->asBinder());
248            return NO_ERROR;
249        } break;
250        case ADD_BATTERY_DATA: {
251            CHECK_INTERFACE(IMediaPlayerService, data, reply);
252            uint32_t params = data.readInt32();
253            addBatteryData(params);
254            return NO_ERROR;
255        } break;
256        case PULL_BATTERY_DATA: {
257            CHECK_INTERFACE(IMediaPlayerService, data, reply);
258            pullBatteryData(reply);
259            return NO_ERROR;
260        } break;
261        case LISTEN_FOR_REMOTE_DISPLAY: {
262            CHECK_INTERFACE(IMediaPlayerService, data, reply);
263            sp<IRemoteDisplayClient> client(
264                    interface_cast<IRemoteDisplayClient>(data.readStrongBinder()));
265            String8 iface(data.readString8());
266            sp<IRemoteDisplay> display(listenForRemoteDisplay(client, iface));
267            reply->writeStrongBinder(display->asBinder());
268            return NO_ERROR;
269        } break;
270        default:
271            return BBinder::onTransact(code, data, reply, flags);
272    }
273}
274
275// ----------------------------------------------------------------------------
276
277}; // namespace android
278