The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 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> |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 20 | |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 21 | #include <binder/Parcel.h> |
Mathias Agopian | 7562408 | 2009-05-19 19:08:10 -0700 | [diff] [blame] | 22 | #include <binder/IMemory.h> |
Andreas Huber | ed3e3e0 | 2012-03-26 11:13:27 -0700 | [diff] [blame] | 23 | #include <media/ICrypto.h> |
Jeff Tinker | cc82dc6 | 2013-02-08 10:18:35 -0800 | [diff] [blame] | 24 | #include <media/IDrm.h> |
Andreas Huber | 59451f8 | 2012-09-18 10:36:32 -0700 | [diff] [blame] | 25 | #include <media/IHDCP.h> |
Lajos Molnar | 1381d4b | 2014-08-07 15:18:35 -0700 | [diff] [blame] | 26 | #include <media/IMediaCodecList.h> |
Andreas Huber | 1b86fe0 | 2014-01-29 11:13:26 -0800 | [diff] [blame] | 27 | #include <media/IMediaHTTPService.h> |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 28 | #include <media/IMediaPlayerService.h> |
| 29 | #include <media/IMediaRecorder.h> |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 30 | #include <media/IOMX.h> |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 31 | #include <media/IRemoteDisplay.h> |
| 32 | #include <media/IRemoteDisplayClient.h> |
Andreas Huber | e2b1028 | 2010-11-23 11:41:34 -0800 | [diff] [blame] | 33 | #include <media/IStreamSource.h> |
Andreas Huber | 20111aa | 2009-07-14 16:56:47 -0700 | [diff] [blame] | 34 | |
| 35 | #include <utils/Errors.h> // for status_t |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 36 | #include <utils/String8.h> |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 37 | |
| 38 | namespace android { |
| 39 | |
| 40 | enum { |
Dave Burke | d681bbb | 2011-08-30 14:39:17 +0100 | [diff] [blame] | 41 | CREATE = IBinder::FIRST_CALL_TRANSACTION, |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 42 | CREATE_MEDIA_RECORDER, |
| 43 | CREATE_METADATA_RETRIEVER, |
Marco Nelissen | 260e56c | 2016-01-28 21:41:25 +0000 | [diff] [blame^] | 44 | GET_OMX, |
Andreas Huber | ed3e3e0 | 2012-03-26 11:13:27 -0700 | [diff] [blame] | 45 | MAKE_CRYPTO, |
Jeff Tinker | cc82dc6 | 2013-02-08 10:18:35 -0800 | [diff] [blame] | 46 | MAKE_DRM, |
Andreas Huber | 59451f8 | 2012-09-18 10:36:32 -0700 | [diff] [blame] | 47 | MAKE_HDCP, |
Gloria Wang | 7cf180c | 2011-02-19 18:37:57 -0800 | [diff] [blame] | 48 | ADD_BATTERY_DATA, |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 49 | PULL_BATTERY_DATA, |
| 50 | LISTEN_FOR_REMOTE_DISPLAY, |
Lajos Molnar | 1381d4b | 2014-08-07 15:18:35 -0700 | [diff] [blame] | 51 | GET_CODEC_LIST, |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 52 | }; |
| 53 | |
| 54 | class BpMediaPlayerService: public BpInterface<IMediaPlayerService> |
| 55 | { |
| 56 | public: |
| 57 | BpMediaPlayerService(const sp<IBinder>& impl) |
| 58 | : BpInterface<IMediaPlayerService>(impl) |
| 59 | { |
| 60 | } |
| 61 | |
Glenn Kasten | f37971f | 2012-02-03 11:06:53 -0800 | [diff] [blame] | 62 | virtual sp<IMediaMetadataRetriever> createMetadataRetriever() |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 63 | { |
| 64 | Parcel data, reply; |
| 65 | data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 66 | remote()->transact(CREATE_METADATA_RETRIEVER, data, &reply); |
| 67 | return interface_cast<IMediaMetadataRetriever>(reply.readStrongBinder()); |
| 68 | } |
| 69 | |
Andreas Huber | 2db8455 | 2010-01-28 11:19:57 -0800 | [diff] [blame] | 70 | virtual sp<IMediaPlayer> create( |
Glenn Kasten | f37971f | 2012-02-03 11:06:53 -0800 | [diff] [blame] | 71 | const sp<IMediaPlayerClient>& client, int audioSessionId) { |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 72 | Parcel data, reply; |
| 73 | data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); |
Marco Nelissen | f888020 | 2014-11-14 07:58:25 -0800 | [diff] [blame] | 74 | data.writeStrongBinder(IInterface::asBinder(client)); |
Eric Laurent | a514bdb | 2010-06-21 09:27:30 -0700 | [diff] [blame] | 75 | data.writeInt32(audioSessionId); |
Andreas Huber | 2db8455 | 2010-01-28 11:19:57 -0800 | [diff] [blame] | 76 | |
Dave Burke | d681bbb | 2011-08-30 14:39:17 +0100 | [diff] [blame] | 77 | remote()->transact(CREATE, data, &reply); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 78 | return interface_cast<IMediaPlayer>(reply.readStrongBinder()); |
| 79 | } |
| 80 | |
Svet Ganov | be71aa2 | 2015-04-28 12:06:02 -0700 | [diff] [blame] | 81 | virtual sp<IMediaRecorder> createMediaRecorder(const String16 &opPackageName) |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 82 | { |
| 83 | Parcel data, reply; |
| 84 | data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); |
Svet Ganov | be71aa2 | 2015-04-28 12:06:02 -0700 | [diff] [blame] | 85 | data.writeString16(opPackageName); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 86 | remote()->transact(CREATE_MEDIA_RECORDER, data, &reply); |
| 87 | return interface_cast<IMediaRecorder>(reply.readStrongBinder()); |
| 88 | } |
| 89 | |
Marco Nelissen | 260e56c | 2016-01-28 21:41:25 +0000 | [diff] [blame^] | 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 | } |
Gloria Wang | 7cf180c | 2011-02-19 18:37:57 -0800 | [diff] [blame] | 96 | |
Andreas Huber | ed3e3e0 | 2012-03-26 11:13:27 -0700 | [diff] [blame] | 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 | |
Jeff Tinker | cc82dc6 | 2013-02-08 10:18:35 -0800 | [diff] [blame] | 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 | |
Andreas Huber | 279dcd8 | 2013-01-30 10:41:25 -0800 | [diff] [blame] | 111 | virtual sp<IHDCP> makeHDCP(bool createEncryptionModule) { |
Andreas Huber | 59451f8 | 2012-09-18 10:36:32 -0700 | [diff] [blame] | 112 | Parcel data, reply; |
| 113 | data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); |
Andreas Huber | 279dcd8 | 2013-01-30 10:41:25 -0800 | [diff] [blame] | 114 | data.writeInt32(createEncryptionModule); |
Andreas Huber | 59451f8 | 2012-09-18 10:36:32 -0700 | [diff] [blame] | 115 | remote()->transact(MAKE_HDCP, data, &reply); |
| 116 | return interface_cast<IHDCP>(reply.readStrongBinder()); |
| 117 | } |
| 118 | |
Gloria Wang | 7cf180c | 2011-02-19 18:37:57 -0800 | [diff] [blame] | 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 | } |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 131 | |
Svet Ganov | be71aa2 | 2015-04-28 12:06:02 -0700 | [diff] [blame] | 132 | virtual sp<IRemoteDisplay> listenForRemoteDisplay(const String16 &opPackageName, |
| 133 | const sp<IRemoteDisplayClient>& client, const String8& iface) |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 134 | { |
| 135 | Parcel data, reply; |
| 136 | data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); |
Svet Ganov | be71aa2 | 2015-04-28 12:06:02 -0700 | [diff] [blame] | 137 | data.writeString16(opPackageName); |
Marco Nelissen | f888020 | 2014-11-14 07:58:25 -0800 | [diff] [blame] | 138 | data.writeStrongBinder(IInterface::asBinder(client)); |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 139 | data.writeString8(iface); |
| 140 | remote()->transact(LISTEN_FOR_REMOTE_DISPLAY, data, &reply); |
| 141 | return interface_cast<IRemoteDisplay>(reply.readStrongBinder()); |
| 142 | } |
Lajos Molnar | 1381d4b | 2014-08-07 15:18:35 -0700 | [diff] [blame] | 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 | } |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 150 | }; |
| 151 | |
niko | 56f0cc5 | 2009-06-22 08:49:52 -0700 | [diff] [blame] | 152 | IMPLEMENT_META_INTERFACE(MediaPlayerService, "android.media.IMediaPlayerService"); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 153 | |
| 154 | // ---------------------------------------------------------------------- |
| 155 | |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 156 | status_t BnMediaPlayerService::onTransact( |
| 157 | uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) |
| 158 | { |
Glenn Kasten | e53b9ea | 2012-03-12 16:29:55 -0700 | [diff] [blame] | 159 | switch (code) { |
Dave Burke | d681bbb | 2011-08-30 14:39:17 +0100 | [diff] [blame] | 160 | case CREATE: { |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 161 | CHECK_INTERFACE(IMediaPlayerService, data, reply); |
Andreas Huber | 2db8455 | 2010-01-28 11:19:57 -0800 | [diff] [blame] | 162 | sp<IMediaPlayerClient> client = |
| 163 | interface_cast<IMediaPlayerClient>(data.readStrongBinder()); |
Eric Laurent | a514bdb | 2010-06-21 09:27:30 -0700 | [diff] [blame] | 164 | int audioSessionId = data.readInt32(); |
Glenn Kasten | f37971f | 2012-02-03 11:06:53 -0800 | [diff] [blame] | 165 | sp<IMediaPlayer> player = create(client, audioSessionId); |
Marco Nelissen | f888020 | 2014-11-14 07:58:25 -0800 | [diff] [blame] | 166 | reply->writeStrongBinder(IInterface::asBinder(player)); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 167 | return NO_ERROR; |
| 168 | } break; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 169 | case CREATE_MEDIA_RECORDER: { |
| 170 | CHECK_INTERFACE(IMediaPlayerService, data, reply); |
Svet Ganov | be71aa2 | 2015-04-28 12:06:02 -0700 | [diff] [blame] | 171 | const String16 opPackageName = data.readString16(); |
| 172 | sp<IMediaRecorder> recorder = createMediaRecorder(opPackageName); |
Marco Nelissen | f888020 | 2014-11-14 07:58:25 -0800 | [diff] [blame] | 173 | reply->writeStrongBinder(IInterface::asBinder(recorder)); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 174 | return NO_ERROR; |
| 175 | } break; |
| 176 | case CREATE_METADATA_RETRIEVER: { |
| 177 | CHECK_INTERFACE(IMediaPlayerService, data, reply); |
Glenn Kasten | f37971f | 2012-02-03 11:06:53 -0800 | [diff] [blame] | 178 | sp<IMediaMetadataRetriever> retriever = createMetadataRetriever(); |
Marco Nelissen | f888020 | 2014-11-14 07:58:25 -0800 | [diff] [blame] | 179 | reply->writeStrongBinder(IInterface::asBinder(retriever)); |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 180 | return NO_ERROR; |
| 181 | } break; |
Marco Nelissen | 260e56c | 2016-01-28 21:41:25 +0000 | [diff] [blame^] | 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; |
Andreas Huber | ed3e3e0 | 2012-03-26 11:13:27 -0700 | [diff] [blame] | 188 | case MAKE_CRYPTO: { |
| 189 | CHECK_INTERFACE(IMediaPlayerService, data, reply); |
| 190 | sp<ICrypto> crypto = makeCrypto(); |
Marco Nelissen | f888020 | 2014-11-14 07:58:25 -0800 | [diff] [blame] | 191 | reply->writeStrongBinder(IInterface::asBinder(crypto)); |
Andreas Huber | ed3e3e0 | 2012-03-26 11:13:27 -0700 | [diff] [blame] | 192 | return NO_ERROR; |
| 193 | } break; |
Jeff Tinker | cc82dc6 | 2013-02-08 10:18:35 -0800 | [diff] [blame] | 194 | case MAKE_DRM: { |
| 195 | CHECK_INTERFACE(IMediaPlayerService, data, reply); |
| 196 | sp<IDrm> drm = makeDrm(); |
Marco Nelissen | f888020 | 2014-11-14 07:58:25 -0800 | [diff] [blame] | 197 | reply->writeStrongBinder(IInterface::asBinder(drm)); |
Jeff Tinker | cc82dc6 | 2013-02-08 10:18:35 -0800 | [diff] [blame] | 198 | return NO_ERROR; |
| 199 | } break; |
Andreas Huber | 59451f8 | 2012-09-18 10:36:32 -0700 | [diff] [blame] | 200 | case MAKE_HDCP: { |
| 201 | CHECK_INTERFACE(IMediaPlayerService, data, reply); |
Andreas Huber | 279dcd8 | 2013-01-30 10:41:25 -0800 | [diff] [blame] | 202 | bool createEncryptionModule = data.readInt32(); |
| 203 | sp<IHDCP> hdcp = makeHDCP(createEncryptionModule); |
Marco Nelissen | f888020 | 2014-11-14 07:58:25 -0800 | [diff] [blame] | 204 | reply->writeStrongBinder(IInterface::asBinder(hdcp)); |
Andreas Huber | 59451f8 | 2012-09-18 10:36:32 -0700 | [diff] [blame] | 205 | return NO_ERROR; |
| 206 | } break; |
Gloria Wang | 7cf180c | 2011-02-19 18:37:57 -0800 | [diff] [blame] | 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; |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 218 | case LISTEN_FOR_REMOTE_DISPLAY: { |
| 219 | CHECK_INTERFACE(IMediaPlayerService, data, reply); |
Svet Ganov | be71aa2 | 2015-04-28 12:06:02 -0700 | [diff] [blame] | 220 | const String16 opPackageName = data.readString16(); |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 221 | sp<IRemoteDisplayClient> client( |
| 222 | interface_cast<IRemoteDisplayClient>(data.readStrongBinder())); |
Wei Jia | 2afac0c | 2016-01-07 12:13:07 -0800 | [diff] [blame] | 223 | if (client == NULL) { |
| 224 | reply->writeStrongBinder(NULL); |
| 225 | return NO_ERROR; |
| 226 | } |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 227 | String8 iface(data.readString8()); |
Svet Ganov | be71aa2 | 2015-04-28 12:06:02 -0700 | [diff] [blame] | 228 | sp<IRemoteDisplay> display(listenForRemoteDisplay(opPackageName, client, iface)); |
Marco Nelissen | f888020 | 2014-11-14 07:58:25 -0800 | [diff] [blame] | 229 | reply->writeStrongBinder(IInterface::asBinder(display)); |
Jeff Brown | 2013a54 | 2012-09-04 21:38:42 -0700 | [diff] [blame] | 230 | return NO_ERROR; |
| 231 | } break; |
Lajos Molnar | 1381d4b | 2014-08-07 15:18:35 -0700 | [diff] [blame] | 232 | case GET_CODEC_LIST: { |
| 233 | CHECK_INTERFACE(IMediaPlayerService, data, reply); |
| 234 | sp<IMediaCodecList> mcl = getCodecList(); |
Marco Nelissen | f888020 | 2014-11-14 07:58:25 -0800 | [diff] [blame] | 235 | reply->writeStrongBinder(IInterface::asBinder(mcl)); |
Lajos Molnar | 1381d4b | 2014-08-07 15:18:35 -0700 | [diff] [blame] | 236 | return NO_ERROR; |
| 237 | } break; |
The Android Open Source Project | 89fa4ad | 2009-03-03 19:31:44 -0800 | [diff] [blame] | 238 | default: |
| 239 | return BBinder::onTransact(code, data, reply, flags); |
| 240 | } |
| 241 | } |
| 242 | |
| 243 | // ---------------------------------------------------------------------------- |
| 244 | |
Glenn Kasten | 40bc906 | 2015-03-20 09:09:33 -0700 | [diff] [blame] | 245 | } // namespace android |