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/IMediaCodecList.h>
27#include <media/IMediaHTTPService.h>
28#include <media/IMediaPlayerService.h>
29#include <media/IMediaRecorder.h>
30#include <media/IOMX.h>
31#include <media/IRemoteDisplay.h>
32#include <media/IRemoteDisplayClient.h>
33#include <media/IStreamSource.h>
34
35#include <utils/Errors.h>  // for status_t
36#include <utils/String8.h>
37
38namespace android {
39
40enum {
41    CREATE = IBinder::FIRST_CALL_TRANSACTION,
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    GET_CODEC_LIST,
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(IInterface::asBinder(client));
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(const String16 &opPackageName)
82    {
83        Parcel data, reply;
84        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
85        data.writeString16(opPackageName);
86        remote()->transact(CREATE_MEDIA_RECORDER, data, &reply);
87        return interface_cast<IMediaRecorder>(reply.readStrongBinder());
88    }
89
90    virtual sp<IOMX> getOMX() {
91        Parcel data, reply;
92        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
93        remote()->transact(GET_OMX, data, &reply);
94        return interface_cast<IOMX>(reply.readStrongBinder());
95    }
96
97    virtual sp<ICrypto> makeCrypto() {
98        Parcel data, reply;
99        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
100        remote()->transact(MAKE_CRYPTO, data, &reply);
101        return interface_cast<ICrypto>(reply.readStrongBinder());
102    }
103
104    virtual sp<IDrm> makeDrm() {
105        Parcel data, reply;
106        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
107        remote()->transact(MAKE_DRM, data, &reply);
108        return interface_cast<IDrm>(reply.readStrongBinder());
109    }
110
111    virtual sp<IHDCP> makeHDCP(bool createEncryptionModule) {
112        Parcel data, reply;
113        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
114        data.writeInt32(createEncryptionModule);
115        remote()->transact(MAKE_HDCP, data, &reply);
116        return interface_cast<IHDCP>(reply.readStrongBinder());
117    }
118
119    virtual void addBatteryData(uint32_t params) {
120        Parcel data, reply;
121        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
122        data.writeInt32(params);
123        remote()->transact(ADD_BATTERY_DATA, data, &reply);
124    }
125
126    virtual status_t pullBatteryData(Parcel* reply) {
127        Parcel data;
128        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
129        return remote()->transact(PULL_BATTERY_DATA, data, reply);
130    }
131
132    virtual sp<IRemoteDisplay> listenForRemoteDisplay(const String16 &opPackageName,
133            const sp<IRemoteDisplayClient>& client, const String8& iface)
134    {
135        Parcel data, reply;
136        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
137        data.writeString16(opPackageName);
138        data.writeStrongBinder(IInterface::asBinder(client));
139        data.writeString8(iface);
140        remote()->transact(LISTEN_FOR_REMOTE_DISPLAY, data, &reply);
141        return interface_cast<IRemoteDisplay>(reply.readStrongBinder());
142    }
143
144    virtual sp<IMediaCodecList> getCodecList() const {
145        Parcel data, reply;
146        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
147        remote()->transact(GET_CODEC_LIST, data, &reply);
148        return interface_cast<IMediaCodecList>(reply.readStrongBinder());
149    }
150};
151
152IMPLEMENT_META_INTERFACE(MediaPlayerService, "android.media.IMediaPlayerService");
153
154// ----------------------------------------------------------------------
155
156status_t BnMediaPlayerService::onTransact(
157    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
158{
159    switch (code) {
160        case CREATE: {
161            CHECK_INTERFACE(IMediaPlayerService, data, reply);
162            sp<IMediaPlayerClient> client =
163                interface_cast<IMediaPlayerClient>(data.readStrongBinder());
164            int audioSessionId = data.readInt32();
165            sp<IMediaPlayer> player = create(client, audioSessionId);
166            reply->writeStrongBinder(IInterface::asBinder(player));
167            return NO_ERROR;
168        } break;
169        case CREATE_MEDIA_RECORDER: {
170            CHECK_INTERFACE(IMediaPlayerService, data, reply);
171            const String16 opPackageName = data.readString16();
172            sp<IMediaRecorder> recorder = createMediaRecorder(opPackageName);
173            reply->writeStrongBinder(IInterface::asBinder(recorder));
174            return NO_ERROR;
175        } break;
176        case CREATE_METADATA_RETRIEVER: {
177            CHECK_INTERFACE(IMediaPlayerService, data, reply);
178            sp<IMediaMetadataRetriever> retriever = createMetadataRetriever();
179            reply->writeStrongBinder(IInterface::asBinder(retriever));
180            return NO_ERROR;
181        } break;
182        case GET_OMX: {
183            CHECK_INTERFACE(IMediaPlayerService, data, reply);
184            sp<IOMX> omx = getOMX();
185            reply->writeStrongBinder(IInterface::asBinder(omx));
186            return NO_ERROR;
187        } break;
188        case MAKE_CRYPTO: {
189            CHECK_INTERFACE(IMediaPlayerService, data, reply);
190            sp<ICrypto> crypto = makeCrypto();
191            reply->writeStrongBinder(IInterface::asBinder(crypto));
192            return NO_ERROR;
193        } break;
194        case MAKE_DRM: {
195            CHECK_INTERFACE(IMediaPlayerService, data, reply);
196            sp<IDrm> drm = makeDrm();
197            reply->writeStrongBinder(IInterface::asBinder(drm));
198            return NO_ERROR;
199        } break;
200        case MAKE_HDCP: {
201            CHECK_INTERFACE(IMediaPlayerService, data, reply);
202            bool createEncryptionModule = data.readInt32();
203            sp<IHDCP> hdcp = makeHDCP(createEncryptionModule);
204            reply->writeStrongBinder(IInterface::asBinder(hdcp));
205            return NO_ERROR;
206        } break;
207        case ADD_BATTERY_DATA: {
208            CHECK_INTERFACE(IMediaPlayerService, data, reply);
209            uint32_t params = data.readInt32();
210            addBatteryData(params);
211            return NO_ERROR;
212        } break;
213        case PULL_BATTERY_DATA: {
214            CHECK_INTERFACE(IMediaPlayerService, data, reply);
215            pullBatteryData(reply);
216            return NO_ERROR;
217        } break;
218        case LISTEN_FOR_REMOTE_DISPLAY: {
219            CHECK_INTERFACE(IMediaPlayerService, data, reply);
220            const String16 opPackageName = data.readString16();
221            sp<IRemoteDisplayClient> client(
222                    interface_cast<IRemoteDisplayClient>(data.readStrongBinder()));
223            String8 iface(data.readString8());
224            sp<IRemoteDisplay> display(listenForRemoteDisplay(opPackageName, client, iface));
225            reply->writeStrongBinder(IInterface::asBinder(display));
226            return NO_ERROR;
227        } break;
228        case GET_CODEC_LIST: {
229            CHECK_INTERFACE(IMediaPlayerService, data, reply);
230            sp<IMediaCodecList> mcl = getCodecList();
231            reply->writeStrongBinder(IInterface::asBinder(mcl));
232            return NO_ERROR;
233        } break;
234        default:
235            return BBinder::onTransact(code, data, reply, flags);
236    }
237}
238
239// ----------------------------------------------------------------------------
240
241} // namespace android
242