1/*
2 ** Copyright 2008, The Android Open Source Project
3 **
4 ** Licensed under the Apache License, Version 2.0 (the "License");
5 ** you may not use this file except in compliance with the License.
6 ** You may obtain a copy of the License at
7 **
8 **     http://www.apache.org/licenses/LICENSE-2.0
9 **
10 ** Unless required by applicable law or agreed to in writing, software
11 ** distributed under the License is distributed on an "AS IS" BASIS,
12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 ** See the License for the specific language governing permissions and
14 ** limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "MediaRecorderService"
19#include <utils/Log.h>
20
21#include <sys/types.h>
22#include <sys/stat.h>
23#include <dirent.h>
24#include <unistd.h>
25#include <string.h>
26#include <cutils/atomic.h>
27#include <cutils/properties.h> // for property_get
28#include <binder/IPCThreadState.h>
29#include <binder/IServiceManager.h>
30#include <binder/MemoryHeapBase.h>
31#include <binder/MemoryBase.h>
32
33#include <utils/String16.h>
34
35#include <system/audio.h>
36
37#include "MediaRecorderClient.h"
38#include "MediaPlayerService.h"
39
40#include "StagefrightRecorder.h"
41#include <gui/IGraphicBufferProducer.h>
42
43namespace android {
44
45const char* cameraPermission = "android.permission.CAMERA";
46const char* recordAudioPermission = "android.permission.RECORD_AUDIO";
47
48static bool checkPermission(const char* permissionString) {
49    if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
50    bool ok = checkCallingPermission(String16(permissionString));
51    if (!ok) ALOGE("Request requires %s", permissionString);
52    return ok;
53}
54
55status_t MediaRecorderClient::setInputSurface(const sp<PersistentSurface>& surface)
56{
57    ALOGV("setInputSurface");
58    Mutex::Autolock lock(mLock);
59    if (mRecorder == NULL) {
60        ALOGE("recorder is not initialized");
61        return NO_INIT;
62    }
63    return mRecorder->setInputSurface(surface);
64}
65
66sp<IGraphicBufferProducer> MediaRecorderClient::querySurfaceMediaSource()
67{
68    ALOGV("Query SurfaceMediaSource");
69    Mutex::Autolock lock(mLock);
70    if (mRecorder == NULL) {
71        ALOGE("recorder is not initialized");
72        return NULL;
73    }
74    return mRecorder->querySurfaceMediaSource();
75}
76
77
78
79status_t MediaRecorderClient::setCamera(const sp<hardware::ICamera>& camera,
80                                        const sp<ICameraRecordingProxy>& proxy)
81{
82    ALOGV("setCamera");
83    Mutex::Autolock lock(mLock);
84    if (mRecorder == NULL) {
85        ALOGE("recorder is not initialized");
86        return NO_INIT;
87    }
88    return mRecorder->setCamera(camera, proxy);
89}
90
91status_t MediaRecorderClient::setPreviewSurface(const sp<IGraphicBufferProducer>& surface)
92{
93    ALOGV("setPreviewSurface");
94    Mutex::Autolock lock(mLock);
95    if (mRecorder == NULL) {
96        ALOGE("recorder is not initialized");
97        return NO_INIT;
98    }
99    return mRecorder->setPreviewSurface(surface);
100}
101
102status_t MediaRecorderClient::setVideoSource(int vs)
103{
104    ALOGV("setVideoSource(%d)", vs);
105    // Check camera permission for sources other than SURFACE
106    if (vs != VIDEO_SOURCE_SURFACE && !checkPermission(cameraPermission)) {
107        return PERMISSION_DENIED;
108    }
109    Mutex::Autolock lock(mLock);
110    if (mRecorder == NULL)     {
111        ALOGE("recorder is not initialized");
112        return NO_INIT;
113    }
114    return mRecorder->setVideoSource((video_source)vs);
115}
116
117status_t MediaRecorderClient::setAudioSource(int as)
118{
119    ALOGV("setAudioSource(%d)", as);
120    if (!checkPermission(recordAudioPermission)) {
121        return PERMISSION_DENIED;
122    }
123    Mutex::Autolock lock(mLock);
124    if (mRecorder == NULL)  {
125        ALOGE("recorder is not initialized");
126        return NO_INIT;
127    }
128    return mRecorder->setAudioSource((audio_source_t)as);
129}
130
131status_t MediaRecorderClient::setOutputFormat(int of)
132{
133    ALOGV("setOutputFormat(%d)", of);
134    Mutex::Autolock lock(mLock);
135    if (mRecorder == NULL) {
136        ALOGE("recorder is not initialized");
137        return NO_INIT;
138    }
139    return mRecorder->setOutputFormat((output_format)of);
140}
141
142status_t MediaRecorderClient::setVideoEncoder(int ve)
143{
144    ALOGV("setVideoEncoder(%d)", ve);
145    Mutex::Autolock lock(mLock);
146    if (mRecorder == NULL) {
147        ALOGE("recorder is not initialized");
148        return NO_INIT;
149    }
150    return mRecorder->setVideoEncoder((video_encoder)ve);
151}
152
153status_t MediaRecorderClient::setAudioEncoder(int ae)
154{
155    ALOGV("setAudioEncoder(%d)", ae);
156    Mutex::Autolock lock(mLock);
157    if (mRecorder == NULL) {
158        ALOGE("recorder is not initialized");
159        return NO_INIT;
160    }
161    return mRecorder->setAudioEncoder((audio_encoder)ae);
162}
163
164status_t MediaRecorderClient::setOutputFile(int fd)
165{
166    ALOGV("setOutputFile(%d)", fd);
167    Mutex::Autolock lock(mLock);
168    if (mRecorder == NULL) {
169        ALOGE("recorder is not initialized");
170        return NO_INIT;
171    }
172    return mRecorder->setOutputFile(fd);
173}
174
175status_t MediaRecorderClient::setNextOutputFile(int fd)
176{
177    ALOGV("setNextOutputFile(%d)", fd);
178    Mutex::Autolock lock(mLock);
179    if (mRecorder == NULL) {
180        ALOGE("recorder is not initialized");
181        return NO_INIT;
182    }
183    return mRecorder->setNextOutputFile(fd);
184}
185
186status_t MediaRecorderClient::setVideoSize(int width, int height)
187{
188    ALOGV("setVideoSize(%dx%d)", width, height);
189    Mutex::Autolock lock(mLock);
190    if (mRecorder == NULL) {
191        ALOGE("recorder is not initialized");
192        return NO_INIT;
193    }
194    return mRecorder->setVideoSize(width, height);
195}
196
197status_t MediaRecorderClient::setVideoFrameRate(int frames_per_second)
198{
199    ALOGV("setVideoFrameRate(%d)", frames_per_second);
200    Mutex::Autolock lock(mLock);
201    if (mRecorder == NULL) {
202        ALOGE("recorder is not initialized");
203        return NO_INIT;
204    }
205    return mRecorder->setVideoFrameRate(frames_per_second);
206}
207
208status_t MediaRecorderClient::setParameters(const String8& params) {
209    ALOGV("setParameters(%s)", params.string());
210    Mutex::Autolock lock(mLock);
211    if (mRecorder == NULL) {
212        ALOGE("recorder is not initialized");
213        return NO_INIT;
214    }
215    return mRecorder->setParameters(params);
216}
217
218status_t MediaRecorderClient::prepare()
219{
220    ALOGV("prepare");
221    Mutex::Autolock lock(mLock);
222    if (mRecorder == NULL) {
223        ALOGE("recorder is not initialized");
224        return NO_INIT;
225    }
226    return mRecorder->prepare();
227}
228
229
230status_t MediaRecorderClient::getMaxAmplitude(int* max)
231{
232    ALOGV("getMaxAmplitude");
233    Mutex::Autolock lock(mLock);
234    if (mRecorder == NULL) {
235        ALOGE("recorder is not initialized");
236        return NO_INIT;
237    }
238    return mRecorder->getMaxAmplitude(max);
239}
240
241status_t MediaRecorderClient::getMetrics(Parcel* reply)
242{
243    ALOGV("MediaRecorderClient::getMetrics");
244    Mutex::Autolock lock(mLock);
245    if (mRecorder == NULL) {
246        ALOGE("recorder is not initialized");
247        return NO_INIT;
248    }
249    return mRecorder->getMetrics(reply);
250}
251
252status_t MediaRecorderClient::start()
253{
254    ALOGV("start");
255    Mutex::Autolock lock(mLock);
256    if (mRecorder == NULL) {
257        ALOGE("recorder is not initialized");
258        return NO_INIT;
259    }
260    return mRecorder->start();
261
262}
263
264status_t MediaRecorderClient::stop()
265{
266    ALOGV("stop");
267    Mutex::Autolock lock(mLock);
268    if (mRecorder == NULL) {
269        ALOGE("recorder is not initialized");
270        return NO_INIT;
271    }
272    return mRecorder->stop();
273}
274
275status_t MediaRecorderClient::pause()
276{
277    ALOGV("pause");
278    Mutex::Autolock lock(mLock);
279    if (mRecorder == NULL) {
280        ALOGE("recorder is not initialized");
281        return NO_INIT;
282    }
283    return mRecorder->pause();
284
285}
286
287status_t MediaRecorderClient::resume()
288{
289    ALOGV("resume");
290    Mutex::Autolock lock(mLock);
291    if (mRecorder == NULL) {
292        ALOGE("recorder is not initialized");
293        return NO_INIT;
294    }
295    return mRecorder->resume();
296}
297
298status_t MediaRecorderClient::init()
299{
300    ALOGV("init");
301    Mutex::Autolock lock(mLock);
302    if (mRecorder == NULL) {
303        ALOGE("recorder is not initialized");
304        return NO_INIT;
305    }
306    return mRecorder->init();
307}
308
309status_t MediaRecorderClient::close()
310{
311    ALOGV("close");
312    Mutex::Autolock lock(mLock);
313    if (mRecorder == NULL) {
314        ALOGE("recorder is not initialized");
315        return NO_INIT;
316    }
317    return mRecorder->close();
318}
319
320
321status_t MediaRecorderClient::reset()
322{
323    ALOGV("reset");
324    Mutex::Autolock lock(mLock);
325    if (mRecorder == NULL) {
326        ALOGE("recorder is not initialized");
327        return NO_INIT;
328    }
329    return mRecorder->reset();
330}
331
332status_t MediaRecorderClient::release()
333{
334    ALOGV("release");
335    Mutex::Autolock lock(mLock);
336    if (mRecorder != NULL) {
337        delete mRecorder;
338        mRecorder = NULL;
339        wp<MediaRecorderClient> client(this);
340        mMediaPlayerService->removeMediaRecorderClient(client);
341    }
342    clearDeathNotifiers();
343    return NO_ERROR;
344}
345
346MediaRecorderClient::MediaRecorderClient(const sp<MediaPlayerService>& service, pid_t pid,
347        const String16& opPackageName)
348{
349    ALOGV("Client constructor");
350    mPid = pid;
351    mRecorder = new StagefrightRecorder(opPackageName);
352    mMediaPlayerService = service;
353}
354
355MediaRecorderClient::~MediaRecorderClient()
356{
357    ALOGV("Client destructor");
358    release();
359}
360
361MediaRecorderClient::ServiceDeathNotifier::ServiceDeathNotifier(
362        const sp<IBinder>& service,
363        const sp<IMediaRecorderClient>& listener,
364        int which) {
365    mService = service;
366    mOmx = nullptr;
367    mListener = listener;
368    mWhich = which;
369}
370
371MediaRecorderClient::ServiceDeathNotifier::ServiceDeathNotifier(
372        const sp<IOmx>& omx,
373        const sp<IMediaRecorderClient>& listener,
374        int which) {
375    mService = nullptr;
376    mOmx = omx;
377    mListener = listener;
378    mWhich = which;
379}
380
381MediaRecorderClient::ServiceDeathNotifier::~ServiceDeathNotifier() {
382}
383
384void MediaRecorderClient::ServiceDeathNotifier::binderDied(const wp<IBinder>& /*who*/) {
385    sp<IMediaRecorderClient> listener = mListener.promote();
386    if (listener != NULL) {
387        listener->notify(MEDIA_ERROR, MEDIA_ERROR_SERVER_DIED, mWhich);
388    } else {
389        ALOGW("listener for process %d death is gone", mWhich);
390    }
391}
392
393void MediaRecorderClient::ServiceDeathNotifier::serviceDied(
394        uint64_t /* cookie */,
395        const wp<::android::hidl::base::V1_0::IBase>& /* who */) {
396    sp<IMediaRecorderClient> listener = mListener.promote();
397    if (listener != NULL) {
398        listener->notify(MEDIA_ERROR, MEDIA_ERROR_SERVER_DIED, mWhich);
399    } else {
400        ALOGW("listener for process %d death is gone", mWhich);
401    }
402}
403
404void MediaRecorderClient::ServiceDeathNotifier::unlinkToDeath() {
405    if (mService != nullptr) {
406        mService->unlinkToDeath(this);
407        mService = nullptr;
408    } else if (mOmx != nullptr) {
409        mOmx->unlinkToDeath(this);
410        mOmx = nullptr;
411    }
412}
413
414void MediaRecorderClient::clearDeathNotifiers() {
415    if (mCameraDeathListener != nullptr) {
416        mCameraDeathListener->unlinkToDeath();
417        mCameraDeathListener = nullptr;
418    }
419    if (mCodecDeathListener != nullptr) {
420        mCodecDeathListener->unlinkToDeath();
421        mCodecDeathListener = nullptr;
422    }
423}
424
425status_t MediaRecorderClient::setListener(const sp<IMediaRecorderClient>& listener)
426{
427    ALOGV("setListener");
428    clearDeathNotifiers();
429    Mutex::Autolock lock(mLock);
430    if (mRecorder == NULL) {
431        ALOGE("recorder is not initialized");
432        return NO_INIT;
433    }
434    mRecorder->setListener(listener);
435
436    sp<IServiceManager> sm = defaultServiceManager();
437
438    // WORKAROUND: We don't know if camera exists here and getService might block for 5 seconds.
439    // Use checkService for camera if we don't know it exists.
440    static std::atomic<bool> sCameraChecked(false);  // once true never becomes false.
441    static std::atomic<bool> sCameraVerified(false); // once true never becomes false.
442    sp<IBinder> binder = (sCameraVerified || !sCameraChecked)
443        ? sm->getService(String16("media.camera")) : sm->checkService(String16("media.camera"));
444    // If the device does not have a camera, do not create a death listener for it.
445    if (binder != NULL) {
446        sCameraVerified = true;
447        mCameraDeathListener = new ServiceDeathNotifier(binder, listener,
448                MediaPlayerService::CAMERA_PROCESS_DEATH);
449        binder->linkToDeath(mCameraDeathListener);
450    }
451    sCameraChecked = true;
452
453    if (property_get_bool("persist.media.treble_omx", true)) {
454        // Treble IOmx
455        sp<IOmx> omx = IOmx::getService();
456        if (omx == nullptr) {
457            ALOGE("Treble IOmx not available");
458            return NO_INIT;
459        }
460        mCodecDeathListener = new ServiceDeathNotifier(omx, listener,
461                MediaPlayerService::MEDIACODEC_PROCESS_DEATH);
462        omx->linkToDeath(mCodecDeathListener, 0);
463    } else {
464        // Legacy IOMX
465        binder = sm->getService(String16("media.codec"));
466        if (binder == NULL) {
467           ALOGE("Unable to connect to media codec service");
468           return NO_INIT;
469        }
470        mCodecDeathListener = new ServiceDeathNotifier(binder, listener,
471                MediaPlayerService::MEDIACODEC_PROCESS_DEATH);
472        binder->linkToDeath(mCodecDeathListener);
473    }
474
475    return OK;
476}
477
478status_t MediaRecorderClient::setClientName(const String16& clientName) {
479    ALOGV("setClientName(%s)", String8(clientName).string());
480    Mutex::Autolock lock(mLock);
481    if (mRecorder == NULL) {
482        ALOGE("recorder is not initialized");
483        return NO_INIT;
484    }
485    return mRecorder->setClientName(clientName);
486}
487
488status_t MediaRecorderClient::dump(int fd, const Vector<String16>& args) {
489    if (mRecorder != NULL) {
490        return mRecorder->dump(fd, args);
491    }
492    return OK;
493}
494
495}; // namespace android
496