core/jni/android_hardware_camera2_CameraMetadata.cpp

   1 /*
   2 **
   3 ** Copyright 2013, 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 // #define LOG_NDEBUG 0
  19 #define LOG_TAG "CameraMetadata-JNI"
  20 #include <utils/Errors.h>
  21 #include <utils/Log.h>
  22 #include <utils/RefBase.h>
  23 #include <utils/Vector.h>
  24 #include <utils/SortedVector.h>
  25 #include <utils/KeyedVector.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <vector>
  29
  30 #include "jni.h"
  31 #include "JNIHelp.h"
  32 #include "android_os_Parcel.h"
  33 #include "core_jni_helpers.h"
  34 #include "android_runtime/android_hardware_camera2_CameraMetadata.h"
  35
  36 #include <android/hardware/ICameraService.h>
  37 #include <binder/IServiceManager.h>
  38 #include <camera/CameraMetadata.h>
  39 #include <camera/VendorTagDescriptor.h>
  40 #include <nativehelper/ScopedUtfChars.h>
  41 #include <nativehelper/ScopedPrimitiveArray.h>
  42
  43 #include <sys/types.h> // for socketpair
  44 #include <sys/socket.h> // for socketpair
  45
  46 static const bool kIsDebug = false;
  47
  48 // fully-qualified class name
  49 #define CAMERA_METADATA_CLASS_NAME "android/hardware/camera2/impl/CameraMetadataNative"
  50 #define CHARACTERISTICS_KEY_CLASS_NAME "android/hardware/camera2/CameraCharacteristics$Key"
  51 #define REQUEST_KEY_CLASS_NAME "android/hardware/camera2/CaptureRequest$Key"
  52 #define RESULT_KEY_CLASS_NAME "android/hardware/camera2/CaptureResult$Key"
  53
  54 using namespace android;
  55
  56 static struct metadata_java_key_offsets_t {
  57     jclass mCharacteristicsKey;
  58     jclass mResultKey;
  59     jclass mRequestKey;
  60     jmethodID mCharacteristicsConstr;
  61     jmethodID mResultConstr;
  62     jmethodID mRequestConstr;
  63     jclass mByteArray;
  64     jclass mInt32Array;
  65     jclass mFloatArray;
  66     jclass mInt64Array;
  67     jclass mDoubleArray;
  68     jclass mRationalArray;
  69     jclass mArrayList;
  70     jmethodID mArrayListConstr;
  71     jmethodID mArrayListAdd;
  72 } gMetadataOffsets;
  73
  74 struct fields_t {
  75     jfieldID    metadata_ptr;
  76 };
  77
  78 static fields_t fields;
  79
  80 namespace android {
  81
  82 status_t CameraMetadata_getNativeMetadata(JNIEnv* env, jobject thiz,
  83         /*out*/CameraMetadata* metadata) {
  84     if (!thiz) {
  85         ALOGE("%s: Invalid java metadata object.", __FUNCTION__);
  86         return BAD_VALUE;
  87     }
  88
  89     if (!metadata) {
  90         ALOGE("%s: Invalid output metadata object.", __FUNCTION__);
  91         return BAD_VALUE;
  92     }
  93     CameraMetadata* nativePtr = reinterpret_cast<CameraMetadata*>(env->GetLongField(thiz,
  94             fields.metadata_ptr));
  95     if (nativePtr == NULL) {
  96         ALOGE("%s: Invalid native pointer in java metadata object.", __FUNCTION__);
  97         return BAD_VALUE;
  98     }
  99     *metadata = *nativePtr;
 100     return OK;
 101 }
 102
 103 } /*namespace android*/
 104
 105 namespace {
 106 struct Helpers {
 107     static size_t getTypeSize(uint8_t type) {
 108         if (type >= NUM_TYPES) {
 109             ALOGE("%s: Invalid type specified (%ud)", __FUNCTION__, type);
 110             return static_cast<size_t>(-1);
 111         }
 112
 113         return camera_metadata_type_size[type];
 114     }
 115
 116     static status_t updateAny(CameraMetadata *metadata,
 117                           uint32_t tag,
 118                           uint32_t type,
 119                           const void *data,
 120                           size_t dataBytes) {
 121
 122         if (type >= NUM_TYPES) {
 123             ALOGE("%s: Invalid type specified (%ud)", __FUNCTION__, type);
 124             return INVALID_OPERATION;
 125         }
 126
 127         size_t typeSize = getTypeSize(type);
 128
 129         if (dataBytes % typeSize != 0) {
 130             ALOGE("%s: Expected dataBytes (%zu) to be divisible by typeSize "
 131                   "(%zu)", __FUNCTION__, dataBytes, typeSize);
 132             return BAD_VALUE;
 133         }
 134
 135         size_t dataCount = dataBytes / typeSize;
 136
 137         switch(type) {
 138 #define METADATA_UPDATE(runtime_type, compile_type)                            \
 139             case runtime_type: {                                               \
 140                 const compile_type *dataPtr =                                  \
 141                         static_cast<const compile_type*>(data);                \
 142                 return metadata->update(tag, dataPtr, dataCount);              \
 143             }                                                                  \
 144
 145             METADATA_UPDATE(TYPE_BYTE,     uint8_t);
 146             METADATA_UPDATE(TYPE_INT32,    int32_t);
 147             METADATA_UPDATE(TYPE_FLOAT,    float);
 148             METADATA_UPDATE(TYPE_INT64,    int64_t);
 149             METADATA_UPDATE(TYPE_DOUBLE,   double);
 150             METADATA_UPDATE(TYPE_RATIONAL, camera_metadata_rational_t);
 151
 152             default: {
 153                 // unreachable
 154                 ALOGE("%s: Unreachable", __FUNCTION__);
 155                 return INVALID_OPERATION;
 156             }
 157         }
 158
 159 #undef METADATA_UPDATE
 160     }
 161 };
 162 } // namespace {}
 163
 164 extern "C" {
 165
 166 static void CameraMetadata_classInit(JNIEnv *env, jobject thiz);
 167 static jobject CameraMetadata_getAllVendorKeys(JNIEnv* env, jobject thiz, jclass keyType);
 168 static jint CameraMetadata_getTagFromKey(JNIEnv *env, jobject thiz, jstring keyName);
 169 static jint CameraMetadata_getTypeFromTag(JNIEnv *env, jobject thiz, jint tag);
 170 static jint CameraMetadata_setupGlobalVendorTagDescriptor(JNIEnv *env, jobject thiz);
 171
 172 // Less safe access to native pointer. Does NOT throw any Java exceptions if NULL.
 173 static CameraMetadata* CameraMetadata_getPointerNoThrow(JNIEnv *env, jobject thiz) {
 174
 175     if (thiz == NULL) {
 176         return NULL;
 177     }
 178
 179     return reinterpret_cast<CameraMetadata*>(env->GetLongField(thiz, fields.metadata_ptr));
 180 }
 181
 182 // Safe access to native pointer from object. Throws if not possible to access.
 183 static CameraMetadata* CameraMetadata_getPointerThrow(JNIEnv *env, jobject thiz,
 184                                                  const char* argName = "this") {
 185
 186     if (thiz == NULL) {
 187         ALOGV("%s: Throwing java.lang.NullPointerException for null reference",
 188               __FUNCTION__);
 189         jniThrowNullPointerException(env, argName);
 190         return NULL;
 191     }
 192
 193     CameraMetadata* metadata = CameraMetadata_getPointerNoThrow(env, thiz);
 194     if (metadata == NULL) {
 195         ALOGV("%s: Throwing java.lang.IllegalStateException for closed object",
 196               __FUNCTION__);
 197         jniThrowException(env, "java/lang/IllegalStateException",
 198                             "Metadata object was already closed");
 199         return NULL;
 200     }
 201
 202     return metadata;
 203 }
 204
 205 static jlong CameraMetadata_allocate(JNIEnv *env, jobject thiz) {
 206     ALOGV("%s", __FUNCTION__);
 207
 208     return reinterpret_cast<jlong>(new CameraMetadata());
 209 }
 210
 211 static jlong CameraMetadata_allocateCopy(JNIEnv *env, jobject thiz,
 212         jobject other) {
 213     ALOGV("%s", __FUNCTION__);
 214
 215     CameraMetadata* otherMetadata =
 216             CameraMetadata_getPointerThrow(env, other, "other");
 217
 218     // In case of exception, return
 219     if (otherMetadata == NULL) return NULL;
 220
 221     // Clone native metadata and return new pointer
 222     return reinterpret_cast<jlong>(new CameraMetadata(*otherMetadata));
 223 }
 224
 225
 226 static jboolean CameraMetadata_isEmpty(JNIEnv *env, jobject thiz) {
 227     ALOGV("%s", __FUNCTION__);
 228
 229     CameraMetadata* metadata = CameraMetadata_getPointerThrow(env, thiz);
 230
 231     if (metadata == NULL) {
 232         ALOGW("%s: Returning early due to exception being thrown",
 233                __FUNCTION__);
 234         return JNI_TRUE; // actually throws java exc.
 235     }
 236
 237     jboolean empty = metadata->isEmpty();
 238
 239     ALOGV("%s: Empty returned %d, entry count was %zu",
 240           __FUNCTION__, empty, metadata->entryCount());
 241
 242     return empty;
 243 }
 244
 245 static jint CameraMetadata_getEntryCount(JNIEnv *env, jobject thiz) {
 246     ALOGV("%s", __FUNCTION__);
 247
 248     CameraMetadata* metadata = CameraMetadata_getPointerThrow(env, thiz);
 249
 250     if (metadata == NULL) return 0; // actually throws java exc.
 251
 252     return metadata->entryCount();
 253 }
 254
 255 // idempotent. calling more than once has no effect.
 256 static void CameraMetadata_close(JNIEnv *env, jobject thiz) {
 257     ALOGV("%s", __FUNCTION__);
 258
 259     CameraMetadata* metadata = CameraMetadata_getPointerNoThrow(env, thiz);
 260
 261     if (metadata != NULL) {
 262         delete metadata;
 263         env->SetLongField(thiz, fields.metadata_ptr, 0);
 264     }
 265
 266     LOG_ALWAYS_FATAL_IF(CameraMetadata_getPointerNoThrow(env, thiz) != NULL,
 267                         "Expected the native ptr to be 0 after #close");
 268 }
 269
 270 static void CameraMetadata_swap(JNIEnv *env, jobject thiz, jobject other) {
 271     ALOGV("%s", __FUNCTION__);
 272
 273     CameraMetadata* metadata = CameraMetadata_getPointerThrow(env, thiz);
 274
 275     // order is important: we can't call another JNI method
 276     // if there is an exception pending
 277     if (metadata == NULL) return;
 278
 279     CameraMetadata* otherMetadata = CameraMetadata_getPointerThrow(env, other, "other");
 280
 281     if (otherMetadata == NULL) return;
 282
 283     metadata->swap(*otherMetadata);
 284 }
 285
 286 static jbyteArray CameraMetadata_readValues(JNIEnv *env, jobject thiz, jint tag) {
 287     ALOGV("%s (tag = %d)", __FUNCTION__, tag);
 288
 289     CameraMetadata* metadata = CameraMetadata_getPointerThrow(env, thiz);
 290     if (metadata == NULL) return NULL;
 291
 292     int tagType = get_camera_metadata_tag_type(tag);
 293     if (tagType == -1) {
 294         jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException",
 295                              "Tag (%d) did not have a type", tag);
 296         return NULL;
 297     }
 298     size_t tagSize = Helpers::getTypeSize(tagType);
 299
 300     camera_metadata_entry entry = metadata->find(tag);
 301     if (entry.count == 0) {
 302          if (!metadata->exists(tag)) {
 303              ALOGV("%s: Tag %d does not have any entries", __FUNCTION__, tag);
 304              return NULL;
 305          } else {
 306              // OK: we will return a 0-sized array.
 307              ALOGV("%s: Tag %d had an entry, but it had 0 data", __FUNCTION__,
 308                    tag);
 309          }
 310     }
 311
 312     jsize byteCount = entry.count * tagSize;
 313     jbyteArray byteArray = env->NewByteArray(byteCount);
 314     if (env->ExceptionCheck()) return NULL;
 315
 316     // Copy into java array from native array
 317     ScopedByteArrayRW arrayWriter(env, byteArray);
 318     memcpy(arrayWriter.get(), entry.data.u8, byteCount);
 319
 320     return byteArray;
 321 }
 322
 323 static void CameraMetadata_writeValues(JNIEnv *env, jobject thiz, jint tag, jbyteArray src) {
 324     ALOGV("%s (tag = %d)", __FUNCTION__, tag);
 325
 326     CameraMetadata* metadata = CameraMetadata_getPointerThrow(env, thiz);
 327     if (metadata == NULL) return;
 328
 329     int tagType = get_camera_metadata_tag_type(tag);
 330     if (tagType == -1) {
 331         jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException",
 332                              "Tag (%d) did not have a type", tag);
 333         return;
 334     }
 335
 336     status_t res;
 337
 338     if (src == NULL) {
 339         // If array is NULL, delete the entry
 340         if (metadata->exists(tag)) {
 341             res = metadata->erase(tag);
 342             ALOGV("%s: Erase values (res = %d)", __FUNCTION__, res);
 343         } else {
 344             res = OK;
 345             ALOGV("%s: Don't need to erase", __FUNCTION__);
 346         }
 347     } else {
 348         // Copy from java array into native array
 349         ScopedByteArrayRO arrayReader(env, src);
 350         if (arrayReader.get() == NULL) return;
 351
 352         res = Helpers::updateAny(metadata, static_cast<uint32_t>(tag),
 353                                  tagType, arrayReader.get(), arrayReader.size());
 354
 355         ALOGV("%s: Update values (res = %d)", __FUNCTION__, res);
 356     }
 357
 358     if (res == OK) {
 359         return;
 360     } else if (res == BAD_VALUE) {
 361         jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException",
 362                              "Src byte array was poorly formed");
 363     } else if (res == INVALID_OPERATION) {
 364         jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
 365                              "Internal error while trying to update metadata");
 366     } else {
 367         jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
 368                              "Unknown error (%d) while trying to update "
 369                             "metadata", res);
 370     }
 371 }
 372
 373 struct DumpMetadataParams {
 374     int writeFd;
 375     const CameraMetadata* metadata;
 376 };
 377
 378 static void* CameraMetadata_writeMetadataThread(void* arg) {
 379     DumpMetadataParams* p = static_cast<DumpMetadataParams*>(arg);
 380
 381     /*
 382      * Write the dumped data, and close the writing side FD.
 383      */
 384     p->metadata->dump(p->writeFd, /*verbosity*/2);
 385
 386     if (close(p->writeFd) < 0) {
 387         ALOGE("%s: Failed to close writeFd (errno = %#x, message = '%s')",
 388                 __FUNCTION__, errno, strerror(errno));
 389     }
 390
 391     return NULL;
 392 }
 393
 394 static void CameraMetadata_dump(JNIEnv *env, jobject thiz) {
 395     ALOGV("%s", __FUNCTION__);
 396     CameraMetadata* metadata = CameraMetadata_getPointerThrow(env, thiz);
 397     if (metadata == NULL) {
 398         return;
 399     }
 400
 401     /*
 402      * Create a socket pair for local streaming read/writes.
 403      *
 404      * The metadata will be dumped into the write side,
 405      * and then read back out (and logged) via the read side.
 406      */
 407
 408     int writeFd, readFd;
 409     {
 410
 411         int sv[2];
 412         if (socketpair(AF_LOCAL, SOCK_STREAM, /*protocol*/0, &sv[0]) < 0) {
 413             jniThrowExceptionFmt(env, "java/io/IOException",
 414                     "Failed to create socketpair (errno = %#x, message = '%s')",
 415                     errno, strerror(errno));
 416             return;
 417         }
 418         writeFd = sv[0];
 419         readFd = sv[1];
 420     }
 421
 422     /*
 423      * Create a thread for doing the writing.
 424      *
 425      * The reading and writing must be concurrent, otherwise
 426      * the write will block forever once it exhausts the capped
 427      * buffer size (from getsockopt).
 428      */
 429     pthread_t writeThread;
 430     DumpMetadataParams params = {
 431         writeFd,
 432         metadata
 433     };
 434
 435     {
 436         int threadRet = pthread_create(&writeThread, /*attr*/NULL,
 437                 CameraMetadata_writeMetadataThread, (void*)&params);
 438
 439         if (threadRet != 0) {
 440             close(writeFd);
 441
 442             jniThrowExceptionFmt(env, "java/io/IOException",
 443                     "Failed to create thread for writing (errno = %#x, message = '%s')",
 444                     threadRet, strerror(threadRet));
 445         }
 446     }
 447
 448     /*
 449      * Read out a byte until stream is complete. Write completed lines
 450      * to ALOG.
 451      */
 452     {
 453         char out[] = {'\0', '\0'}; // large enough to append as a string
 454         String8 logLine;
 455
 456         // Read one byte at a time! Very slow but avoids complicated \n scanning.
 457         ssize_t res;
 458         while ((res = TEMP_FAILURE_RETRY(read(readFd, &out[0], /*count*/1))) > 0) {
 459             if (out[0] == '\n') {
 460                 ALOGD("%s", logLine.string());
 461                 logLine.clear();
 462             } else {
 463                 logLine.append(out);
 464             }
 465         }
 466
 467         if (res < 0) {
 468             jniThrowExceptionFmt(env, "java/io/IOException",
 469                     "Failed to read from fd (errno = %#x, message = '%s')",
 470                     errno, strerror(errno));
 471             //return;
 472         } else if (!logLine.isEmpty()) {
 473             ALOGD("%s", logLine.string());
 474         }
 475     }
 476
 477     int res;
 478
 479     // Join until thread finishes. Ensures params/metadata is valid until then.
 480     if ((res = pthread_join(writeThread, /*retval*/NULL)) != 0) {
 481         ALOGE("%s: Failed to join thread (errno = %#x, message = '%s')",
 482                 __FUNCTION__, res, strerror(res));
 483     }
 484 }
 485
 486 static void CameraMetadata_readFromParcel(JNIEnv *env, jobject thiz, jobject parcel) {
 487     ALOGV("%s", __FUNCTION__);
 488     CameraMetadata* metadata = CameraMetadata_getPointerThrow(env, thiz);
 489     if (metadata == NULL) {
 490         return;
 491     }
 492
 493     Parcel* parcelNative = parcelForJavaObject(env, parcel);
 494     if (parcelNative == NULL) {
 495         jniThrowNullPointerException(env, "parcel");
 496         return;
 497     }
 498
 499     status_t err;
 500     if ((err = metadata->readFromParcel(parcelNative)) != OK) {
 501         jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
 502                              "Failed to read from parcel (error code %d)", err);
 503         return;
 504     }
 505 }
 506
 507 static void CameraMetadata_writeToParcel(JNIEnv *env, jobject thiz, jobject parcel) {
 508     ALOGV("%s", __FUNCTION__);
 509     CameraMetadata* metadata = CameraMetadata_getPointerThrow(env, thiz);
 510     if (metadata == NULL) {
 511         return;
 512     }
 513
 514     Parcel* parcelNative = parcelForJavaObject(env, parcel);
 515     if (parcelNative == NULL) {
 516         jniThrowNullPointerException(env, "parcel");
 517         return;
 518     }
 519
 520     status_t err;
 521     if ((err = metadata->writeToParcel(parcelNative)) != OK) {
 522         jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
 523                                   "Failed to write to parcel (error code %d)", err);
 524         return;
 525     }
 526 }
 527
 528 } // extern "C"
 529
 530 //-------------------------------------------------
 531
 532 static const JNINativeMethod gCameraMetadataMethods[] = {
 533 // static methods
 534   { "nativeClassInit",
 535     "()V",
 536     (void *)CameraMetadata_classInit },
 537   { "nativeGetAllVendorKeys",
 538     "(Ljava/lang/Class;)Ljava/util/ArrayList;",
 539     (void *)CameraMetadata_getAllVendorKeys},
 540   { "nativeGetTagFromKey",
 541     "(Ljava/lang/String;)I",
 542     (void *)CameraMetadata_getTagFromKey },
 543   { "nativeGetTypeFromTag",
 544     "(I)I",
 545     (void *)CameraMetadata_getTypeFromTag },
 546   { "nativeSetupGlobalVendorTagDescriptor",
 547     "()I",
 548     (void*)CameraMetadata_setupGlobalVendorTagDescriptor },
 549 // instance methods
 550   { "nativeAllocate",
 551     "()J",
 552     (void*)CameraMetadata_allocate },
 553   { "nativeAllocateCopy",
 554     "(L" CAMERA_METADATA_CLASS_NAME ";)J",
 555     (void *)CameraMetadata_allocateCopy },
 556   { "nativeIsEmpty",
 557     "()Z",
 558     (void*)CameraMetadata_isEmpty },
 559   { "nativeGetEntryCount",
 560     "()I",
 561     (void*)CameraMetadata_getEntryCount },
 562   { "nativeClose",
 563     "()V",
 564     (void*)CameraMetadata_close },
 565   { "nativeSwap",
 566     "(L" CAMERA_METADATA_CLASS_NAME ";)V",
 567     (void *)CameraMetadata_swap },
 568   { "nativeReadValues",
 569     "(I)[B",
 570     (void *)CameraMetadata_readValues },
 571   { "nativeWriteValues",
 572     "(I[B)V",
 573     (void *)CameraMetadata_writeValues },
 574   { "nativeDump",
 575     "()V",
 576     (void *)CameraMetadata_dump },
 577 // Parcelable interface
 578   { "nativeReadFromParcel",
 579     "(Landroid/os/Parcel;)V",
 580     (void *)CameraMetadata_readFromParcel },
 581   { "nativeWriteToParcel",
 582     "(Landroid/os/Parcel;)V",
 583     (void *)CameraMetadata_writeToParcel },
 584 };
 585
 586 struct field {
 587     const char *class_name;
 588     const char *field_name;
 589     const char *field_type;
 590     jfieldID   *jfield;
 591 };
 592
 593 static int find_fields(JNIEnv *env, field *fields, int count)
 594 {
 595     for (int i = 0; i < count; i++) {
 596         field *f = &fields[i];
 597         jclass clazz = env->FindClass(f->class_name);
 598         if (clazz == NULL) {
 599             ALOGE("Can't find %s", f->class_name);
 600             return -1;
 601         }
 602
 603         jfieldID field = env->GetFieldID(clazz, f->field_name, f->field_type);
 604         if (field == NULL) {
 605             ALOGE("Can't find %s.%s", f->class_name, f->field_name);
 606             return -1;
 607         }
 608
 609         *(f->jfield) = field;
 610     }
 611
 612     return 0;
 613 }
 614
 615 // Get all the required offsets in java class and register native functions
 616 int register_android_hardware_camera2_CameraMetadata(JNIEnv *env)
 617 {
 618
 619     // Store global references to Key-related classes and methods used natively
 620     jclass characteristicsKeyClazz = FindClassOrDie(env, CHARACTERISTICS_KEY_CLASS_NAME);
 621     jclass requestKeyClazz = FindClassOrDie(env, REQUEST_KEY_CLASS_NAME);
 622     jclass resultKeyClazz = FindClassOrDie(env, RESULT_KEY_CLASS_NAME);
 623     gMetadataOffsets.mCharacteristicsKey = MakeGlobalRefOrDie(env, characteristicsKeyClazz);
 624     gMetadataOffsets.mRequestKey = MakeGlobalRefOrDie(env, requestKeyClazz);
 625     gMetadataOffsets.mResultKey = MakeGlobalRefOrDie(env, resultKeyClazz);
 626     gMetadataOffsets.mCharacteristicsConstr = GetMethodIDOrDie(env,
 627             gMetadataOffsets.mCharacteristicsKey, "<init>",
 628             "(Ljava/lang/String;Ljava/lang/Class;)V");
 629     gMetadataOffsets.mRequestConstr = GetMethodIDOrDie(env,
 630             gMetadataOffsets.mRequestKey, "<init>", "(Ljava/lang/String;Ljava/lang/Class;)V");
 631     gMetadataOffsets.mResultConstr = GetMethodIDOrDie(env,
 632             gMetadataOffsets.mResultKey, "<init>", "(Ljava/lang/String;Ljava/lang/Class;)V");
 633
 634     // Store global references for primitive array types used by Keys
 635     jclass byteClazz = FindClassOrDie(env, "[B");
 636     jclass int32Clazz = FindClassOrDie(env, "[I");
 637     jclass floatClazz = FindClassOrDie(env, "[F");
 638     jclass int64Clazz = FindClassOrDie(env, "[J");
 639     jclass doubleClazz = FindClassOrDie(env, "[D");
 640     jclass rationalClazz = FindClassOrDie(env, "[Landroid/util/Rational;");
 641     gMetadataOffsets.mByteArray = MakeGlobalRefOrDie(env, byteClazz);
 642     gMetadataOffsets.mInt32Array = MakeGlobalRefOrDie(env, int32Clazz);
 643     gMetadataOffsets.mFloatArray = MakeGlobalRefOrDie(env, floatClazz);
 644     gMetadataOffsets.mInt64Array = MakeGlobalRefOrDie(env, int64Clazz);
 645     gMetadataOffsets.mDoubleArray = MakeGlobalRefOrDie(env, doubleClazz);
 646     gMetadataOffsets.mRationalArray = MakeGlobalRefOrDie(env, rationalClazz);
 647
 648     // Store global references for ArrayList methods used
 649     jclass arrayListClazz = FindClassOrDie(env, "java/util/ArrayList");
 650     gMetadataOffsets.mArrayList = MakeGlobalRefOrDie(env, arrayListClazz);
 651     gMetadataOffsets.mArrayListConstr = GetMethodIDOrDie(env, gMetadataOffsets.mArrayList,
 652             "<init>", "(I)V");
 653     gMetadataOffsets.mArrayListAdd = GetMethodIDOrDie(env, gMetadataOffsets.mArrayList,
 654             "add", "(Ljava/lang/Object;)Z");
 655
 656     // Register native functions
 657     return RegisterMethodsOrDie(env,
 658             CAMERA_METADATA_CLASS_NAME,
 659             gCameraMetadataMethods,
 660             NELEM(gCameraMetadataMethods));
 661 }
 662
 663 extern "C" {
 664
 665 static void CameraMetadata_classInit(JNIEnv *env, jobject thiz) {
 666     // XX: Why do this separately instead of doing it in the register function?
 667     ALOGV("%s", __FUNCTION__);
 668
 669     field fields_to_find[] = {
 670         { CAMERA_METADATA_CLASS_NAME, "mMetadataPtr", "J", &fields.metadata_ptr },
 671     };
 672
 673     // Do this here instead of in register_native_methods,
 674     // since otherwise it will fail to find the fields.
 675     if (find_fields(env, fields_to_find, NELEM(fields_to_find)) < 0)
 676         return;
 677
 678     env->FindClass(CAMERA_METADATA_CLASS_NAME);
 679 }
 680
 681 static jobject CameraMetadata_getAllVendorKeys(JNIEnv* env, jobject thiz, jclass keyType) {
 682
 683     // Get all vendor tags
 684     sp<VendorTagDescriptor> vTags = VendorTagDescriptor::getGlobalVendorTagDescriptor();
 685     if (vTags.get() == nullptr) {
 686         // No vendor tags.
 687         return NULL;
 688     }
 689
 690     int count = vTags->getTagCount();
 691     if (count <= 0) {
 692         // No vendor tags.
 693         return NULL;
 694     }
 695
 696     std::vector<uint32_t> tagIds(count, /*initializer value*/0);
 697     vTags->getTagArray(&tagIds[0]);
 698
 699     // Which key class/constructor should we use?
 700     jclass keyClazz;
 701     jmethodID keyConstr;
 702     if (env->IsSameObject(keyType, gMetadataOffsets.mCharacteristicsKey)) {
 703         keyClazz = gMetadataOffsets.mCharacteristicsKey;
 704         keyConstr = gMetadataOffsets.mCharacteristicsConstr;
 705     } else if (env->IsSameObject(keyType, gMetadataOffsets.mResultKey)) {
 706         keyClazz = gMetadataOffsets.mResultKey;
 707         keyConstr = gMetadataOffsets.mResultConstr;
 708     } else if (env->IsSameObject(keyType, gMetadataOffsets.mRequestKey)) {
 709         keyClazz = gMetadataOffsets.mRequestKey;
 710         keyConstr = gMetadataOffsets.mRequestConstr;
 711     } else {
 712         jniThrowException(env, "java/lang/IllegalArgumentException",
 713                 "Invalid key class given as argument.");
 714         return NULL;
 715     }
 716
 717     // Allocate arrayList to return
 718     jobject arrayList = env->NewObject(gMetadataOffsets.mArrayList,
 719             gMetadataOffsets.mArrayListConstr, static_cast<jint>(count));
 720     if (env->ExceptionCheck()) {
 721         return NULL;
 722     }
 723
 724     for (uint32_t id : tagIds) {
 725         const char* section = vTags->getSectionName(id);
 726         const char* tag = vTags->getTagName(id);
 727         int type = vTags->getTagType(id);
 728
 729         size_t totalLen = strlen(section) + strlen(tag) + 2;
 730         std::vector<char> fullName(totalLen, 0);
 731         snprintf(&fullName[0], totalLen, "%s.%s", section, tag);
 732
 733         jstring name = env->NewStringUTF(&fullName[0]);
 734
 735         if (env->ExceptionCheck()) {
 736             return NULL;
 737         }
 738
 739         jclass valueClazz;
 740         switch (type) {
 741             case TYPE_BYTE:
 742                 valueClazz = gMetadataOffsets.mByteArray;
 743                 break;
 744             case TYPE_INT32:
 745                 valueClazz = gMetadataOffsets.mInt32Array;
 746                 break;
 747             case TYPE_FLOAT:
 748                 valueClazz = gMetadataOffsets.mFloatArray;
 749                 break;
 750             case TYPE_INT64:
 751                 valueClazz = gMetadataOffsets.mInt64Array;
 752                 break;
 753             case TYPE_DOUBLE:
 754                 valueClazz = gMetadataOffsets.mDoubleArray;
 755                 break;
 756             case TYPE_RATIONAL:
 757                 valueClazz = gMetadataOffsets.mRationalArray;
 758                 break;
 759             default:
 760                 jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
 761                         "Invalid type %d given for key %s", type, &fullName[0]);
 762                 return NULL;
 763         }
 764
 765         jobject key = env->NewObject(keyClazz, keyConstr, name, valueClazz);
 766         if (env->ExceptionCheck()) {
 767             return NULL;
 768         }
 769
 770         env->CallBooleanMethod(arrayList, gMetadataOffsets.mArrayListAdd, key);
 771         if (env->ExceptionCheck()) {
 772             return NULL;
 773         }
 774
 775         env->DeleteLocalRef(name);
 776         env->DeleteLocalRef(key);
 777     }
 778
 779     return arrayList;
 780 }
 781
 782 static jint CameraMetadata_getTagFromKey(JNIEnv *env, jobject thiz, jstring keyName) {
 783
 784     ScopedUtfChars keyScoped(env, keyName);
 785     const char *key = keyScoped.c_str();
 786     if (key == NULL) {
 787         // exception thrown by ScopedUtfChars
 788         return 0;
 789     }
 790     ALOGV("%s (key = '%s')", __FUNCTION__, key);
 791
 792     uint32_t tag = 0;
 793     sp<VendorTagDescriptor> vTags =
 794             VendorTagDescriptor::getGlobalVendorTagDescriptor();
 795     status_t res = CameraMetadata::getTagFromName(key, vTags.get(), &tag);
 796     if (res != OK) {
 797         jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException",
 798                              "Could not find tag for key '%s')", key);
 799     }
 800     return tag;
 801 }
 802
 803 static jint CameraMetadata_getTypeFromTag(JNIEnv *env, jobject thiz, jint tag) {
 804     int tagType = get_camera_metadata_tag_type(tag);
 805     if (tagType == -1) {
 806         jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException",
 807                              "Tag (%d) did not have a type", tag);
 808         return -1;
 809     }
 810
 811     return tagType;
 812 }
 813
 814 static jint CameraMetadata_setupGlobalVendorTagDescriptor(JNIEnv *env, jobject thiz) {
 815     const String16 NAME("media.camera");
 816     sp<hardware::ICameraService> cameraService;
 817     status_t err = getService(NAME, /*out*/&cameraService);
 818
 819     if (err != OK) {
 820         ALOGE("%s: Failed to get camera service, received error %s (%d)", __FUNCTION__,
 821                 strerror(-err), err);
 822         return hardware::ICameraService::ERROR_DISCONNECTED;
 823     }
 824
 825     sp<VendorTagDescriptor> desc = new VendorTagDescriptor();
 826     binder::Status res = cameraService->getCameraVendorTagDescriptor(/*out*/desc.get());
 827
 828     if (res.serviceSpecificErrorCode() == hardware::ICameraService::ERROR_DISCONNECTED) {
 829         // No camera module available, not an error on devices with no cameras
 830         VendorTagDescriptor::clearGlobalVendorTagDescriptor();
 831         return OK;
 832     } else if (!res.isOk()) {
 833         VendorTagDescriptor::clearGlobalVendorTagDescriptor();
 834         ALOGE("%s: Failed to setup vendor tag descriptors: %s",
 835                 __FUNCTION__, res.toString8().string());
 836         return res.serviceSpecificErrorCode();
 837     }
 838
 839     err = VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
 840
 841     if (err != OK) {
 842         return hardware::ICameraService::ERROR_INVALID_OPERATION;
 843     }
 844     return OK;
 845 }
 846
 847 } // extern "C"