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 
38 namespace android {
39 
40 enum {
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 
54 class BpMediaPlayerService: public BpInterface<IMediaPlayerService>
55 {
56 public:
BpMediaPlayerService(const sp<IBinder> & impl)57     BpMediaPlayerService(const sp<IBinder>& impl)
58         : BpInterface<IMediaPlayerService>(impl)
59     {
60     }
61 
createMetadataRetriever()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 
create(const sp<IMediaPlayerClient> & client,int audioSessionId)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 
createMediaRecorder(const String16 & opPackageName)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 
getOMX()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 
makeCrypto()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 
makeDrm()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 
makeHDCP(bool createEncryptionModule)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 
addBatteryData(uint32_t params)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 
pullBatteryData(Parcel * reply)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 
listenForRemoteDisplay(const String16 & opPackageName,const sp<IRemoteDisplayClient> & client,const String8 & iface)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 
getCodecList() const144     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 
152 IMPLEMENT_META_INTERFACE(MediaPlayerService, "android.media.IMediaPlayerService");
153 
154 // ----------------------------------------------------------------------
155 
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)156 status_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