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