src/type3_AndroidCloud/anbox-master/android/camera/EmulatedCameraFactory.cpp

   1 /*
   2  * Copyright (C) 2011 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 /*
  18  * Contains implementation of a class EmulatedCameraFactory that manages cameras
  19  * available for emulation.
  20  */
  21
  22 //#define LOG_NDEBUG 0
  23 #define LOG_TAG "EmulatedCamera_Factory"
  24 #include <cutils/log.h>
  25 #include <cutils/properties.h>
  26 #include "EmulatedQemuCamera.h"
  27 #include "EmulatedFakeCamera.h"
  28 #include "EmulatedFakeCamera2.h"
  29 #include "EmulatedFakeCamera3.h"
  30 #include "EmulatedCameraHotplugThread.h"
  31 #include "EmulatedCameraFactory.h"
  32
  33 extern camera_module_t HAL_MODULE_INFO_SYM;
  34
  35 /* A global instance of EmulatedCameraFactory is statically instantiated and
  36  * initialized when camera emulation HAL is loaded.
  37  */
  38 android::EmulatedCameraFactory  gEmulatedCameraFactory;
  39
  40 namespace android {
  41
  42 EmulatedCameraFactory::EmulatedCameraFactory()
  43         : mQemuClient(),
  44           mEmulatedCameras(NULL),
  45           mEmulatedCameraNum(0),
  46           mFakeCameraNum(0),
  47           mConstructedOK(false),
  48           mCallbacks(NULL)
  49 {
  50     status_t res;
  51     /* Connect to the factory service in the emulator, and create Qemu cameras. */
  52     if (mQemuClient.connectClient(NULL) == NO_ERROR) {
  53         /* Connection has succeeded. Create emulated cameras for each camera
  54          * device, reported by the service. */
  55         createQemuCameras();
  56     }
  57
  58     if (isBackFakeCameraEmulationOn()) {
  59         /* Camera ID. */
  60         const int camera_id = mEmulatedCameraNum;
  61         /* Use fake camera to emulate back-facing camera. */
  62         mEmulatedCameraNum++;
  63
  64         /* Make sure that array is allocated (in case there were no 'qemu'
  65          * cameras created. Note that we preallocate the array so it may contain
  66          * two fake cameras: one facing back, and another facing front. */
  67         if (mEmulatedCameras == NULL) {
  68             mEmulatedCameras = new EmulatedBaseCamera*[mEmulatedCameraNum + 1];
  69             if (mEmulatedCameras == NULL) {
  70                 ALOGE("%s: Unable to allocate emulated camera array for %d entries",
  71                      __FUNCTION__, mEmulatedCameraNum);
  72                 return;
  73             }
  74             memset(mEmulatedCameras, 0,
  75                     (mEmulatedCameraNum + 1) * sizeof(EmulatedBaseCamera*));
  76         }
  77
  78         /* Create, and initialize the fake camera */
  79         switch (getBackCameraHalVersion()) {
  80             case 1:
  81                 mEmulatedCameras[camera_id] =
  82                         new EmulatedFakeCamera(camera_id, true,
  83                                 &HAL_MODULE_INFO_SYM.common);
  84                 break;
  85             case 2:
  86                 mEmulatedCameras[camera_id] =
  87                         new EmulatedFakeCamera2(camera_id, true,
  88                                 &HAL_MODULE_INFO_SYM.common);
  89                 break;
  90             case 3:
  91                 mEmulatedCameras[camera_id] =
  92                         new EmulatedFakeCamera3(camera_id, true,
  93                                 &HAL_MODULE_INFO_SYM.common);
  94                 break;
  95             default:
  96                 ALOGE("%s: Unknown back camera hal version requested: %d", __FUNCTION__,
  97                         getBackCameraHalVersion());
  98         }
  99         if (mEmulatedCameras[camera_id] != NULL) {
 100             ALOGV("%s: Back camera device version is %d", __FUNCTION__,
 101                     getBackCameraHalVersion());
 102             res = mEmulatedCameras[camera_id]->Initialize();
 103             if (res != NO_ERROR) {
 104                 ALOGE("%s: Unable to intialize back camera %d: %s (%d)",
 105                         __FUNCTION__, camera_id, strerror(-res), res);
 106                 delete mEmulatedCameras[camera_id];
 107                 mEmulatedCameraNum--;
 108             }
 109         } else {
 110             mEmulatedCameraNum--;
 111             ALOGE("%s: Unable to instantiate fake camera class", __FUNCTION__);
 112         }
 113     }
 114
 115     if (isFrontFakeCameraEmulationOn()) {
 116         /* Camera ID. */
 117         const int camera_id = mEmulatedCameraNum;
 118         /* Use fake camera to emulate front-facing camera. */
 119         mEmulatedCameraNum++;
 120
 121         /* Make sure that array is allocated (in case there were no 'qemu'
 122          * cameras created. */
 123         if (mEmulatedCameras == NULL) {
 124             mEmulatedCameras = new EmulatedBaseCamera*[mEmulatedCameraNum];
 125             if (mEmulatedCameras == NULL) {
 126                 ALOGE("%s: Unable to allocate emulated camera array for %d entries",
 127                      __FUNCTION__, mEmulatedCameraNum);
 128                 return;
 129             }
 130             memset(mEmulatedCameras, 0,
 131                     mEmulatedCameraNum * sizeof(EmulatedBaseCamera*));
 132         }
 133
 134         /* Create, and initialize the fake camera */
 135         switch (getFrontCameraHalVersion()) {
 136             case 1:
 137                 mEmulatedCameras[camera_id] =
 138                         new EmulatedFakeCamera(camera_id, false,
 139                                 &HAL_MODULE_INFO_SYM.common);
 140                 break;
 141             case 2:
 142                 mEmulatedCameras[camera_id] =
 143                         new EmulatedFakeCamera2(camera_id, false,
 144                                 &HAL_MODULE_INFO_SYM.common);
 145                 break;
 146             case 3:
 147                 mEmulatedCameras[camera_id] =
 148                         new EmulatedFakeCamera3(camera_id, false,
 149                                 &HAL_MODULE_INFO_SYM.common);
 150                 break;
 151             default:
 152                 ALOGE("%s: Unknown front camera hal version requested: %d",
 153                         __FUNCTION__,
 154                         getFrontCameraHalVersion());
 155         }
 156         if (mEmulatedCameras[camera_id] != NULL) {
 157             ALOGV("%s: Front camera device version is %d", __FUNCTION__,
 158                     getFrontCameraHalVersion());
 159             res = mEmulatedCameras[camera_id]->Initialize();
 160             if (res != NO_ERROR) {
 161                 ALOGE("%s: Unable to intialize front camera %d: %s (%d)",
 162                         __FUNCTION__, camera_id, strerror(-res), res);
 163                 delete mEmulatedCameras[camera_id];
 164                 mEmulatedCameraNum--;
 165             }
 166         } else {
 167             mEmulatedCameraNum--;
 168             ALOGE("%s: Unable to instantiate fake camera class", __FUNCTION__);
 169         }
 170     }
 171
 172     ALOGV("%d cameras are being emulated. %d of them are fake cameras.",
 173           mEmulatedCameraNum, mFakeCameraNum);
 174
 175     /* Create hotplug thread */
 176     {
 177         Vector<int> cameraIdVector;
 178         for (int i = 0; i < mEmulatedCameraNum; ++i) {
 179             cameraIdVector.push_back(i);
 180         }
 181         mHotplugThread = new EmulatedCameraHotplugThread(&cameraIdVector[0],
 182                                                          mEmulatedCameraNum);
 183         mHotplugThread->run("EmulatedCameraHotplugThread");
 184     }
 185
 186     mConstructedOK = true;
 187 }
 188
 189 EmulatedCameraFactory::~EmulatedCameraFactory()
 190 {
 191     if (mEmulatedCameras != NULL) {
 192         for (int n = 0; n < mEmulatedCameraNum; n++) {
 193             if (mEmulatedCameras[n] != NULL) {
 194                 delete mEmulatedCameras[n];
 195             }
 196         }
 197         delete[] mEmulatedCameras;
 198     }
 199
 200     if (mHotplugThread != NULL) {
 201         mHotplugThread->requestExit();
 202         mHotplugThread->join();
 203     }
 204 }
 205
 206 /****************************************************************************
 207  * Camera HAL API handlers.
 208  *
 209  * Each handler simply verifies existence of an appropriate EmulatedBaseCamera
 210  * instance, and dispatches the call to that instance.
 211  *
 212  ***************************************************************************/
 213
 214 int EmulatedCameraFactory::cameraDeviceOpen(int camera_id, hw_device_t** device)
 215 {
 216     ALOGV("%s: id = %d", __FUNCTION__, camera_id);
 217
 218     *device = NULL;
 219
 220     if (!isConstructedOK()) {
 221         ALOGE("%s: EmulatedCameraFactory has failed to initialize", __FUNCTION__);
 222         return -EINVAL;
 223     }
 224
 225     if (camera_id < 0 || camera_id >= getEmulatedCameraNum()) {
 226         ALOGE("%s: Camera id %d is out of bounds (%d)",
 227              __FUNCTION__, camera_id, getEmulatedCameraNum());
 228         return -ENODEV;
 229     }
 230
 231     return mEmulatedCameras[camera_id]->connectCamera(device);
 232 }
 233
 234 int EmulatedCameraFactory::getCameraInfo(int camera_id, struct camera_info* info)
 235 {
 236     ALOGV("%s: id = %d", __FUNCTION__, camera_id);
 237
 238     if (!isConstructedOK()) {
 239         ALOGE("%s: EmulatedCameraFactory has failed to initialize", __FUNCTION__);
 240         return -EINVAL;
 241     }
 242
 243     if (camera_id < 0 || camera_id >= getEmulatedCameraNum()) {
 244         ALOGE("%s: Camera id %d is out of bounds (%d)",
 245              __FUNCTION__, camera_id, getEmulatedCameraNum());
 246         return -ENODEV;
 247     }
 248
 249     return mEmulatedCameras[camera_id]->getCameraInfo(info);
 250 }
 251
 252 int EmulatedCameraFactory::setCallbacks(
 253         const camera_module_callbacks_t *callbacks)
 254 {
 255     ALOGV("%s: callbacks = %p", __FUNCTION__, callbacks);
 256
 257     mCallbacks = callbacks;
 258
 259     return OK;
 260 }
 261
 262 void EmulatedCameraFactory::getVendorTagOps(vendor_tag_ops_t* ops) {
 263     ALOGV("%s: ops = %p", __FUNCTION__, ops);
 264
 265     // No vendor tags defined for emulator yet, so not touching ops
 266 }
 267
 268 /****************************************************************************
 269  * Camera HAL API callbacks.
 270  ***************************************************************************/
 271
 272 int EmulatedCameraFactory::device_open(const hw_module_t* module,
 273                                        const char* name,
 274                                        hw_device_t** device)
 275 {
 276     /*
 277      * Simply verify the parameters, and dispatch the call inside the
 278      * EmulatedCameraFactory instance.
 279      */
 280
 281     if (module != &HAL_MODULE_INFO_SYM.common) {
 282         ALOGE("%s: Invalid module %p expected %p",
 283              __FUNCTION__, module, &HAL_MODULE_INFO_SYM.common);
 284         return -EINVAL;
 285     }
 286     if (name == NULL) {
 287         ALOGE("%s: NULL name is not expected here", __FUNCTION__);
 288         return -EINVAL;
 289     }
 290
 291     return gEmulatedCameraFactory.cameraDeviceOpen(atoi(name), device);
 292 }
 293
 294 int EmulatedCameraFactory::get_number_of_cameras(void)
 295 {
 296     return gEmulatedCameraFactory.getEmulatedCameraNum();
 297 }
 298
 299 int EmulatedCameraFactory::get_camera_info(int camera_id,
 300                                            struct camera_info* info)
 301 {
 302     return gEmulatedCameraFactory.getCameraInfo(camera_id, info);
 303 }
 304
 305 int EmulatedCameraFactory::set_callbacks(
 306         const camera_module_callbacks_t *callbacks)
 307 {
 308     return gEmulatedCameraFactory.setCallbacks(callbacks);
 309 }
 310
 311 void EmulatedCameraFactory::get_vendor_tag_ops(vendor_tag_ops_t* ops)
 312 {
 313     gEmulatedCameraFactory.getVendorTagOps(ops);
 314 }
 315
 316 int EmulatedCameraFactory::open_legacy(const struct hw_module_t* module,
 317         const char* id, uint32_t halVersion, struct hw_device_t** device) {
 318     // Not supporting legacy open
 319     return -ENOSYS;
 320 }
 321
 322 /********************************************************************************
 323  * Internal API
 324  *******************************************************************************/
 325
 326 /*
 327  * Camera information tokens passed in response to the "list" factory query.
 328  */
 329
 330 /* Device name token. */
 331 static const char lListNameToken[]    = "name=";
 332 /* Frame dimensions token. */
 333 static const char lListDimsToken[]    = "framedims=";
 334 /* Facing direction token. */
 335 static const char lListDirToken[]     = "dir=";
 336
 337 void EmulatedCameraFactory::createQemuCameras()
 338 {
 339     /* Obtain camera list. */
 340     char* camera_list = NULL;
 341     status_t res = mQemuClient.listCameras(&camera_list);
 342     /* Empty list, or list containing just an EOL means that there were no
 343      * connected cameras found. */
 344     if (res != NO_ERROR || camera_list == NULL || *camera_list == '\0' ||
 345         *camera_list == '\n') {
 346         if (camera_list != NULL) {
 347             free(camera_list);
 348         }
 349         return;
 350     }
 351
 352     /*
 353      * Calculate number of connected cameras. Number of EOLs in the camera list
 354      * is the number of the connected cameras.
 355      */
 356
 357     int num = 0;
 358     const char* eol = strchr(camera_list, '\n');
 359     while (eol != NULL) {
 360         num++;
 361         eol = strchr(eol + 1, '\n');
 362     }
 363
 364     /* Allocate the array for emulated camera instances. Note that we allocate
 365      * two more entries for back and front fake camera emulation. */
 366     mEmulatedCameras = new EmulatedBaseCamera*[num + 2];
 367     if (mEmulatedCameras == NULL) {
 368         ALOGE("%s: Unable to allocate emulated camera array for %d entries",
 369              __FUNCTION__, num + 1);
 370         free(camera_list);
 371         return;
 372     }
 373     memset(mEmulatedCameras, 0, sizeof(EmulatedBaseCamera*) * (num + 1));
 374
 375     /*
 376      * Iterate the list, creating, and initializin emulated qemu cameras for each
 377      * entry (line) in the list.
 378      */
 379
 380     int index = 0;
 381     char* cur_entry = camera_list;
 382     while (cur_entry != NULL && *cur_entry != '\0' && index < num) {
 383         /* Find the end of the current camera entry, and terminate it with zero
 384          * for simpler string manipulation. */
 385         char* next_entry = strchr(cur_entry, '\n');
 386         if (next_entry != NULL) {
 387             *next_entry = '\0';
 388             next_entry++;   // Start of the next entry.
 389         }
 390
 391         /* Find 'name', 'framedims', and 'dir' tokens that are required here. */
 392         char* name_start = strstr(cur_entry, lListNameToken);
 393         char* dim_start = strstr(cur_entry, lListDimsToken);
 394         char* dir_start = strstr(cur_entry, lListDirToken);
 395         if (name_start != NULL && dim_start != NULL && dir_start != NULL) {
 396             /* Advance to the token values. */
 397             name_start += strlen(lListNameToken);
 398             dim_start += strlen(lListDimsToken);
 399             dir_start += strlen(lListDirToken);
 400
 401             /* Terminate token values with zero. */
 402             char* s = strchr(name_start, ' ');
 403             if (s != NULL) {
 404                 *s = '\0';
 405             }
 406             s = strchr(dim_start, ' ');
 407             if (s != NULL) {
 408                 *s = '\0';
 409             }
 410             s = strchr(dir_start, ' ');
 411             if (s != NULL) {
 412                 *s = '\0';
 413             }
 414
 415             /* Create and initialize qemu camera. */
 416             EmulatedQemuCamera* qemu_cam =
 417                 new EmulatedQemuCamera(index, &HAL_MODULE_INFO_SYM.common);
 418             if (NULL != qemu_cam) {
 419                 res = qemu_cam->Initialize(name_start, dim_start, dir_start);
 420                 if (res == NO_ERROR) {
 421                     mEmulatedCameras[index] = qemu_cam;
 422                     index++;
 423                 } else {
 424                     delete qemu_cam;
 425                 }
 426             } else {
 427                 ALOGE("%s: Unable to instantiate EmulatedQemuCamera",
 428                      __FUNCTION__);
 429             }
 430         } else {
 431             ALOGW("%s: Bad camera information: %s", __FUNCTION__, cur_entry);
 432         }
 433
 434         cur_entry = next_entry;
 435     }
 436
 437     mEmulatedCameraNum = index;
 438 }
 439
 440 bool EmulatedCameraFactory::isBackFakeCameraEmulationOn()
 441 {
 442     /* Defined by 'qemu.sf.fake_camera' boot property: if property exist, and
 443      * is set to 'both', or 'back', then fake camera is used to emulate back
 444      * camera. */
 445     char prop[PROPERTY_VALUE_MAX];
 446     if ((property_get("qemu.sf.fake_camera", prop, NULL) > 0) &&
 447         (!strcmp(prop, "both") || !strcmp(prop, "back"))) {
 448         return true;
 449     } else {
 450         return false;
 451     }
 452 }
 453
 454 int EmulatedCameraFactory::getBackCameraHalVersion()
 455 {
 456     /* Defined by 'qemu.sf.back_camera_hal_version' boot property: if the
 457      * property doesn't exist, it is assumed to be 1. */
 458     char prop[PROPERTY_VALUE_MAX];
 459     if (property_get("qemu.sf.back_camera_hal", prop, NULL) > 0) {
 460         char *prop_end = prop;
 461         int val = strtol(prop, &prop_end, 10);
 462         if (*prop_end == '\0') {
 463             return val;
 464         }
 465         // Badly formatted property, should just be a number
 466         ALOGE("qemu.sf.back_camera_hal is not a number: %s", prop);
 467     }
 468     return 1;
 469 }
 470
 471 bool EmulatedCameraFactory::isFrontFakeCameraEmulationOn()
 472 {
 473     /* Defined by 'qemu.sf.fake_camera' boot property: if property exist, and
 474      * is set to 'both', or 'front', then fake camera is used to emulate front
 475      * camera. */
 476     char prop[PROPERTY_VALUE_MAX];
 477     if ((property_get("qemu.sf.fake_camera", prop, NULL) > 0) &&
 478         (!strcmp(prop, "both") || !strcmp(prop, "front"))) {
 479         return true;
 480     } else {
 481         return false;
 482     }
 483 }
 484
 485 int EmulatedCameraFactory::getFrontCameraHalVersion()
 486 {
 487     /* Defined by 'qemu.sf.front_camera_hal_version' boot property: if the
 488      * property doesn't exist, it is assumed to be 1. */
 489     char prop[PROPERTY_VALUE_MAX];
 490     if (property_get("qemu.sf.front_camera_hal", prop, NULL) > 0) {
 491         char *prop_end = prop;
 492         int val = strtol(prop, &prop_end, 10);
 493         if (*prop_end == '\0') {
 494             return val;
 495         }
 496         // Badly formatted property, should just be a number
 497         ALOGE("qemu.sf.front_camera_hal is not a number: %s", prop);
 498     }
 499     return 1;
 500 }
 501
 502 void EmulatedCameraFactory::onStatusChanged(int cameraId, int newStatus) {
 503
 504     EmulatedBaseCamera *cam = mEmulatedCameras[cameraId];
 505     if (!cam) {
 506         ALOGE("%s: Invalid camera ID %d", __FUNCTION__, cameraId);
 507         return;
 508     }
 509
 510     /**
 511      * (Order is important)
 512      * Send the callback first to framework, THEN close the camera.
 513      */
 514
 515     if (newStatus == cam->getHotplugStatus()) {
 516         ALOGW("%s: Ignoring transition to the same status", __FUNCTION__);
 517         return;
 518     }
 519
 520     const camera_module_callbacks_t* cb = mCallbacks;
 521     if (cb != NULL && cb->camera_device_status_change != NULL) {
 522         cb->camera_device_status_change(cb, cameraId, newStatus);
 523     }
 524
 525     if (newStatus == CAMERA_DEVICE_STATUS_NOT_PRESENT) {
 526         cam->unplugCamera();
 527     } else if (newStatus == CAMERA_DEVICE_STATUS_PRESENT) {
 528         cam->plugCamera();
 529     }
 530
 531 }
 532
 533 /********************************************************************************
 534  * Initializer for the static member structure.
 535  *******************************************************************************/
 536
 537 /* Entry point for camera HAL API. */
 538 struct hw_module_methods_t EmulatedCameraFactory::mCameraModuleMethods = {
 539     open: EmulatedCameraFactory::device_open
 540 };
 541
 542 }; /* namespace android */