frameworks/base/media/libmediaplayerservice/MediaRecorderClient.cpp

   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 <android_runtime/ActivityManager.h>
  29 #include <binder/IPCThreadState.h>
  30 #include <binder/IServiceManager.h>
  31 #include <binder/MemoryHeapBase.h>
  32 #include <binder/MemoryBase.h>
  33
  34 #ifndef NO_OPENCORE
  35 #include <media/PVMediaRecorder.h>
  36 #endif
  37
  38 #include <utils/String16.h>
  39
  40 #include <media/AudioTrack.h>
  41
  42 #include "MediaRecorderClient.h"
  43 #include "MediaPlayerService.h"
  44
  45 #include "StagefrightRecorder.h"
  46
  47 namespace android {
  48
  49 const char* cameraPermission = "android.permission.CAMERA";
  50 const char* recordAudioPermission = "android.permission.RECORD_AUDIO";
  51
  52 static bool checkPermission(const char* permissionString) {
  53 #ifndef HAVE_ANDROID_OS
  54     return true;
  55 #endif
  56     if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
  57     bool ok = checkCallingPermission(String16(permissionString));
  58     if (!ok) LOGE("Request requires %s", permissionString);
  59     return ok;
  60 }
  61
  62 status_t MediaRecorderClient::setCamera(const sp<ICamera>& camera)
  63 {
  64     LOGV("setCamera");
  65     Mutex::Autolock lock(mLock);
  66     if (mRecorder == NULL) {
  67         LOGE("recorder is not initialized");
  68         return NO_INIT;
  69     }
  70     return mRecorder->setCamera(camera);
  71 }
  72
  73 status_t MediaRecorderClient::setPreviewSurface(const sp<ISurface>& surface)
  74 {
  75     LOGV("setPreviewSurface");
  76     Mutex::Autolock lock(mLock);
  77     if (mRecorder == NULL) {
  78         LOGE("recorder is not initialized");
  79         return NO_INIT;
  80     }
  81     return mRecorder->setPreviewSurface(surface);
  82 }
  83
  84 status_t MediaRecorderClient::setVideoSource(int vs)
  85 {
  86     LOGV("setVideoSource(%d)", vs);
  87     if (!checkPermission(cameraPermission)) {
  88         return PERMISSION_DENIED;
  89     }
  90     Mutex::Autolock lock(mLock);
  91     if (mRecorder == NULL)      {
  92         LOGE("recorder is not initialized");
  93         return NO_INIT;
  94     }
  95     return mRecorder->setVideoSource((video_source)vs);
  96 }
  97
  98 status_t MediaRecorderClient::setAudioSource(int as)
  99 {
 100     LOGV("setAudioSource(%d)", as);
 101     if (!checkPermission(recordAudioPermission)) {
 102         return PERMISSION_DENIED;
 103     }
 104     Mutex::Autolock lock(mLock);
 105     if (mRecorder == NULL)  {
 106         LOGE("recorder is not initialized");
 107         return NO_INIT;
 108     }
 109     return mRecorder->setAudioSource((audio_source)as);
 110 }
 111
 112 status_t MediaRecorderClient::setOutputFormat(int of)
 113 {
 114     LOGV("setOutputFormat(%d)", of);
 115     Mutex::Autolock lock(mLock);
 116     if (mRecorder == NULL) {
 117         LOGE("recorder is not initialized");
 118         return NO_INIT;
 119     }
 120     return mRecorder->setOutputFormat((output_format)of);
 121 }
 122
 123 status_t MediaRecorderClient::setVideoEncoder(int ve)
 124 {
 125     LOGV("setVideoEncoder(%d)", ve);
 126     Mutex::Autolock lock(mLock);
 127     if (mRecorder == NULL) {
 128         LOGE("recorder is not initialized");
 129         return NO_INIT;
 130     }
 131     return mRecorder->setVideoEncoder((video_encoder)ve);
 132 }
 133
 134 status_t MediaRecorderClient::setAudioEncoder(int ae)
 135 {
 136     LOGV("setAudioEncoder(%d)", ae);
 137     Mutex::Autolock lock(mLock);
 138     if (mRecorder == NULL) {
 139         LOGE("recorder is not initialized");
 140         return NO_INIT;
 141     }
 142     return mRecorder->setAudioEncoder((audio_encoder)ae);
 143 }
 144
 145 status_t MediaRecorderClient::setOutputFile(const char* path)
 146 {
 147     LOGV("setOutputFile(%s)", path);
 148     Mutex::Autolock lock(mLock);
 149     if (mRecorder == NULL) {
 150         LOGE("recorder is not initialized");
 151         return NO_INIT;
 152     }
 153     return mRecorder->setOutputFile(path);
 154 }
 155
 156 status_t MediaRecorderClient::setOutputFile(int fd, int64_t offset, int64_t length)
 157 {
 158     LOGV("setOutputFile(%d, %lld, %lld)", fd, offset, length);
 159     Mutex::Autolock lock(mLock);
 160     if (mRecorder == NULL) {
 161         LOGE("recorder is not initialized");
 162         return NO_INIT;
 163     }
 164     return mRecorder->setOutputFile(fd, offset, length);
 165 }
 166
 167 status_t MediaRecorderClient::setVideoSize(int width, int height)
 168 {
 169     LOGV("setVideoSize(%dx%d)", width, height);
 170     Mutex::Autolock lock(mLock);
 171     if (mRecorder == NULL) {
 172         LOGE("recorder is not initialized");
 173         return NO_INIT;
 174     }
 175     return mRecorder->setVideoSize(width, height);
 176 }
 177
 178 status_t MediaRecorderClient::setVideoFrameRate(int frames_per_second)
 179 {
 180     LOGV("setVideoFrameRate(%d)", frames_per_second);
 181     Mutex::Autolock lock(mLock);
 182     if (mRecorder == NULL) {
 183         LOGE("recorder is not initialized");
 184         return NO_INIT;
 185     }
 186     return mRecorder->setVideoFrameRate(frames_per_second);
 187 }
 188
 189 status_t MediaRecorderClient::setParameters(const String8& params) {
 190     LOGV("setParameters(%s)", params.string());
 191     Mutex::Autolock lock(mLock);
 192     if (mRecorder == NULL) {
 193         LOGE("recorder is not initialized");
 194         return NO_INIT;
 195     }
 196     return mRecorder->setParameters(params);
 197 }
 198
 199 status_t MediaRecorderClient::prepare()
 200 {
 201     LOGV("prepare");
 202     Mutex::Autolock lock(mLock);
 203     if (mRecorder == NULL) {
 204         LOGE("recorder is not initialized");
 205         return NO_INIT;
 206     }
 207     return mRecorder->prepare();
 208 }
 209
 210
 211 status_t MediaRecorderClient::getMaxAmplitude(int* max)
 212 {
 213     LOGV("getMaxAmplitude");
 214     Mutex::Autolock lock(mLock);
 215     if (mRecorder == NULL) {
 216         LOGE("recorder is not initialized");
 217         return NO_INIT;
 218     }
 219     return mRecorder->getMaxAmplitude(max);
 220 }
 221
 222 status_t MediaRecorderClient::start()
 223 {
 224     LOGV("start");
 225     Mutex::Autolock lock(mLock);
 226     if (mRecorder == NULL) {
 227         LOGE("recorder is not initialized");
 228         return NO_INIT;
 229     }
 230     return mRecorder->start();
 231
 232 }
 233
 234 status_t MediaRecorderClient::stop()
 235 {
 236     LOGV("stop");
 237     Mutex::Autolock lock(mLock);
 238     if (mRecorder == NULL) {
 239         LOGE("recorder is not initialized");
 240         return NO_INIT;
 241     }
 242     return mRecorder->stop();
 243 }
 244
 245 status_t MediaRecorderClient::init()
 246 {
 247     LOGV("init");
 248     Mutex::Autolock lock(mLock);
 249     if (mRecorder == NULL) {
 250         LOGE("recorder is not initialized");
 251         return NO_INIT;
 252     }
 253     return mRecorder->init();
 254 }
 255
 256 status_t MediaRecorderClient::close()
 257 {
 258     LOGV("close");
 259     Mutex::Autolock lock(mLock);
 260     if (mRecorder == NULL) {
 261         LOGE("recorder is not initialized");
 262         return NO_INIT;
 263     }
 264     return mRecorder->close();
 265 }
 266
 267
 268 status_t MediaRecorderClient::reset()
 269 {
 270     LOGV("reset");
 271     Mutex::Autolock lock(mLock);
 272     if (mRecorder == NULL) {
 273         LOGE("recorder is not initialized");
 274         return NO_INIT;
 275     }
 276     return mRecorder->reset();
 277 }
 278
 279 status_t MediaRecorderClient::release()
 280 {
 281     LOGV("release");
 282     Mutex::Autolock lock(mLock);
 283     if (mRecorder != NULL) {
 284         delete mRecorder;
 285         mRecorder = NULL;
 286         wp<MediaRecorderClient> client(this);
 287         mMediaPlayerService->removeMediaRecorderClient(client);
 288     }
 289     return NO_ERROR;
 290 }
 291
 292 MediaRecorderClient::MediaRecorderClient(const sp<MediaPlayerService>& service, pid_t pid)
 293 {
 294     LOGV("Client constructor");
 295     mPid = pid;
 296
 297     char value[PROPERTY_VALUE_MAX];
 298     if (!property_get("media.stagefright.enable-record", value, NULL)
 299         || !strcmp(value, "1") || !strcasecmp(value, "true")) {
 300         mRecorder = new StagefrightRecorder;
 301     } else
 302 #ifndef NO_OPENCORE
 303     {
 304         mRecorder = new PVMediaRecorder();
 305     }
 306 #else
 307     {
 308         mRecorder = NULL;
 309     }
 310 #endif
 311
 312     mMediaPlayerService = service;
 313 }
 314
 315 MediaRecorderClient::~MediaRecorderClient()
 316 {
 317     LOGV("Client destructor");
 318     release();
 319 }
 320
 321 status_t MediaRecorderClient::setListener(const sp<IMediaRecorderClient>& listener)
 322 {
 323     LOGV("setListener");
 324     Mutex::Autolock lock(mLock);
 325     if (mRecorder == NULL) {
 326         LOGE("recorder is not initialized");
 327         return NO_INIT;
 328     }
 329     return mRecorder->setListener(listener);
 330 }
 331
 332 status_t MediaRecorderClient::dump(int fd, const Vector<String16>& args) const {
 333     if (mRecorder != NULL) {
 334         return mRecorder->dump(fd, args);
 335     }
 336     return OK;
 337 }
 338
 339 }; // namespace android
 340