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