DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
12111 Commits
9 Branches
2.6GB
Tree: 61c638106f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '61c638106f'
${ noResults }
JUCE/modules/juce_video/native/juce_android_CameraDevice.h

3294 lines
146KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2020 - Raw Material Software Limited

  6. 

  7.    JUCE is an open source library subject to commercial or open-source

  8.    licensing.

  9. 

  10.    By using JUCE, you agree to the terms of both the JUCE 6 End-User License

  11.    Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).

  12. 

  13.    End User License Agreement: www.juce.com/juce-6-licence

  14.    Privacy Policy: www.juce.com/juce-privacy-policy

  15. 

  16.    Or: You may also use this code under the terms of the GPL v3 (see

  17.    www.gnu.org/licenses).

  18. 

  19.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  20.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  21.    DISCLAIMED.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. //==============================================================================

  27. // This byte-code is generated from:

  28. //

  29. // native/java/com/rmsl/juce/CameraCaptureSessionCaptureCallback.java

  30. // native/java/com/rmsl/juce/CameraCaptureSessionStateCallback.java

  31. // native/java/com/rmsl/juce/CameraDeviceStateCallback.java

  32. // native/java/com/rmsl/juce/JuceOrientationEventListener.java

  33. //

  34. // files with min sdk version 21

  35. // See juce_core/native/java/README.txt on how to generate this byte-code.

  36. static const uint8 CameraSupportByteCode[] =

  37. {31,139,8,8,187,110,161,94,0,3,67,97,109,101,114,97,83,117,112,112,111,114,116,66,121,116,101,67,111,100,101,46,100,101,120,0,

  38. 149,152,93,108,28,213,21,199,207,157,157,221,89,239,174,215,227,181,243,217,36,56,95,182,3,113,54,137,227,40,101,29,59,198,113,

  39. 192,102,133,169,215,182,34,3,45,147,221,73,188,176,222,89,102,215,139,171,86,37,68,84,208,151,42,80,90,168,4,136,170,20,181,15,

  40. 84,110,9,132,7,30,82,21,149,240,0,10,136,190,165,18,84,133,7,154,7,132,42,20,85,60,244,127,63,198,158,93,175,93,99,233,183,

  41. 255,51,115,206,61,247,222,115,239,140,103,38,103,47,68,14,246,246,209,213,103,22,174,255,247,133,96,249,25,246,233,195,151,255,

  42. 18,189,241,193,31,255,57,248,226,196,252,238,238,4,81,137,136,22,166,143,192,146,127,79,181,18,157,38,121,190,13,92,99,68,91,

  43. 160,219,52,162,32,244,174,0,81,55,247,67,117,232,34,126,110,198,136,14,194,249,86,152,232,10,248,2,36,154,136,14,131,62,112,12,

  44. 220,7,170,224,50,248,26,116,69,136,190,15,158,4,127,6,255,0,70,148,232,40,248,1,120,22,188,11,190,2,29,200,191,27,116,129,219,

  45. 120,95,160,15,164,192,9,112,39,24,7,167,193,131,32,7,242,192,1,85,240,99,240,24,120,18,252,22,188,7,110,128,182,102,162,65,48,7,

  46. 158,6,175,129,143,192,87,160,57,78,212,9,70,192,3,160,10,30,3,191,6,47,131,63,128,55,193,219,224,93,240,33,248,12,124,13,162,

  47. 45,68,123,193,16,200,128,7,64,9,252,4,252,28,60,7,126,3,46,131,43,224,125,112,29,124,6,254,13,254,3,190,1,97,147,168,21,236,2,

  48. 221,166,172,55,95,3,3,160,196,132,50,18,202,70,40,17,97,58,132,97,19,186,39,52,37,132,19,150,146,18,106,29,219,193,6,176,17,

  49. 116,42,109,85,107,190,73,217,139,72,188,89,217,111,25,114,221,185,125,5,246,119,148,125,21,246,86,101,127,236,179,175,251,98,

  50. 254,5,123,155,178,191,132,189,93,217,55,97,239,80,182,142,9,220,162,236,118,216,29,202,222,227,179,143,248,236,147,176,119,41,

  51. 123,18,246,78,101,223,239,59,159,131,189,91,217,5,216,123,148,189,0,123,175,178,159,240,217,23,125,246,11,190,156,191,247,229,

  52. 92,12,243,186,50,234,23,245,77,208,184,168,177,60,110,81,106,42,13,168,122,234,74,67,74,99,98,69,120,251,176,210,56,237,19,26,

  53. 163,91,133,54,211,109,66,155,104,191,208,8,245,8,141,210,1,161,27,105,80,104,59,157,16,186,129,134,132,182,210,29,106,92,195,66,

  54. 219,232,164,24,159,38,250,137,99,183,116,43,77,42,61,168,244,144,210,195,66,77,26,80,58,162,244,148,210,59,149,166,197,124,

  55. 101,222,22,204,172,87,233,17,161,6,245,169,227,163,66,55,137,60,92,239,18,186,153,70,213,241,152,168,151,172,144,137,138,29,83,

  56. 245,187,155,228,254,101,190,58,50,165,31,155,164,230,35,207,121,245,213,148,38,212,70,110,81,126,175,238,94,158,83,202,111,

  57. 42,127,172,110,125,92,229,15,34,51,247,247,154,242,250,42,153,60,126,6,151,208,253,237,12,189,199,224,231,215,222,113,83,230,

  58. 200,92,32,154,122,130,145,241,184,241,75,227,85,227,114,213,8,146,63,238,212,170,113,161,154,184,241,85,227,12,17,23,193,76,248,

  59. 88,79,155,242,90,207,184,136,171,32,238,17,227,167,236,87,213,80,88,68,201,245,228,227,126,208,203,247,52,226,126,129,184,139,

  60. 198,43,236,13,253,111,213,112,147,136,74,160,87,126,223,200,155,178,166,153,63,33,238,117,196,45,26,239,24,127,215,63,15,226,

  61. 198,83,141,68,68,172,142,190,121,77,202,166,172,87,201,100,162,38,154,240,105,98,45,126,164,124,153,14,141,74,39,18,164,29,90,

  62. 246,93,168,241,181,213,248,126,86,227,107,175,241,93,172,241,109,168,241,61,87,227,219,168,124,114,156,47,45,141,83,19,227,12,

  63. 248,198,249,234,82,187,0,218,109,175,201,249,90,141,111,135,240,5,145,147,223,111,47,249,125,147,183,212,180,123,187,166,93,

  64. 135,240,133,68,75,162,191,122,99,57,24,160,161,224,76,66,247,141,229,253,165,118,58,218,117,138,118,222,126,103,10,205,119,61,

  65. 48,181,219,229,185,160,82,67,249,12,159,47,33,242,115,13,146,252,127,225,217,222,181,33,143,155,136,137,76,203,199,225,154,248,

  66. 38,177,71,252,199,81,213,135,55,174,160,178,131,106,140,94,31,242,255,148,204,31,80,118,120,41,70,230,245,236,168,106,99,168,

  67. 92,92,67,253,249,98,190,50,64,221,195,214,156,237,90,195,86,169,50,239,218,25,187,92,206,59,69,117,52,108,21,10,103,172,236,195,

  68. 7,30,178,170,22,117,54,138,204,84,172,74,93,220,14,25,119,210,174,230,179,118,3,63,27,37,54,70,59,199,230,179,246,184,155,

  69. 183,139,136,64,162,145,42,172,116,190,92,177,139,182,43,3,183,164,173,98,206,117,242,185,100,214,41,226,124,37,57,204,117,161,

  70. 146,162,193,37,215,172,229,230,30,181,92,59,153,21,189,30,78,54,26,229,158,186,9,165,232,248,183,76,80,51,143,20,37,191,93,243,

  71. 20,245,253,191,6,178,92,245,253,116,173,175,89,138,246,173,21,40,134,114,202,202,23,32,235,9,157,176,31,153,183,203,40,115,247,

  72. 58,66,203,243,5,68,246,172,30,57,233,84,172,66,93,248,242,188,170,121,251,209,228,106,251,32,69,189,233,172,51,151,116,231,

  73. 202,133,228,67,216,48,13,171,187,98,113,15,173,163,81,93,161,247,53,108,210,96,15,167,104,127,93,232,90,27,57,69,108,154,180,

  74. 233,81,48,70,129,233,177,81,254,147,38,29,63,194,156,161,32,126,96,135,132,140,145,193,53,61,54,38,79,164,211,104,152,70,32,34,

  75. 244,105,238,15,78,11,47,14,224,99,51,20,146,85,166,173,217,6,115,28,202,86,242,85,155,246,52,242,121,69,115,230,74,5,187,98,231,

  76. 104,231,26,81,124,239,32,100,239,26,33,247,186,206,57,23,103,16,118,235,26,97,25,190,181,138,89,123,232,140,227,242,94,247,

  77. 175,35,118,121,140,187,214,138,174,88,34,99,195,74,12,23,28,62,178,221,13,125,78,241,108,254,220,242,44,119,172,25,148,163,45,

  78. 141,252,19,182,149,251,33,109,202,174,216,54,178,227,237,43,28,39,243,101,220,213,138,118,150,143,121,227,10,247,136,235,58,

  79. 110,131,124,227,37,108,171,28,25,89,121,39,164,205,57,225,243,237,191,225,89,171,120,14,33,65,91,164,48,206,202,235,158,162,103,

  80. 93,36,187,103,126,238,140,237,146,62,235,148,43,212,196,127,39,157,169,178,77,225,165,221,146,104,176,55,90,234,119,66,91,

  81. 163,117,223,188,234,42,111,93,99,77,205,21,43,24,94,90,175,214,149,171,19,171,89,139,184,83,172,41,164,129,235,79,76,27,57,84,

  82. 169,218,97,173,172,142,225,45,89,212,89,118,82,115,9,35,200,91,5,121,155,34,163,228,218,252,254,68,186,139,210,147,225,202,251,

  83. 34,133,92,233,143,148,213,108,70,145,176,44,55,2,181,148,103,157,249,66,238,14,84,70,53,174,204,230,203,212,84,201,207,161,173,

  84. 53,87,162,30,109,96,218,136,247,247,244,208,209,192,212,68,198,136,95,162,126,24,41,110,12,195,24,231,198,168,54,53,105,196,

  85. 127,71,227,129,169,201,126,126,98,90,159,154,56,13,235,35,218,207,6,120,115,234,101,83,70,124,134,190,43,101,80,202,136,148,187,

  86. 165,116,169,208,3,172,155,31,30,145,114,187,214,125,59,215,19,242,176,51,48,112,236,123,70,252,56,15,187,135,159,32,13,15,

  87. 207,26,211,244,243,231,245,197,8,187,128,167,188,6,68,217,181,8,99,55,193,203,81,198,174,130,47,193,243,49,98,161,160,166,181,

  88. 162,237,59,177,70,237,54,177,79,98,140,125,3,158,111,102,236,18,184,134,151,191,160,30,208,182,161,205,141,230,250,248,157,236,

  89. 169,56,99,175,128,43,224,58,30,225,52,166,107,123,31,63,175,223,140,115,127,23,123,182,69,190,215,120,207,117,158,122,223,88,

  90. 248,51,143,247,157,133,63,19,121,223,90,188,119,125,254,189,133,171,247,205,37,68,203,223,93,88,135,124,175,231,223,94,152,41,

  91. 223,221,249,59,188,214,33,243,243,239,49,1,21,195,223,105,248,203,52,111,43,222,167,76,57,14,254,189,231,127,249,28,121,55,40,18,

  92. 0,0,0,0};

  93. 

  94. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK)    \

  95.  STATICMETHOD (valueOf, "valueOf", "(Ljava/lang/String;)Landroid/graphics/Bitmap$CompressFormat;")

  96. 

  97. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidBitmapCompressFormat, "android/graphics/Bitmap$CompressFormat", 21)

  98. #undef JNI_CLASS_MEMBERS

  99. 

  100. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  101.  METHOD (close,                "close",                "()V") \

  102.  METHOD (createCaptureRequest, "createCaptureRequest", "(I)Landroid/hardware/camera2/CaptureRequest$Builder;") \

  103.  METHOD (createCaptureSession, "createCaptureSession", "(Ljava/util/List;Landroid/hardware/camera2/CameraCaptureSession$StateCallback;Landroid/os/Handler;)V")

  104. 

  105. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidCameraDevice, "android/hardware/camera2/CameraDevice", 21)

  106. #undef JNI_CLASS_MEMBERS

  107. 

  108. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  109.  METHOD (close,     "close",     "()V") \

  110.  METHOD (getPlanes, "getPlanes", "()[Landroid/media/Image$Plane;")

  111. 

  112. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidImage, "android/media/Image", 21)

  113. #undef JNI_CLASS_MEMBERS

  114. 

  115. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  116.  METHOD (getBuffer, "getBuffer", "()Ljava/nio/ByteBuffer;")

  117. 

  118. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidImagePlane, "android/media/Image$Plane", 21)

  119. #undef JNI_CLASS_MEMBERS

  120. 

  121. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  122.  METHOD (acquireLatestImage,          "acquireLatestImage",          "()Landroid/media/Image;") \

  123.  METHOD (close,                       "close",                       "()V") \

  124.  METHOD (getSurface,                  "getSurface",                  "()Landroid/view/Surface;") \

  125.  METHOD (setOnImageAvailableListener, "setOnImageAvailableListener", "(Landroid/media/ImageReader$OnImageAvailableListener;Landroid/os/Handler;)V") \

  126.  STATICMETHOD (newInstance, "newInstance", "(IIII)Landroid/media/ImageReader;")

  127. 

  128. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidImageReader, "android/media/ImageReader", 21)

  129. #undef JNI_CLASS_MEMBERS

  130. 

  131. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  132.  METHOD (constructor,             "<init>",                  "()V") \

  133.  METHOD (getSurface,              "getSurface",              "()Landroid/view/Surface;") \

  134.  METHOD (prepare,                 "prepare",                 "()V") \

  135.  METHOD (release,                 "release",                 "()V") \

  136.  METHOD (setAudioEncoder,         "setAudioEncoder",         "(I)V") \

  137.  METHOD (setAudioSource,          "setAudioSource",          "(I)V") \

  138.  METHOD (setOnErrorListener,      "setOnErrorListener",      "(Landroid/media/MediaRecorder$OnErrorListener;)V") \

  139.  METHOD (setOnInfoListener,       "setOnInfoListener",       "(Landroid/media/MediaRecorder$OnInfoListener;)V") \

  140.  METHOD (setOrientationHint,      "setOrientationHint",      "(I)V") \

  141.  METHOD (setOutputFile,           "setOutputFile",           "(Ljava/lang/String;)V") \

  142.  METHOD (setOutputFormat,         "setOutputFormat",         "(I)V") \

  143.  METHOD (setVideoEncoder,         "setVideoEncoder",         "(I)V") \

  144.  METHOD (setVideoEncodingBitRate, "setVideoEncodingBitRate", "(I)V") \

  145.  METHOD (setVideoFrameRate,       "setVideoFrameRate",       "(I)V") \

  146.  METHOD (setVideoSize,            "setVideoSize",            "(II)V") \

  147.  METHOD (setVideoSource,          "setVideoSource",          "(I)V") \

  148.  METHOD (start,                   "start",                   "()V") \

  149.  METHOD (stop,                    "stop",                    "()V")

  150. 

  151. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidMediaRecorder, "android/media/MediaRecorder", 21)

  152. #undef JNI_CLASS_MEMBERS

  153. 

  154. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  155.  METHOD (constructor,               "<init>",                    "(Landroid/content/Context;)V") \

  156.  METHOD (getSurfaceTexture,         "getSurfaceTexture",         "()Landroid/graphics/SurfaceTexture;") \

  157.  METHOD (isAvailable,               "isAvailable",               "()Z") \

  158.  METHOD (setSurfaceTextureListener, "setSurfaceTextureListener", "(Landroid/view/TextureView$SurfaceTextureListener;)V") \

  159.  METHOD (setTransform,              "setTransform",              "(Landroid/graphics/Matrix;)V")

  160. 

  161. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidTextureView, "android/view/TextureView", 21)

  162. #undef JNI_CLASS_MEMBERS

  163. 

  164. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  165.  METHOD (constructor, "<init>", "(Landroid/graphics/SurfaceTexture;)V")

  166. 

  167. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidSurface, "android/view/Surface", 21)

  168. #undef JNI_CLASS_MEMBERS

  169. 

  170. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  171.  METHOD (setDefaultBufferSize, "setDefaultBufferSize", "(II)V")

  172. 

  173. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidSurfaceTexture, "android/graphics/SurfaceTexture", 21)

  174. #undef JNI_CLASS_MEMBERS

  175. 

  176. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  177.  METHOD (getOutputSizesForClass,      "getOutputSizes",       "(Ljava/lang/Class;)[Landroid/util/Size;") \

  178.  METHOD (getOutputSizesForFormat,     "getOutputSizes",       "(I)[Landroid/util/Size;") \

  179.  METHOD (isOutputSupportedFor,        "isOutputSupportedFor", "(I)Z") \

  180.  METHOD (isOutputSupportedForSurface, "isOutputSupportedFor", "(Landroid/view/Surface;)Z")

  181. 

  182. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidStreamConfigurationMap, "android/hardware/camera2/params/StreamConfigurationMap", 21)

  183. #undef JNI_CLASS_MEMBERS

  184. 

  185. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  186.  METHOD (constructor, "<init>",      "()V") \

  187.  METHOD (toByteArray, "toByteArray", "()[B") \

  188.  METHOD (size,        "size",        "()I")

  189. 

  190. DECLARE_JNI_CLASS_WITH_MIN_SDK (ByteArrayOutputStream, "java/io/ByteArrayOutputStream", 21)

  191. #undef JNI_CLASS_MEMBERS

  192. 

  193. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  194.  METHOD (abortCaptures,       "abortCaptures",       "()V") \

  195.  METHOD (capture,             "capture",             "(Landroid/hardware/camera2/CaptureRequest;Landroid/hardware/camera2/CameraCaptureSession$CaptureCallback;Landroid/os/Handler;)I") \

  196.  METHOD (close,               "close",               "()V") \

  197.  METHOD (setRepeatingRequest, "setRepeatingRequest", "(Landroid/hardware/camera2/CaptureRequest;Landroid/hardware/camera2/CameraCaptureSession$CaptureCallback;Landroid/os/Handler;)I") \

  198.  METHOD (stopRepeating,       "stopRepeating",       "()V")

  199. 

  200. DECLARE_JNI_CLASS_WITH_MIN_SDK (CameraCaptureSession, "android/hardware/camera2/CameraCaptureSession", 21)

  201. #undef JNI_CLASS_MEMBERS

  202. 

  203. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  204.  METHOD (get,     "get",     "(Landroid/hardware/camera2/CameraCharacteristics$Key;)Ljava/lang/Object;") \

  205.  METHOD (getKeys, "getKeys", "()Ljava/util/List;") \

  206.  STATICFIELD (CONTROL_AF_AVAILABLE_MODES,      "CONTROL_AF_AVAILABLE_MODES",      "Landroid/hardware/camera2/CameraCharacteristics$Key;") \

  207.  STATICFIELD (LENS_FACING,                     "LENS_FACING",                     "Landroid/hardware/camera2/CameraCharacteristics$Key;") \

  208.  STATICFIELD (SCALER_STREAM_CONFIGURATION_MAP, "SCALER_STREAM_CONFIGURATION_MAP", "Landroid/hardware/camera2/CameraCharacteristics$Key;") \

  209.  STATICFIELD (SENSOR_ORIENTATION,              "SENSOR_ORIENTATION",              "Landroid/hardware/camera2/CameraCharacteristics$Key;")

  210. 

  211. DECLARE_JNI_CLASS_WITH_MIN_SDK (CameraCharacteristics, "android/hardware/camera2/CameraCharacteristics", 21)

  212. #undef JNI_CLASS_MEMBERS

  213. 

  214. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  215.  METHOD (getName, "getName", "()Ljava/lang/String;")

  216. 

  217. DECLARE_JNI_CLASS_WITH_MIN_SDK (CameraCharacteristicsKey, "android/hardware/camera2/CameraCharacteristics$Key", 21)

  218. #undef JNI_CLASS_MEMBERS

  219. 

  220. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  221.  METHOD (getCameraCharacteristics, "getCameraCharacteristics", "(Ljava/lang/String;)Landroid/hardware/camera2/CameraCharacteristics;") \

  222.  METHOD (getCameraIdList,          "getCameraIdList",          "()[Ljava/lang/String;") \

  223.  METHOD (openCamera,               "openCamera",               "(Ljava/lang/String;Landroid/hardware/camera2/CameraDevice$StateCallback;Landroid/os/Handler;)V")

  224. 

  225. DECLARE_JNI_CLASS_WITH_MIN_SDK (CameraManager, "android/hardware/camera2/CameraManager", 21)

  226. #undef JNI_CLASS_MEMBERS

  227. 

  228. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  229.  STATICFIELD (CONTROL_AE_PRECAPTURE_TRIGGER, "CONTROL_AE_PRECAPTURE_TRIGGER", "Landroid/hardware/camera2/CaptureRequest$Key;") \

  230.  STATICFIELD (CONTROL_AF_MODE,               "CONTROL_AF_MODE",               "Landroid/hardware/camera2/CaptureRequest$Key;") \

  231.  STATICFIELD (CONTROL_AF_TRIGGER,            "CONTROL_AF_TRIGGER",            "Landroid/hardware/camera2/CaptureRequest$Key;") \

  232.  STATICFIELD (CONTROL_MODE,                  "CONTROL_MODE",                  "Landroid/hardware/camera2/CaptureRequest$Key;")

  233. 

  234. DECLARE_JNI_CLASS_WITH_MIN_SDK (CaptureRequest, "android/hardware/camera2/CaptureRequest", 21)

  235. #undef JNI_CLASS_MEMBERS

  236. 

  237. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  238.  METHOD (addTarget, "addTarget", "(Landroid/view/Surface;)V") \

  239.  METHOD (build,     "build",     "()Landroid/hardware/camera2/CaptureRequest;") \

  240.  METHOD (set,       "set",       "(Landroid/hardware/camera2/CaptureRequest$Key;Ljava/lang/Object;)V")

  241. 

  242. DECLARE_JNI_CLASS_WITH_MIN_SDK (CaptureRequestBuilder, "android/hardware/camera2/CaptureRequest$Builder", 21)

  243. #undef JNI_CLASS_MEMBERS

  244. 

  245. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  246.  METHOD (get, "get", "(Landroid/hardware/camera2/CaptureResult$Key;)Ljava/lang/Object;") \

  247.  STATICFIELD (CONTROL_AE_STATE, "CONTROL_AE_STATE", "Landroid/hardware/camera2/CaptureResult$Key;") \

  248.  STATICFIELD (CONTROL_AF_STATE, "CONTROL_AF_STATE", "Landroid/hardware/camera2/CaptureResult$Key;")

  249. 

  250. DECLARE_JNI_CLASS_WITH_MIN_SDK (CaptureResult, "android/hardware/camera2/CaptureResult", 21)

  251. #undef JNI_CLASS_MEMBERS

  252. 

  253. //==============================================================================

  254. class AndroidRunnable  : public juce::AndroidInterfaceImplementer

  255. {

  256. public:

  257.     struct Owner

  258.     {

  259.         virtual ~Owner() {}

  260. 

  261.         virtual void run() = 0;

  262.     };

  263. 

  264.     AndroidRunnable (Owner& ownerToUse)

  265.         : owner (ownerToUse)

  266.     {}

  267. 

  268. private:

  269.     Owner& owner;

  270. 

  271.     jobject invoke (jobject proxy, jobject method, jobjectArray args) override

  272.     {

  273.         auto* env = getEnv();

  274.         auto methodName = juce::juceString ((jstring) env->CallObjectMethod (method, JavaMethod.getName));

  275. 

  276.         if (methodName == "run")

  277.         {

  278.             owner.run();

  279.             return nullptr;

  280.         }

  281. 

  282.         // invoke base class

  283.         return AndroidInterfaceImplementer::invoke (proxy, method, args);

  284.     }

  285. };

  286. 

  287. //==============================================================================

  288. class TextureViewSurfaceTextureListener     : public AndroidInterfaceImplementer

  289. {

  290. public:

  291.     struct Owner

  292.     {

  293.         virtual ~Owner() {}

  294. 

  295.         virtual void onSurfaceTextureAvailable (LocalRef<jobject>& surface, int width, int height) = 0;

  296.         virtual bool onSurfaceTextureDestroyed (LocalRef<jobject>& surface) = 0;

  297.         virtual void onSurfaceTextureSizeChanged (LocalRef<jobject>& surface, int width, int height) = 0;

  298.         virtual void onSurfaceTextureUpdated (LocalRef<jobject>& surface) = 0;

  299.     };

  300. 

  301.     TextureViewSurfaceTextureListener (Owner& ownerToUse)

  302.         : owner (ownerToUse)

  303.     {}

  304. 

  305.     jobject invoke (jobject proxy, jobject method, jobjectArray args) override

  306.     {

  307.         auto* env = getEnv();

  308. 

  309.         auto methodName = juceString ((jstring) env->CallObjectMethod (method, JavaMethod.getName));

  310. 

  311.         int numArgs = args != nullptr ? env->GetArrayLength (args) : 0;

  312. 

  313.         if (methodName == "onSurfaceTextureAvailable" && numArgs == 3)

  314.         {

  315.             auto surface = LocalRef<jobject> (env->GetObjectArrayElement (args, 0));

  316.             auto width   = LocalRef<jobject> (env->GetObjectArrayElement (args, 1));

  317.             auto height  = LocalRef<jobject> (env->GetObjectArrayElement (args, 2));

  318. 

  319.             auto widthInt  = env->CallIntMethod (width, JavaInteger.intValue);

  320.             auto heightInt = env->CallIntMethod (height, JavaInteger.intValue);

  321. 

  322.             owner.onSurfaceTextureAvailable (surface, widthInt, heightInt);

  323.             return nullptr;

  324.         }

  325.         else if (methodName == "onSurfaceTextureDestroyed" && numArgs == 1)

  326.         {

  327.             auto surface = LocalRef<jobject> (env->GetObjectArrayElement (args, 0));

  328.             auto result = owner.onSurfaceTextureDestroyed (surface);

  329. 

  330.             return env->CallStaticObjectMethod (JavaBoolean, JavaBoolean.valueOf, result);

  331.         }

  332.         else if (methodName == "onSurfaceTextureSizeChanged" && numArgs == 3)

  333.         {

  334.             auto surface = LocalRef<jobject> (env->GetObjectArrayElement (args, 0));

  335.             auto width   = LocalRef<jobject> (env->GetObjectArrayElement (args, 1));

  336.             auto height  = LocalRef<jobject> (env->GetObjectArrayElement (args, 2));

  337. 

  338.             auto widthInt  = env->CallIntMethod (width, JavaInteger.intValue);

  339.             auto heightInt = env->CallIntMethod (height, JavaInteger.intValue);

  340. 

  341.             owner.onSurfaceTextureSizeChanged (surface, widthInt, heightInt);

  342.             return nullptr;

  343.         }

  344.         else if (methodName == "onSurfaceTextureUpdated" && numArgs == 1)

  345.         {

  346.             auto surface = LocalRef<jobject> (env->GetObjectArrayElement (args, 0));

  347. 

  348.             owner.onSurfaceTextureUpdated (surface);

  349.             return nullptr;

  350.         }

  351. 

  352.         return AndroidInterfaceImplementer::invoke (proxy, method, args);

  353.     }

  354. 

  355. private:

  356.     Owner& owner;

  357. };

  358. 

  359. //==============================================================================

  360. class ImageReaderOnImageAvailableListener     : public AndroidInterfaceImplementer

  361. {

  362. public:

  363.     struct Owner

  364.     {

  365.         virtual ~Owner() {}

  366. 

  367.         virtual void onImageAvailable (LocalRef<jobject>& imageReader) = 0;

  368.     };

  369. 

  370.     ImageReaderOnImageAvailableListener (Owner& ownerToUse)

  371.         : owner (ownerToUse)

  372.     {}

  373. 

  374.     jobject invoke (jobject proxy, jobject method, jobjectArray args) override

  375.     {

  376.         auto* env = getEnv();

  377. 

  378.         auto methodName = juceString ((jstring) env->CallObjectMethod (method, JavaMethod.getName));

  379. 

  380.         int numArgs = args != nullptr ? env->GetArrayLength (args) : 0;

  381. 

  382.         if (methodName == "onImageAvailable" && numArgs == 1)

  383.         {

  384.             auto imageReader = LocalRef<jobject> (env->GetObjectArrayElement (args, 0));

  385. 

  386.             owner.onImageAvailable (imageReader);

  387.             return nullptr;

  388.         }

  389. 

  390.         return AndroidInterfaceImplementer::invoke (proxy, method, args);

  391.     }

  392. 

  393. private:

  394.     Owner& owner;

  395. };

  396. 

  397. //==============================================================================

  398. class MediaRecorderOnInfoListener     : public AndroidInterfaceImplementer

  399. {

  400. public:

  401.     struct Owner

  402.     {

  403.         virtual ~Owner() {}

  404. 

  405.         virtual void onInfo (LocalRef<jobject>& mediaRecorder, int what, int extra) = 0;

  406.     };

  407. 

  408.     MediaRecorderOnInfoListener (Owner& ownerToUse)

  409.         : owner (ownerToUse)

  410.     {}

  411. 

  412.     jobject invoke (jobject proxy, jobject method, jobjectArray args) override

  413.     {

  414.         auto* env = getEnv();

  415. 

  416.         auto methodName = juceString ((jstring) env->CallObjectMethod (method, JavaMethod.getName));

  417. 

  418.         int numArgs = args != nullptr ? env->GetArrayLength (args) : 0;

  419. 

  420.         if (methodName == "onInfo" && numArgs == 3)

  421.         {

  422.             auto mediaRecorder = LocalRef<jobject> (env->GetObjectArrayElement (args, 0));

  423.             auto what   = LocalRef<jobject> (env->GetObjectArrayElement (args, 1));

  424.             auto extra  = LocalRef<jobject> (env->GetObjectArrayElement (args, 2));

  425. 

  426.             auto whatInt  = (int) env->CallIntMethod (what, JavaInteger.intValue);

  427.             auto extraInt = (int) env->CallIntMethod (extra, JavaInteger.intValue);

  428. 

  429.             owner.onInfo (mediaRecorder, whatInt, extraInt);

  430.             return nullptr;

  431.         }

  432. 

  433.         return AndroidInterfaceImplementer::invoke (proxy, method, args);

  434.     }

  435. 

  436. private:

  437.     Owner& owner;

  438. };

  439. 

  440. //==============================================================================

  441. class MediaRecorderOnErrorListener     : public AndroidInterfaceImplementer

  442. {

  443. public:

  444.     struct Owner

  445.     {

  446.         virtual ~Owner() {}

  447. 

  448.         virtual void onError (LocalRef<jobject>& mediaRecorder, int what, int extra) = 0;

  449.     };

  450. 

  451.     MediaRecorderOnErrorListener (Owner& ownerToUse)

  452.         : owner (ownerToUse)

  453.     {}

  454. 

  455.     jobject invoke (jobject proxy, jobject method, jobjectArray args) override

  456.     {

  457.         auto* env = getEnv();

  458. 

  459.         auto methodName = juceString ((jstring) env->CallObjectMethod (method, JavaMethod.getName));

  460. 

  461.         int numArgs = args != nullptr ? env->GetArrayLength (args) : 0;

  462. 

  463.         if (methodName == "onError" && numArgs == 3)

  464.         {

  465.             auto mediaRecorder = LocalRef<jobject> (env->GetObjectArrayElement (args, 0));

  466.             auto what   = LocalRef<jobject> (env->GetObjectArrayElement (args, 1));

  467.             auto extra  = LocalRef<jobject> (env->GetObjectArrayElement (args, 2));

  468. 

  469.             auto whatInt  = (int) env->CallIntMethod (what, JavaInteger.intValue);

  470.             auto extraInt = (int) env->CallIntMethod (extra, JavaInteger.intValue);

  471. 

  472.             owner.onError (mediaRecorder, whatInt, extraInt);

  473.             return nullptr;

  474.         }

  475. 

  476.         return AndroidInterfaceImplementer::invoke (proxy, method, args);

  477.     }

  478. 

  479. private:

  480.     Owner& owner;

  481. };

  482. 

  483. //==============================================================================

  484. struct CameraDevice::Pimpl

  485.     : private ActivityLifecycleCallbacks

  486. {

  487.     using InternalOpenCameraResultCallback = std::function<void (const String& /*cameraId*/, const String& /*error*/)>;

  488. 

  489.     Pimpl (CameraDevice& ownerToUse, const String& cameraIdToUse, int /*index*/,

  490.            int minWidthToUse, int minHeightToUse, int maxWidthToUse, int maxHeightToUse,

  491.            bool /*useHighQuality*/)

  492.         : owner (ownerToUse),

  493.           minWidth (minWidthToUse),

  494.           minHeight (minHeightToUse),

  495.           maxWidth (maxWidthToUse),

  496.           maxHeight (maxHeightToUse),

  497.           cameraId (cameraIdToUse),

  498.           activityLifeListener (CreateJavaInterface (this, "android/app/Application$ActivityLifecycleCallbacks")),

  499.           cameraManager (initialiseCameraManager()),

  500.           cameraCharacteristics (initialiseCameraCharacteristics (cameraManager, cameraId)),

  501.           streamConfigurationMap (cameraCharacteristics),

  502.           previewDisplay (streamConfigurationMap.getPreviewBufferSize()),

  503.           deviceOrientationChangeListener (previewDisplay)

  504.     {

  505.         startBackgroundThread();

  506.     }

  507. 

  508.     ~Pimpl() override

  509.     {

  510.         auto* env = getEnv();

  511. 

  512.         env->CallVoidMethod (getAppContext().get(), AndroidApplication.unregisterActivityLifecycleCallbacks, activityLifeListener.get());

  513.         activityLifeListener.clear();

  514.     }

  515. 

  516.     JUCE_DECLARE_WEAK_REFERENCEABLE (Pimpl)

  517. 

  518.     String getCameraId() const noexcept { return cameraId; }

  519. 

  520.     void open (InternalOpenCameraResultCallback cameraOpenCallbackToUse)

  521.     {

  522.         cameraOpenCallback = std::move (cameraOpenCallbackToUse);

  523. 

  524.         // A valid camera open callback must be passed.

  525.         jassert (cameraOpenCallback != nullptr);

  526. 

  527.         // The same camera can be opened only once!

  528.         jassert (scopedCameraDevice == nullptr);

  529. 

  530.         if (cameraOpenCallback == nullptr || scopedCameraDevice != nullptr)

  531.             return;

  532. 

  533.         WeakReference<Pimpl> safeThis (this);

  534.         RuntimePermissions::request (RuntimePermissions::camera, [safeThis] (bool granted) mutable

  535.                                      {

  536.                                          if (safeThis != nullptr)

  537.                                              safeThis->continueOpenRequest (granted);

  538.                                      });

  539.     }

  540. 

  541.     void continueOpenRequest (bool granted)

  542.     {

  543.         if (getAndroidSDKVersion() >= 21)

  544.         {

  545.             if (granted)

  546.             {

  547.                 getEnv()->CallVoidMethod (getAppContext().get(), AndroidApplication.registerActivityLifecycleCallbacks, activityLifeListener.get());

  548.                 scopedCameraDevice.reset (new ScopedCameraDevice (*this, cameraId, cameraManager, handler, getAutoFocusModeToUse()));

  549.             }

  550.             else

  551.             {

  552.                 invokeCameraOpenCallback ("Camera permission not granted");

  553.             }

  554.         }

  555.         else

  556.         {

  557.             invokeCameraOpenCallback ("Camera requires android sdk version 21 or greater");

  558.         }

  559.     }

  560. 

  561.     bool openedOk() const noexcept { return scopedCameraDevice->openedOk(); }

  562. 

  563.     void takeStillPicture (std::function<void (const Image&)> pictureTakenCallbackToUse)

  564.     {

  565.         if (pictureTakenCallbackToUse == nullptr || currentCaptureSessionMode == nullptr)

  566.         {

  567.             jassertfalse;

  568.             return;

  569.         }

  570. 

  571.         if (currentCaptureSessionMode->isVideoRecordSession())

  572.         {

  573.             // Taking still pictures while recording video is not supported on Android.

  574.             jassertfalse;

  575.             return;

  576.         }

  577. 

  578.         pictureTakenCallback = std::move (pictureTakenCallbackToUse);

  579. 

  580.         triggerStillPictureCapture();

  581.     }

  582. 

  583.     void startRecordingToFile (const File& file, int /*quality*/)

  584.     {

  585.         if (! openedOk())

  586.         {

  587.             jassertfalse;

  588.             return;

  589.         }

  590. 

  591.         if (! previewDisplay.isReady())

  592.         {

  593.             // Did you remember to create and show a preview display?

  594.             jassertfalse;

  595.             return;

  596.         }

  597. 

  598.         file.deleteFile();

  599.         file.create();

  600.         jassert (file.existsAsFile());

  601. 

  602.         // MediaRecorder can't handle videos larger than 1080p

  603.         auto videoSize = chooseBestSize (minWidth, minHeight, jmin (maxWidth, 1080), maxHeight,

  604.                                          streamConfigurationMap.getSupportedVideoRecordingOutputSizes());

  605. 

  606.         mediaRecorder.reset (new MediaRecorder (file.getFullPathName(), videoSize.getWidth(), videoSize.getHeight(),

  607.                                                 getCameraSensorOrientation(), getCameraLensFacing()));

  608. 

  609.         firstRecordedFrameTimeMs = Time::getCurrentTime();

  610. 

  611.         currentCaptureSessionMode.reset();

  612.         startVideoRecordingMode (*mediaRecorder);

  613.     }

  614. 

  615.     void stopRecording()

  616.     {

  617.         currentCaptureSessionMode.reset();

  618.         mediaRecorder.reset();

  619. 

  620.         startPreviewMode (*imageReader);

  621.     }

  622. 

  623.     Time getTimeOfFirstRecordedFrame() const

  624.     {

  625.         return firstRecordedFrameTimeMs;

  626.     }

  627. 

  628.     static StringArray getAvailableDevices()

  629.     {

  630.         if (getAndroidSDKVersion() < 21)

  631.             return StringArray(); // Camera requires SDK version 21 or later

  632. 

  633.         StringArray results;

  634. 

  635.         auto* env = getEnv();

  636. 

  637.         auto cameraManagerToUse = initialiseCameraManager();

  638.         auto cameraIdArray = LocalRef<jobjectArray> ((jobjectArray) env->CallObjectMethod (cameraManagerToUse,

  639.                                                                                            CameraManager.getCameraIdList));

  640. 

  641.         results = javaStringArrayToJuce (cameraIdArray);

  642. 

  643.         for (auto& result : results)

  644.             printDebugCameraInfo (cameraManagerToUse, result);

  645. 

  646.         return results;

  647.     }

  648. 

  649.     void addListener (CameraDevice::Listener* listenerToAdd)

  650.     {

  651.         const ScopedLock sl (listenerLock);

  652.         listeners.add (listenerToAdd);

  653. 

  654.         if (listeners.size() == 1)

  655.             triggerStillPictureCapture();

  656.     }

  657. 

  658.     void removeListener (CameraDevice::Listener* listenerToRemove)

  659.     {

  660.         const ScopedLock sl (listenerLock);

  661.         listeners.remove (listenerToRemove);

  662.     }

  663. 

  664. private:

  665.     enum

  666.     {

  667.         ERROR_CAMERA_IN_USE = 1,

  668.         ERROR_MAX_CAMERAS_IN_USE = 2,

  669.         ERROR_CAMERA_DISABLED = 3,

  670.         ERROR_CAMERA_DEVICE = 4,

  671.         ERROR_CAMERA_SERVICE = 5

  672.     };

  673. 

  674.     static String cameraErrorCodeToString (int errorCode)

  675.     {

  676.         switch (errorCode)

  677.         {

  678.             case ERROR_CAMERA_IN_USE:      return "Camera already in use.";

  679.             case ERROR_MAX_CAMERAS_IN_USE: return "Too many opened camera devices.";

  680.             case ERROR_CAMERA_DISABLED:    return "Camera disabled.";

  681.             case ERROR_CAMERA_DEVICE:      return "Fatal error.";

  682.             case ERROR_CAMERA_SERVICE:     return "Fatal error. Reboot required or persistent hardware problem.";

  683.             default:                       return "Unknown error.";

  684.         }

  685.     }

  686. 

  687.     static LocalRef<jobject> initialiseCameraManager()

  688.     {

  689.         return LocalRef<jobject> (getEnv()->CallObjectMethod (getAppContext().get(), AndroidContext.getSystemService,

  690.                                                               javaString ("camera").get()));

  691.     }

  692. 

  693.     static LocalRef<jobject> initialiseCameraCharacteristics (const GlobalRef& cameraManager, const String& cameraId)

  694.     {

  695.         return LocalRef<jobject> (getEnv()->CallObjectMethod (cameraManager,

  696.                                                               CameraManager.getCameraCharacteristics,

  697.                                                               javaString (cameraId).get()));

  698.     }

  699. 

  700.     static void printDebugCameraInfo (const LocalRef<jobject>& cameraManagerToUse, const String& cameraId)

  701.     {

  702.         auto* env = getEnv();

  703. 

  704.         auto characteristics = LocalRef<jobject> (env->CallObjectMethod (cameraManagerToUse,

  705.                                                                          CameraManager.getCameraCharacteristics,

  706.                                                                          javaString (cameraId).get()));

  707. 

  708.         auto keysList = LocalRef<jobject> (env->CallObjectMethod (characteristics, CameraCharacteristics.getKeys));

  709. 

  710.         const int size = env->CallIntMethod (keysList, JavaList.size);

  711. 

  712.         JUCE_CAMERA_LOG ("Camera id: " + cameraId + ", characteristics keys num: " + String (size));

  713. 

  714.         for (int i = 0; i < size; ++i)

  715.         {

  716.             auto key = LocalRef<jobject> (env->CallObjectMethod (keysList, JavaList.get, i));

  717.             auto jKeyName = LocalRef<jstring> ((jstring) env->CallObjectMethod (key, CameraCharacteristicsKey.getName));

  718.             auto keyName = juceString (jKeyName);

  719. 

  720.             auto keyValue = LocalRef<jobject> (env->CallObjectMethod (characteristics, CameraCharacteristics.get, key.get()));

  721.             auto jKeyValueString = LocalRef<jstring> ((jstring) env->CallObjectMethod (keyValue, JavaObject.toString));

  722.             auto keyValueString = juceString (jKeyValueString);

  723. 

  724.             auto &kvs = keyValueString;

  725. 

  726.             if (kvs.startsWith ("[I") || kvs.startsWith ("[F") || kvs.startsWith ("[Z") || kvs.startsWith ("[B"))

  727.             {

  728.                 printPrimitiveArrayElements (keyValue, keyName, keyValueString);

  729.             }

  730.             else if (kvs.startsWith ("[Landroid.util.Range"))

  731.             {

  732.                 printRangeArrayElements (keyValue, keyName);

  733.             }

  734.             else

  735.             {

  736.                 int chunkSize = 256;

  737. 

  738.                 if (keyValueString.length() > chunkSize)

  739.                 {

  740.                     JUCE_CAMERA_LOG ("Key: " + keyName);

  741. 

  742.                     for (int j = 0, k = 1; j < keyValueString.length(); j += chunkSize, ++k)

  743.                         JUCE_CAMERA_LOG ("value part " + String (k) + ": " + keyValueString.substring (j, k + chunkSize));

  744.                 }

  745.                 else

  746.                 {

  747.                     JUCE_CAMERA_LOG ("Key: " + keyName + ", value: " + keyValueString);

  748.                 }

  749.             }

  750. 

  751.             ignoreUnused (keyName);

  752.         }

  753.     }

  754. 

  755.     static void printPrimitiveArrayElements (const LocalRef<jobject>& keyValue, const String& keyName,

  756.                                              const String& keyValueString)

  757.     {

  758.         ignoreUnused (keyName);

  759. 

  760.         String result = "[";

  761. 

  762.         auto* env = getEnv();

  763. 

  764.         #define PRINT_ELEMENTS(elem_type, array_type, fun_name_middle)                                              \

  765.         {                                                                                                           \

  766.             elem_type* elements = env->Get##fun_name_middle##ArrayElements ((array_type) keyValue.get(), nullptr);  \

  767.             int size = env->GetArrayLength ((array_type) keyValue.get());                                           \

  768.                                                                                                                     \

  769.             for (int i = 0; i < size - 1; ++i)                                                                      \

  770.                 result << String (elements[i]) << " ";                                                              \

  771.                                                                                                                     \

  772.             if (size > 0)                                                                                           \

  773.                 result << String (elements[size - 1]);                                                              \

  774.                                                                                                                     \

  775.             env->Release##fun_name_middle##ArrayElements ((array_type) keyValue.get(), elements, 0);                \

  776.         }

  777. 

  778.         if (keyValueString.startsWith ("[I"))

  779.             PRINT_ELEMENTS (jint, jintArray, Int)

  780.         else if (keyValueString.startsWith ("[F"))

  781.             PRINT_ELEMENTS (float, jfloatArray, Float)

  782.         else if (keyValueString.startsWith ("[Z"))

  783.             PRINT_ELEMENTS (jboolean, jbooleanArray, Boolean)

  784.         else if (keyValueString.startsWith ("[B"))

  785.             PRINT_ELEMENTS (jbyte, jbyteArray, Byte);

  786. 

  787.         #undef PRINT_ELEMENTS

  788. 

  789.         result << "]";

  790.         JUCE_CAMERA_LOG ("Key: " + keyName + ", value: " + result);

  791.     }

  792. 

  793.     static void printRangeArrayElements (const LocalRef<jobject>& rangeArray, const String& keyName)

  794.     {

  795.         auto* env = getEnv();

  796. 

  797.         jobjectArray ranges = static_cast<jobjectArray> (rangeArray.get());

  798. 

  799.         int numRanges = env->GetArrayLength (ranges);

  800. 

  801.         String result;

  802. 

  803.         for (int i = 0; i < numRanges; ++i)

  804.         {

  805.             auto range = LocalRef<jobject> (env->GetObjectArrayElement (ranges, i));

  806. 

  807.             auto jRangeString = LocalRef<jstring> ((jstring) env->CallObjectMethod (range, AndroidRange.toString));

  808. 

  809.             result << juceString (jRangeString) << " ";

  810.         }

  811. 

  812.         ignoreUnused (keyName);

  813.         JUCE_CAMERA_LOG ("Key: " + keyName + ", value: " + result);

  814.     }

  815. 

  816.     //==============================================================================

  817.     class StreamConfigurationMap

  818.     {

  819.     public:

  820.         StreamConfigurationMap (const GlobalRef& cameraCharacteristicsToUse)

  821.             : scalerStreamConfigurationMap (getStreamConfigurationMap (cameraCharacteristicsToUse)),

  822.               supportedPreviewOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

  823.                                                                 getClassForName ("android.graphics.SurfaceTexture"),

  824.                                                                 -1)),

  825.               supportedStillImageOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

  826.                                                                    LocalRef<jobject>(),

  827.                                                                    jpegImageFormat)),

  828.               supportedVideoRecordingOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

  829.                                                                        getClassForName ("android.media.MediaRecorder"),

  830.                                                                        -1)),

  831.               defaultPreviewSize (getSmallestSize (supportedPreviewOutputSizes)),

  832.               previewBufferSize (getLargestSize (supportedPreviewOutputSizes))

  833.         {

  834.             printSizesLog (supportedPreviewOutputSizes, "SurfaceTexture");

  835.             printSizesLog (supportedStillImageOutputSizes, "JPEG");

  836.             printSizesLog (supportedVideoRecordingOutputSizes, "MediaRecorder");

  837.         }

  838. 

  839.         Array<Rectangle<int>> getSupportedPreviewOutputSizes()        const noexcept { return supportedPreviewOutputSizes; }

  840.         Array<Rectangle<int>> getSupportedStillImageOutputSizes()     const noexcept { return supportedStillImageOutputSizes; }

  841.         Array<Rectangle<int>> getSupportedVideoRecordingOutputSizes() const noexcept { return supportedVideoRecordingOutputSizes; }

  842. 

  843.         Rectangle<int> getDefaultPreviewSize() const noexcept { return defaultPreviewSize; }

  844.         Rectangle<int> getPreviewBufferSize()  const noexcept { return previewBufferSize; }

  845. 

  846.         bool isOutputSupportedForSurface (const LocalRef<jobject>& surface) const

  847.         {

  848.             return getEnv()->CallBooleanMethod (scalerStreamConfigurationMap, AndroidStreamConfigurationMap.isOutputSupportedForSurface, surface.get()) != 0;

  849.         }

  850. 

  851.         static constexpr int jpegImageFormat = 256;

  852. 

  853.     private:

  854.         GlobalRef scalerStreamConfigurationMap;

  855. 

  856.         Array<Rectangle<int>> supportedPreviewOutputSizes;

  857.         Array<Rectangle<int>> supportedStillImageOutputSizes;

  858.         Array<Rectangle<int>> supportedVideoRecordingOutputSizes;

  859.         Rectangle<int> defaultPreviewSize, previewBufferSize;

  860. 

  861.         GlobalRef getStreamConfigurationMap (const GlobalRef& cameraCharacteristicsToUse)

  862.         {

  863.             auto* env = getEnv();

  864. 

  865.             auto scalerStreamConfigurationMapKey = LocalRef<jobject> (env->GetStaticObjectField (CameraCharacteristics,

  866.                                                                                                  CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP));

  867. 

  868.             return GlobalRef (LocalRef<jobject> (env->CallObjectMethod (cameraCharacteristicsToUse,

  869.                                                                         CameraCharacteristics.get,

  870.                                                                         scalerStreamConfigurationMapKey.get())));

  871.         }

  872. 

  873.         static Array<Rectangle<int>> retrieveOutputSizes (GlobalRef& scalerStreamConfigurationMap,

  874.                                                           const LocalRef<jobject>& outputClass,

  875.                                                           int format)

  876.         {

  877.             Array<Rectangle<int>> result;

  878. 

  879.             auto* env = getEnv();

  880. 

  881.             auto outputSizes = outputClass.get() != nullptr

  882.                              ? LocalRef<jobjectArray> ((jobjectArray) env->CallObjectMethod (scalerStreamConfigurationMap,

  883.                                                                                              AndroidStreamConfigurationMap.getOutputSizesForClass,

  884.                                                                                              outputClass.get()))

  885.                              : LocalRef<jobjectArray> ((jobjectArray) env->CallObjectMethod (scalerStreamConfigurationMap,

  886.                                                                                              AndroidStreamConfigurationMap.getOutputSizesForFormat,

  887.                                                                                              (jint) format));

  888. 

  889.             if (format != -1)

  890.             {

  891.                 auto supported = (env->CallBooleanMethod (scalerStreamConfigurationMap, AndroidStreamConfigurationMap.isOutputSupportedFor, (jint) format) != 0);

  892. 

  893.                 if (! supported)

  894.                 {

  895.                     // The output format is not supported by this device, still image capture will not work!

  896.                     jassertfalse;

  897.                     return {};

  898.                 }

  899.             }

  900. 

  901.             int numSizes = env->GetArrayLength (outputSizes);

  902. 

  903.             jassert (numSizes > 0);

  904. 

  905.             for (int i = 0; i < numSizes; ++i)

  906.             {

  907.                 auto size = LocalRef<jobject> (env->GetObjectArrayElement (outputSizes, i));

  908. 

  909.                 auto width  = env->CallIntMethod (size, AndroidSize.getWidth);

  910.                 auto height = env->CallIntMethod (size, AndroidSize.getHeight);

  911. 

  912.                 result.add (Rectangle<int> (0, 0, width, height));

  913.             }

  914. 

  915.             return result;

  916.         }

  917. 

  918.         static LocalRef<jobject> getClassForName (const String& name)

  919.         {

  920.             return LocalRef<jobject> (getEnv()->CallStaticObjectMethod (JavaClass, JavaClass.forName,

  921.                                                                         javaString (name).get()));

  922.         }

  923. 

  924.         static void printSizesLog (const Array<Rectangle<int>>& sizes, const String& className)

  925.         {

  926.             ignoreUnused (sizes, className);

  927. 

  928.             JUCE_CAMERA_LOG ("Sizes for class " + className);

  929. 

  930.           #if JUCE_CAMERA_LOG_ENABLED

  931.             for (auto& s : sizes)

  932.                 JUCE_CAMERA_LOG (s.toString() + "\n");

  933.           #endif

  934.         }

  935. 

  936.         Rectangle<int> getSmallestSize (const Array<Rectangle<int>>& sizes) const

  937.         {

  938.             if (sizes.size() == 0)

  939.                 return {};

  940. 

  941.             auto smallestSize = sizes[0];

  942. 

  943.             for (auto& size : sizes)

  944.             {

  945.                 if (size.getWidth() < smallestSize.getWidth() && size.getHeight() < smallestSize.getHeight())

  946.                     smallestSize = size;

  947.             }

  948. 

  949.             return smallestSize;

  950.         }

  951. 

  952.         Rectangle<int> getLargestSize (const Array<Rectangle<int>>& sizes) const

  953.         {

  954.             if (sizes.size() == 0)

  955.                 return {};

  956. 

  957.             auto largestSize = sizes[0];

  958. 

  959.             for (auto& size : sizes)

  960.             {

  961.                 if (size.getWidth() > largestSize.getWidth() && size.getHeight() > largestSize.getHeight())

  962.                     largestSize = size;

  963.             }

  964. 

  965.             return largestSize;

  966.         }

  967.     };

  968. 

  969.     //==============================================================================

  970.     class PreviewDisplay    : private TextureViewSurfaceTextureListener::Owner

  971.     {

  972.     public:

  973.         struct Listener

  974.         {

  975.             virtual ~Listener() {}

  976. 

  977.             virtual void previewDisplayReady() = 0;

  978.             virtual void previewDisplayAboutToBeDestroyed() = 0;

  979.         };

  980. 

  981.         PreviewDisplay (Rectangle<int> bufferSize)

  982.             : textureViewSurfaceTextureListener (*this),

  983.               textureView (LocalRef<jobject> (getEnv()->NewObject (AndroidTextureView, AndroidTextureView.constructor,

  984.                                                                    getAppContext().get()))),

  985.               bufferWidth (bufferSize.getWidth()),

  986.               bufferHeight (bufferSize.getHeight())

  987.         {

  988.             auto* env = getEnv();

  989. 

  990.             if (! isReady())

  991.                 env->CallVoidMethod (textureView, AndroidTextureView.setSurfaceTextureListener,

  992.                                      CreateJavaInterface (&textureViewSurfaceTextureListener,

  993.                                                           "android/view/TextureView$SurfaceTextureListener").get());

  994.         }

  995. 

  996.         ~PreviewDisplay() override

  997.         {

  998.             getEnv()->CallVoidMethod (textureView, AndroidTextureView.setSurfaceTextureListener, nullptr);

  999.         }

  1000. 

  1001.         void addListener (Listener* l)

  1002.         {

  1003.             if (l == nullptr)

  1004.             {

  1005.                 jassertfalse;

  1006.                 return;

  1007.             }

  1008. 

  1009.             listeners.add (l);

  1010. 

  1011.             if (isReady())

  1012.                 l->previewDisplayReady();

  1013.         }

  1014. 

  1015.         void removeListener (Listener* l)

  1016.         {

  1017.             if (l == nullptr)

  1018.             {

  1019.                 jassertfalse;

  1020.                 return;

  1021.             }

  1022. 

  1023.             listeners.remove (l);

  1024.         }

  1025. 

  1026.         bool isReady() const

  1027.         {

  1028.             return (getEnv()->CallBooleanMethod (textureView, AndroidTextureView.isAvailable) != 0)

  1029.                     && width > 0 && height > 0;

  1030.         }

  1031. 

  1032.         LocalRef<jobject> createSurface()

  1033.         {

  1034.             // Surface may get destroyed while session is being configured, if

  1035.             // the preview gets hidden in the meantime, so bailout.

  1036.             if (! isReady())

  1037.                 return LocalRef<jobject> (nullptr);

  1038. 

  1039.             auto* env = getEnv();

  1040. 

  1041.             auto surfaceTexture = LocalRef<jobject> (env->CallObjectMethod (textureView,

  1042.                                                                             AndroidTextureView.getSurfaceTexture));

  1043. 

  1044.             // NB: too small buffer will result in pixelated preview. A buffer with wrong aspect ratio

  1045.             //     can result in a cropped preview.

  1046.             env->CallVoidMethod (surfaceTexture, AndroidSurfaceTexture.setDefaultBufferSize, (jint) bufferWidth, (jint) bufferHeight);

  1047. 

  1048.             auto surface = LocalRef<jobject> (env->NewObject (AndroidSurface, AndroidSurface.constructor, surfaceTexture.get()));

  1049. 

  1050.             return surface;

  1051.         }

  1052. 

  1053.         const GlobalRef& getNativeView() { return textureView; }

  1054. 

  1055.         void updateSurfaceTransform()

  1056.         {

  1057.             auto* env = getEnv();

  1058. 

  1059.             auto windowManager = LocalRef<jobject> (env->CallObjectMethod (getAppContext(), AndroidContext.getSystemService, javaString ("window").get()));

  1060.             auto display = LocalRef<jobject> (env->CallObjectMethod (windowManager, AndroidWindowManager.getDefaultDisplay));

  1061.             auto rotation = env->CallIntMethod (display, AndroidDisplay.getRotation);

  1062. 

  1063.             static constexpr int rotation90 = 1;

  1064.             static constexpr int rotation270 = 3;

  1065. 

  1066.             auto matrix = LocalRef<jobject> (env->NewObject (AndroidMatrix, AndroidMatrix.constructor));

  1067. 

  1068.             if (rotation == rotation90 || rotation == rotation270)

  1069.             {

  1070.                 env->CallBooleanMethod (matrix, AndroidMatrix.postScale, jfloat (height / (float) width), jfloat (width / (float) height), (jfloat) 0, (jfloat) 0);

  1071.                 env->CallBooleanMethod (matrix, AndroidMatrix.postRotate, (jfloat) 90 * (rotation - 2), (jfloat) 0, (jfloat) 0);

  1072.                 env->CallBooleanMethod (matrix, AndroidMatrix.postTranslate, (jfloat) (rotation == 3 ? width : 0), (jfloat) (rotation == 1 ? height : 0));

  1073.             }

  1074. 

  1075.             env->CallVoidMethod (textureView, AndroidTextureView.setTransform, matrix.get());

  1076.         }

  1077. 

  1078.     private:

  1079.         ListenerList<Listener> listeners;

  1080. 

  1081.         TextureViewSurfaceTextureListener textureViewSurfaceTextureListener;

  1082.         GlobalRef textureView;

  1083.         int width = -1, height = -1;

  1084.         int bufferWidth, bufferHeight;

  1085. 

  1086.         void onSurfaceTextureAvailable (LocalRef<jobject>& /*surface*/, int widthToUse, int heightToUse) override

  1087.         {

  1088.             JUCE_CAMERA_LOG ("onSurfaceTextureAvailable()");

  1089. 

  1090.             width = widthToUse;

  1091.             height = heightToUse;

  1092. 

  1093.             updateSurfaceTransform();

  1094. 

  1095.             listeners.call (&Listener::previewDisplayReady);

  1096.         }

  1097. 

  1098.         bool onSurfaceTextureDestroyed (LocalRef<jobject>& /*surface*/) override

  1099.         {

  1100.             JUCE_CAMERA_LOG ("onSurfaceTextureDestroyed()");

  1101. 

  1102.             listeners.call (&Listener::previewDisplayAboutToBeDestroyed);

  1103. 

  1104.             return true;

  1105.         }

  1106. 

  1107.         void onSurfaceTextureSizeChanged (LocalRef<jobject>& /*surface*/, int widthToUse, int heightToUse) override

  1108.         {

  1109.             JUCE_CAMERA_LOG ("onSurfaceTextureSizeChanged()");

  1110. 

  1111.             width = widthToUse;

  1112.             height = heightToUse;

  1113. 

  1114.             updateSurfaceTransform();

  1115.         }

  1116. 

  1117.         void onSurfaceTextureUpdated (LocalRef<jobject>& /*surface*/) override

  1118.         {

  1119.             JUCE_CAMERA_LOG ("onSurfaceTextureUpdated()");

  1120.         }

  1121. 

  1122.         JUCE_DECLARE_NON_COPYABLE (PreviewDisplay)

  1123.     };

  1124. 

  1125.     //==============================================================================

  1126.     class ImageReader   : private ImageReaderOnImageAvailableListener::Owner

  1127.     {

  1128.     public:

  1129.         ImageReader (Pimpl& ownerToUse, GlobalRef& handlerToUse,

  1130.                      int imageWidth, int imageHeight, int cameraSensorOrientationToUse)

  1131.             : owner (ownerToUse),

  1132.               cameraSensorOrientation (cameraSensorOrientationToUse),

  1133.               imageReader (LocalRef<jobject> (getEnv()->CallStaticObjectMethod (AndroidImageReader, AndroidImageReader.newInstance,

  1134.                                                                                 imageWidth, imageHeight, StreamConfigurationMap::jpegImageFormat,

  1135.                                                                                 numImagesToKeep))),

  1136.               onImageAvailableListener (*this)

  1137.         {

  1138.             getEnv()->CallVoidMethod (imageReader, AndroidImageReader.setOnImageAvailableListener,

  1139.                                       CreateJavaInterface (&onImageAvailableListener,

  1140.                                                            "android/media/ImageReader$OnImageAvailableListener").get(),

  1141.                                       handlerToUse.get());

  1142.         }

  1143. 

  1144.         ~ImageReader() override

  1145.         {

  1146.             getEnv()->CallVoidMethod (imageReader, AndroidImageReader.close);

  1147.         }

  1148. 

  1149.         LocalRef<jobject> getSurface() const

  1150.         {

  1151.             return LocalRef<jobject> (getEnv()->CallObjectMethod (imageReader, AndroidImageReader.getSurface));

  1152.         }

  1153. 

  1154.         void resetNotificationFlag()

  1155.         {

  1156.             hasNotifiedListeners.set (0);

  1157.         }

  1158. 

  1159.     private:

  1160.         Pimpl& owner;

  1161.         int cameraSensorOrientation;

  1162. 

  1163.         GlobalRef imageReader;

  1164.         ImageReaderOnImageAvailableListener onImageAvailableListener;

  1165.         static constexpr int numImagesToKeep = 2;

  1166.         Atomic<int> hasNotifiedListeners { 0 };

  1167. 

  1168.         JUCE_DECLARE_WEAK_REFERENCEABLE (ImageReader)

  1169. 

  1170.         void onImageAvailable (LocalRef<jobject>& /*imageReader*/) override

  1171.         {

  1172.             JUCE_CAMERA_LOG ("onImageAvailable()");

  1173. 

  1174.             auto* env = getEnv();

  1175. 

  1176.             auto jImage = LocalRef<jobject> (env->CallObjectMethod (imageReader, AndroidImageReader.acquireLatestImage));

  1177. 

  1178.             if (jImage.get() == nullptr)

  1179.                 return;

  1180. 

  1181.             auto cameraLensFrontFacing = owner.getCameraLensFacing() == 0;

  1182. 

  1183.             // NB: could use sensor orientation here to get real-world orientation, but then the resulting

  1184.             //     image could not match the UI orientation.

  1185.             auto image = androidImageToJuceWithFixedOrientation (jImage, owner.deviceOrientationChangeListener.getDeviceOrientation(),

  1186.                                                                  Desktop::getInstance().getCurrentOrientation(),

  1187.                                                                  cameraLensFrontFacing,

  1188.                                                                  cameraSensorOrientation);

  1189. 

  1190.             env->CallVoidMethod (jImage, AndroidImage.close);

  1191. 

  1192.             WeakReference<ImageReader> safeThis (this);

  1193. 

  1194.             owner.callListeners (image);

  1195. 

  1196.             // Android may take multiple pictures before it handles a request to stop.

  1197.             if (hasNotifiedListeners.compareAndSetBool (1, 0))

  1198.                 MessageManager::callAsync ([safeThis, image]() mutable { if (safeThis != nullptr) safeThis->owner.notifyPictureTaken (image); });

  1199.         }

  1200. 

  1201.         struct ImageBuffer

  1202.         {

  1203.             LocalRef<jbyteArray> byteArray;

  1204.             int size;

  1205.         };

  1206. 

  1207.         static Image androidImageToJuceWithFixedOrientation (const LocalRef<jobject>& androidImage,

  1208.                                                              Desktop::DisplayOrientation deviceOrientationFromAccelerometerSensor,

  1209.                                                              Desktop::DisplayOrientation targetOrientation,

  1210.                                                              bool cameraLensFrontFacing,

  1211.                                                              int cameraSensorOrientation)

  1212.         {

  1213.             auto* env = getEnv();

  1214. 

  1215.             auto planes = LocalRef<jobjectArray> ((jobjectArray) env->CallObjectMethod (androidImage, AndroidImage.getPlanes));

  1216.             jassert (env->GetArrayLength (planes) > 0);

  1217. 

  1218.             auto plane = LocalRef<jobject> (env->GetObjectArrayElement (planes, 0));

  1219.             auto byteBuffer = LocalRef<jobject> (env->CallObjectMethod (plane, AndroidImagePlane.getBuffer));

  1220. 

  1221.             ImageBuffer correctedBuffer = getImageBufferWithCorrectedOrientationFrom (byteBuffer, deviceOrientationFromAccelerometerSensor,

  1222.                                                                                       targetOrientation, cameraLensFrontFacing, cameraSensorOrientation);

  1223. 

  1224.             jbyte* rawBytes = env->GetByteArrayElements (correctedBuffer.byteArray, nullptr);

  1225. 

  1226.             Image result = ImageFileFormat::loadFrom (rawBytes, (size_t) correctedBuffer.size);

  1227. 

  1228.             env->ReleaseByteArrayElements (correctedBuffer.byteArray, rawBytes, 0);

  1229. 

  1230.             return result;

  1231.         }

  1232. 

  1233.         static ImageBuffer getImageBufferWithCorrectedOrientationFrom (const LocalRef<jobject>& imagePlaneBuffer,

  1234.                                                                        Desktop::DisplayOrientation deviceOrientationFromAccelerometerSensor,

  1235.                                                                        Desktop::DisplayOrientation targetOrientation,

  1236.                                                                        bool cameraLensFrontFacing,

  1237.                                                                        int cameraSensorOrientation)

  1238.         {

  1239.             auto* env = getEnv();

  1240. 

  1241.             auto bufferSize = env->CallIntMethod (imagePlaneBuffer, JavaByteBuffer.remaining);

  1242.             auto byteArray = LocalRef<jbyteArray> (env->NewByteArray (bufferSize));

  1243.             env->CallObjectMethod (imagePlaneBuffer, JavaByteBuffer.get, byteArray.get());

  1244. 

  1245.             auto rotationAngle = getRotationAngle (deviceOrientationFromAccelerometerSensor, targetOrientation,

  1246.                                                   cameraLensFrontFacing, cameraSensorOrientation);

  1247. 

  1248.             if (rotationAngle == 0)

  1249.             {

  1250.                 // Nothing to do, just get the bytes

  1251.                 return { byteArray, bufferSize };

  1252.             }

  1253. 

  1254.             auto origBitmap = LocalRef<jobject> (env->CallStaticObjectMethod (AndroidBitmapFactory,

  1255.                                                                               AndroidBitmapFactory.decodeByteArray,

  1256.                                                                               byteArray.get(), (jint) 0, (jint) bufferSize));

  1257. 

  1258.             if (origBitmap == nullptr)

  1259.             {

  1260.                 // Nothing to do, just get the bytes

  1261.                 return { byteArray, bufferSize };

  1262.             }

  1263. 

  1264.             auto correctedBitmap = getBitmapWithCorrectOrientationFrom (origBitmap, rotationAngle);

  1265. 

  1266.             auto byteArrayOutputStream = LocalRef<jobject> (env->NewObject (ByteArrayOutputStream,

  1267.                                                                             ByteArrayOutputStream.constructor));

  1268. 

  1269.             auto jCompressFormatString = javaString ("JPEG");

  1270.             auto compressFormat = LocalRef<jobject> (env->CallStaticObjectMethod (AndroidBitmapCompressFormat,

  1271.                                                                                   AndroidBitmapCompressFormat.valueOf,

  1272.                                                                                   jCompressFormatString.get()));

  1273. 

  1274.             if (env->CallBooleanMethod (correctedBitmap, AndroidBitmap.compress, compressFormat.get(),

  1275.                                         (jint) 100, byteArrayOutputStream.get()) != 0)

  1276.             {

  1277.                 auto correctedByteArray = LocalRef<jbyteArray> ((jbyteArray) env->CallObjectMethod (byteArrayOutputStream,

  1278.                                                                                                     ByteArrayOutputStream.toByteArray));

  1279. 

  1280.                 int correctedByteArraySize = env->CallIntMethod (byteArrayOutputStream, ByteArrayOutputStream.size);

  1281. 

  1282.                 return { correctedByteArray, correctedByteArraySize };

  1283.             }

  1284. 

  1285.             jassertfalse;

  1286.             // fallback, return original bitmap

  1287.             return { byteArray, bufferSize };

  1288.         }

  1289. 

  1290.         static int getRotationAngle (Desktop::DisplayOrientation deviceOrientationFromAccelerometerSensor,

  1291.                                      Desktop::DisplayOrientation targetOrientation,

  1292.                                      bool cameraLensFrontFacing,

  1293.                                      int cameraSensorOrientation)

  1294.         {

  1295.             auto isSensorOrientationHorizontal = deviceOrientationFromAccelerometerSensor == Desktop::rotatedAntiClockwise

  1296.                                               || deviceOrientationFromAccelerometerSensor == Desktop::rotatedClockwise;

  1297. 

  1298.             if (cameraLensFrontFacing && isSensorOrientationHorizontal)

  1299.             {

  1300.                 // flip angles for front camera

  1301.                 return getRotationAngle (deviceOrientationFromAccelerometerSensor, targetOrientation, false, (cameraSensorOrientation + 180) % 360);

  1302.             }

  1303. 

  1304.             switch (targetOrientation)

  1305.             {

  1306.                 case Desktop::rotatedAntiClockwise:

  1307.                     return cameraSensorOrientation == 90 ? 0 : 180;

  1308.                 case Desktop::rotatedClockwise:

  1309.                     return cameraSensorOrientation == 90 ? 180 : 0;

  1310.                 case Desktop::upright:

  1311.                 case Desktop::upsideDown:

  1312.                     if ((targetOrientation == Desktop::upright && ! cameraLensFrontFacing)

  1313.                         || (targetOrientation == Desktop::upsideDown && cameraLensFrontFacing))

  1314.                     {

  1315.                         return cameraSensorOrientation;

  1316.                     }

  1317.                     else

  1318.                     {

  1319.                         if (deviceOrientationFromAccelerometerSensor == Desktop::upright || deviceOrientationFromAccelerometerSensor == Desktop::upsideDown)

  1320.                             return cameraSensorOrientation;

  1321.                         else

  1322.                             return (cameraSensorOrientation + 180) % 360;

  1323.                     }

  1324.                     break;

  1325.                 case Desktop::allOrientations:

  1326.                 default:

  1327.                     return 0;

  1328.             }

  1329.         }

  1330. 

  1331.         static LocalRef<jobject> getBitmapWithCorrectOrientationFrom (LocalRef<jobject>& origBitmap, int rotationAngle)

  1332.         {

  1333.             auto* env = getEnv();

  1334. 

  1335.             auto origBitmapWidth  = env->CallIntMethod (origBitmap, AndroidBitmap.getWidth);

  1336.             auto origBitmapHeight = env->CallIntMethod (origBitmap, AndroidBitmap.getHeight);

  1337. 

  1338.             auto matrix = LocalRef<jobject> (env->NewObject (AndroidMatrix, AndroidMatrix.constructor));

  1339.             env->CallBooleanMethod (matrix, AndroidMatrix.postRotate, (jfloat) rotationAngle, (jfloat) 0, (jfloat) 0);

  1340. 

  1341.             auto rotatedBitmap = LocalRef<jobject> (env->CallStaticObjectMethod (AndroidBitmap, AndroidBitmap.createBitmapFrom,

  1342.                                                                                  origBitmap.get(), (jint) 0, (jint) 0,

  1343.                                                                                  (jint) origBitmapWidth, (jint) origBitmapHeight,

  1344.                                                                                  matrix.get(), true));

  1345. 

  1346.             env->CallVoidMethod (origBitmap, AndroidBitmap.recycle);

  1347. 

  1348.             return rotatedBitmap;

  1349.         }

  1350.     };

  1351. 

  1352.     //==============================================================================

  1353.     class MediaRecorder : private MediaRecorderOnInfoListener::Owner,

  1354.                           private MediaRecorderOnErrorListener::Owner

  1355.     {

  1356.     public:

  1357.         MediaRecorder (const String& outputFilePath, int videoWidth, int videoHeight,

  1358.                        int sensorOrientation, int cameraLensFacing)

  1359.             : onInfoListener (*this),

  1360.               onErrorListener (*this),

  1361.               mediaRecorder (LocalRef<jobject> (getEnv()->NewObject (AndroidMediaRecorder,

  1362.                                                                      AndroidMediaRecorder.constructor)))

  1363.         {

  1364.             auto* env = getEnv();

  1365. 

  1366.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setOnInfoListener,

  1367.                                  CreateJavaInterface (&onInfoListener,

  1368.                                                       "android/media/MediaRecorder$OnInfoListener").get());

  1369. 

  1370.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setOnErrorListener,

  1371.                                  CreateJavaInterface (&onErrorListener,

  1372.                                                       "android/media/MediaRecorder$OnErrorListener").get());

  1373. 

  1374.             // NB: the order of function calls here is enforced, and exceptions will be thrown if

  1375.             //     the order is changed.

  1376.             static constexpr int audioSourceMic = 1;

  1377.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setAudioSource, (jint) audioSourceMic);

  1378. 

  1379.             static constexpr int videoSourceSurface = 2;

  1380.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setVideoSource, (jint) videoSourceSurface);

  1381. 

  1382.             static constexpr int outputFormatMPEG4 = 2;

  1383.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setOutputFormat, (jint) outputFormatMPEG4);

  1384. 

  1385.             static constexpr int audioEncoderAAC = 3;

  1386.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setAudioEncoder, (jint) audioEncoderAAC);

  1387. 

  1388.             static constexpr int videoEncoderH264 = 2;

  1389.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setVideoEncoder, (jint) videoEncoderH264);

  1390. 

  1391.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setVideoEncodingBitRate, (jint) 10000000);

  1392.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setVideoFrameRate, (jint) 30);

  1393. 

  1394.             auto frontFacing = cameraLensFacing == 0;

  1395. 

  1396.             auto useInverseDegrees = frontFacing && sensorOrientation == 90;

  1397. 

  1398.             int orientationHint = getOrientationHint (useInverseDegrees, sensorOrientation);

  1399.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setOrientationHint, (jint) orientationHint);

  1400. 

  1401.             getEnv()->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setVideoSize, (jint) videoWidth, (jint) videoHeight);

  1402.             getEnv()->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.setOutputFile, javaString (outputFilePath).get());

  1403.             getEnv()->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.prepare);

  1404.         }

  1405. 

  1406.         ~MediaRecorder() override

  1407.         {

  1408.             getEnv()->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.release);

  1409.         }

  1410. 

  1411.         LocalRef<jobject> getSurface()

  1412.         {

  1413.             return LocalRef<jobject> (getEnv()->CallObjectMethod (mediaRecorder, AndroidMediaRecorder.getSurface));

  1414.         }

  1415. 

  1416.         void start()

  1417.         {

  1418.             lockScreenOrientation();

  1419. 

  1420.             getEnv()->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.start);

  1421. 

  1422.             hasStartedRecording = true;

  1423.         }

  1424. 

  1425.         void stop()

  1426.         {

  1427.             // A request to stop can be sent before recording has had a chance to start, so

  1428.             // ignore the request rather than calling AndroidMediaRecorder.stop because

  1429.             // otherwise MediaRecorder will throw an exception and...

  1430.             if (! hasStartedRecording)

  1431.                 return;

  1432. 

  1433.             hasStartedRecording = false;

  1434. 

  1435.             auto* env = getEnv();

  1436.             env->CallVoidMethod (mediaRecorder, AndroidMediaRecorder.stop);

  1437. 

  1438.             // ... ignore RuntimeException that can be thrown if stop() was called after recording

  1439.             // has started but before any frame was written to a file. This is not an error.

  1440.             jniCheckHasExceptionOccurredAndClear();

  1441. 

  1442.             unlockScreenOrientation();

  1443.         }

  1444. 

  1445.     private:

  1446.         MediaRecorderOnInfoListener onInfoListener;

  1447.         MediaRecorderOnErrorListener onErrorListener;

  1448.         GlobalRef mediaRecorder;

  1449.         bool hasStartedRecording = false;

  1450.         int orientationsEnabled = -1;

  1451. 

  1452.         void lockScreenOrientation()

  1453.         {

  1454.             orientationsEnabled = Desktop::getInstance().getOrientationsEnabled();

  1455. 

  1456.             auto o = Desktop::getInstance().getCurrentOrientation();

  1457.             Desktop::getInstance().setOrientationsEnabled (o);

  1458.         }

  1459. 

  1460.         static jint juceOrientationToNativeOrientation (int orientations) noexcept

  1461.         {

  1462.             enum

  1463.             {

  1464.                 SCREEN_ORIENTATION_LANDSCAPE          = 0,

  1465.                 SCREEN_ORIENTATION_PORTRAIT           = 1,

  1466.                 SCREEN_ORIENTATION_USER               = 2,

  1467.                 SCREEN_ORIENTATION_REVERSE_LANDSCAPE  = 8,

  1468.                 SCREEN_ORIENTATION_REVERSE_PORTRAIT   = 9,

  1469.                 SCREEN_ORIENTATION_USER_LANDSCAPE     = 11,

  1470.                 SCREEN_ORIENTATION_USER_PORTRAIT      = 12,

  1471.             };

  1472. 

  1473.             switch (orientations)

  1474.             {

  1475.                 case Desktop::upright:                                          return (jint) SCREEN_ORIENTATION_PORTRAIT;

  1476.                 case Desktop::upsideDown:                                       return (jint) SCREEN_ORIENTATION_REVERSE_PORTRAIT;

  1477.                 case Desktop::upright + Desktop::upsideDown:                    return (jint) SCREEN_ORIENTATION_USER_PORTRAIT;

  1478.                 case Desktop::rotatedAntiClockwise:                             return (jint) SCREEN_ORIENTATION_LANDSCAPE;

  1479.                 case Desktop::rotatedClockwise:                                 return (jint) SCREEN_ORIENTATION_REVERSE_LANDSCAPE;

  1480.                 case Desktop::rotatedClockwise + Desktop::rotatedAntiClockwise: return (jint) SCREEN_ORIENTATION_USER_LANDSCAPE;

  1481.                 default:                                                        return (jint) SCREEN_ORIENTATION_USER;

  1482.             }

  1483.         }

  1484. 

  1485.         void unlockScreenOrientation()

  1486.         {

  1487.             Desktop::getInstance().setOrientationsEnabled (orientationsEnabled);

  1488.         }

  1489. 

  1490.         void onInfo (LocalRef<jobject>& recorder, int what, int extra) override

  1491.         {

  1492.             ignoreUnused (recorder, what, extra);

  1493. 

  1494.             JUCE_CAMERA_LOG ("MediaRecorder::OnInfo: " + getInfoStringFromCode (what)

  1495.                                      + ", extra code = " + String (extra));

  1496.         }

  1497. 

  1498.         void onError (LocalRef<jobject>& recorder, int what, int extra) override

  1499.         {

  1500.             ignoreUnused (recorder, what, extra);

  1501. 

  1502.             JUCE_CAMERA_LOG ("MediaRecorder::onError: " + getErrorStringFromCode (what)

  1503.                                      + ", extra code = " + String (extra));

  1504.         }

  1505. 

  1506.         static String getInfoStringFromCode (int what)

  1507.         {

  1508.             enum

  1509.             {

  1510.                 MEDIA_RECORDER_INFO_UNKNOWN = 1,

  1511.                 MEDIA_RECORDER_INFO_MAX_DURATION_REACHED = 800,

  1512.                 MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED = 801,

  1513.                 MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING = 802,

  1514.                 MEDIA_RECORDER_INFO_NEXT_OUTPUT_FILE_STARTED = 803

  1515.             };

  1516. 

  1517.             switch (what)

  1518.             {

  1519.                 case MEDIA_RECORDER_INFO_UNKNOWN:                  return { "Unknown info" };

  1520.                 case MEDIA_RECORDER_INFO_MAX_DURATION_REACHED:     return { "Max duration reached" };

  1521.                 case MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED:     return { "Max filesize reached" };

  1522.                 case MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING: return { "Max filesize approaching" };

  1523.                 case MEDIA_RECORDER_INFO_NEXT_OUTPUT_FILE_STARTED: return { "Next output file started" };

  1524.                 default: return String (what);

  1525.             };

  1526.         }

  1527. 

  1528.         static String getErrorStringFromCode (int what)

  1529.         {

  1530.             enum

  1531.             {

  1532.                 MEDIA_RECORDER_ERROR_UNKNOWN = 1,

  1533.                 MEDIA_ERROR_SERVER_DIED = 100

  1534.             };

  1535. 

  1536.             switch (what)

  1537.             {

  1538.                 case MEDIA_RECORDER_ERROR_UNKNOWN:   return { "Unknown error" };

  1539.                 case MEDIA_ERROR_SERVER_DIED:        return { "Server died" };

  1540.                 default: return String (what);

  1541.             };

  1542.         }

  1543. 

  1544.         static int getOrientationHint (bool useInverseDegrees, int cameraSensorOrientation)

  1545.         {

  1546.             auto* env = getEnv();

  1547. 

  1548.             auto windowManager = LocalRef<jobject> (env->CallObjectMethod (getAppContext(), AndroidContext.getSystemService, javaString ("window").get()));

  1549.             auto display = LocalRef<jobject> (env->CallObjectMethod (windowManager, AndroidWindowManager.getDefaultDisplay));

  1550.             auto rotation = env->CallIntMethod (display, AndroidDisplay.getRotation);

  1551. 

  1552.             enum

  1553.             {

  1554.                 ROTATION_0 = 0,

  1555.                 ROTATION_90,

  1556.                 ROTATION_180,

  1557.                 ROTATION_270

  1558.             };

  1559. 

  1560.             int hint = 0;

  1561. 

  1562.             switch (rotation)

  1563.             {

  1564.                 case ROTATION_0:   hint = cameraSensorOrientation;       break;

  1565.                 case ROTATION_90:  hint = useInverseDegrees ? 180 : 0;   break;

  1566.                 case ROTATION_180: hint = cameraSensorOrientation + 180; break;

  1567.                 case ROTATION_270: hint = useInverseDegrees ? 0 : 180;   break;

  1568.                 default: jassertfalse;

  1569.             }

  1570. 

  1571.             return (hint + 360) % 360;

  1572.         }

  1573.     };

  1574. 

  1575.     //==============================================================================

  1576.     class ScopedCameraDevice

  1577.     {

  1578.     public:

  1579.         //==============================================================================

  1580.         class CaptureSession

  1581.         {

  1582.         public:

  1583.             struct ConfiguredCallback

  1584.             {

  1585.                 virtual ~ConfiguredCallback() {}

  1586. 

  1587.                 virtual void captureSessionConfigured (CaptureSession*) = 0;

  1588.             };

  1589. 

  1590.             ~CaptureSession()

  1591.             {

  1592.                 bool calledClose = false;

  1593. 

  1594.                 auto* env = getEnv();

  1595. 

  1596.                 {

  1597.                     const ScopedLock lock (captureSessionLock);

  1598. 

  1599.                     if (captureSession.get() != nullptr)

  1600.                     {

  1601.                         calledClose = true;

  1602. 

  1603.                         env->CallVoidMethod (captureSession, CameraCaptureSession.close);

  1604.                     }

  1605.                 }

  1606. 

  1607.                 // When exception occurs, CameraCaptureSession.close will never finish, so

  1608.                 // we should not wait for it. For fatal error an exception does occur, but

  1609.                 // it is caught internally in Java...

  1610.                 if (jniCheckHasExceptionOccurredAndClear() || scopedCameraDevice.fatalErrorOccurred.get())

  1611.                 {

  1612.                     JUCE_CAMERA_LOG ("Exception or fatal error occurred while closing Capture Session, closing by force");

  1613.                 }

  1614.                 else if (calledClose)

  1615.                 {

  1616.                     pendingClose.set (1);

  1617.                     closedEvent.wait (-1);

  1618.                 }

  1619.             }

  1620. 

  1621.             bool openedOk() const noexcept { return captureSession != nullptr; }

  1622. 

  1623.             const GlobalRef& getNativeSession() const { return captureSession; }

  1624. 

  1625.             bool start (const LocalRef<jobject>& targetSurfacesList, GlobalRef& handlerToUse)

  1626.             {

  1627.                 if (! openedOk())

  1628.                 {

  1629.                     jassertfalse;

  1630.                     return false;

  1631.                 }

  1632. 

  1633.                 auto* env = getEnv();

  1634. 

  1635.                 auto numSurfaces = env->CallIntMethod (targetSurfacesList, JavaArrayList.size);

  1636. 

  1637.                 for (int i = 0; i < numSurfaces; ++i)

  1638.                 {

  1639.                     auto surface = LocalRef<jobject> (env->CallObjectMethod (targetSurfacesList, JavaArrayList.get, (jint) i));

  1640.                     env->CallVoidMethod (captureRequestBuilder, CaptureRequestBuilder.addTarget, surface.get());

  1641.                 }

  1642. 

  1643.                 previewCaptureRequest = GlobalRef (LocalRef<jobject>(env->CallObjectMethod (captureRequestBuilder, CaptureRequestBuilder.build)));

  1644. 

  1645.                 env->CallIntMethod (captureSession, CameraCaptureSession.setRepeatingRequest,

  1646.                                     previewCaptureRequest.get(), nullptr, handlerToUse.get());

  1647. 

  1648.                 return true;

  1649.             }

  1650. 

  1651.             void takeStillPicture (jobject targetSurface)

  1652.             {

  1653.                 if (stillPictureTaker == nullptr)

  1654.                 {

  1655.                     // Can only take picture once session was successfully configured!

  1656.                     jassertfalse;

  1657.                     return;

  1658.                 }

  1659. 

  1660.                 auto* env = getEnv();

  1661. 

  1662.                 static constexpr int templateStillCapture = 2;

  1663.                 auto builder = LocalRef<jobject> (env->CallObjectMethod (scopedCameraDevice.cameraDevice,

  1664.                                                                          AndroidCameraDevice.createCaptureRequest,

  1665.                                                                          (jint) templateStillCapture));

  1666. 

  1667.                 env->CallVoidMethod (builder, CaptureRequestBuilder.addTarget, targetSurface);

  1668. 

  1669.                 setCaptureRequestBuilderIntegerKey (builder, CaptureRequest.CONTROL_AF_MODE, autoFocusMode);

  1670. 

  1671.                 auto stillPictureCaptureRequest = LocalRef<jobject> (env->CallObjectMethod (builder, CaptureRequestBuilder.build));

  1672. 

  1673.                 stillPictureTaker->takePicture (stillPictureCaptureRequest);

  1674.             }

  1675. 

  1676.         private:

  1677.             //==============================================================================

  1678.             class StillPictureTaker   : private AndroidRunnable::Owner

  1679.             {

  1680.             public:

  1681.                 StillPictureTaker (GlobalRef& captureSessionToUse, GlobalRef& captureRequestBuilderToUse,

  1682.                                    GlobalRef& previewCaptureRequestToUse, GlobalRef& handlerToUse,

  1683.                                    int autoFocusModeToUse)

  1684.                     : captureSession (captureSessionToUse),

  1685.                       captureRequestBuilder (captureRequestBuilderToUse),

  1686.                       previewCaptureRequest (previewCaptureRequestToUse),

  1687.                       handler (handlerToUse),

  1688.                       runnable (*this),

  1689.                       captureSessionPreviewCaptureCallback (createCaptureSessionCallback (true)),

  1690.                       captureSessionStillPictureCaptureCallback (createCaptureSessionCallback (false)),

  1691.                       autoFocusMode (autoFocusModeToUse)

  1692.                 {

  1693.                 }

  1694. 

  1695.                 void takePicture (const LocalRef<jobject>& stillPictureCaptureRequestToUse)

  1696.                 {

  1697.                     JUCE_CAMERA_LOG ("Taking picture...");

  1698. 

  1699.                     stillPictureCaptureRequest = GlobalRef (LocalRef<jobject>(stillPictureCaptureRequestToUse));

  1700. 

  1701.                     lockFocus();

  1702.                 }

  1703. 

  1704.             private:

  1705.                 GlobalRef& captureSession;

  1706.                 GlobalRef& captureRequestBuilder;

  1707.                 GlobalRef& previewCaptureRequest;

  1708.                 GlobalRef& handler;

  1709. 

  1710.                 AndroidRunnable runnable;

  1711.                 GlobalRef delayedCaptureRunnable;

  1712. 

  1713.                 GlobalRef captureSessionPreviewCaptureCallback;

  1714. 

  1715.                 GlobalRef stillPictureCaptureRequest;

  1716.                 GlobalRef captureSessionStillPictureCaptureCallback;

  1717. 

  1718.                 int autoFocusMode;

  1719. 

  1720.                 //==============================================================================

  1721.                 #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  1722.                    METHOD (constructor, "<init>", "(JZ)V")              \

  1723.                    CALLBACK (cameraCaptureSessionCaptureCompletedCallback,         "cameraCaptureSessionCaptureCompleted",         "(JZLandroid/hardware/camera2/CameraCaptureSession;Landroid/hardware/camera2/CaptureRequest;Landroid/hardware/camera2/TotalCaptureResult;)V") \

  1724.                    CALLBACK (cameraCaptureSessionCaptureFailedCallback,            "cameraCaptureSessionCaptureFailed",            "(JZLandroid/hardware/camera2/CameraCaptureSession;Landroid/hardware/camera2/CaptureRequest;Landroid/hardware/camera2/CaptureFailure;)V") \

  1725.                    CALLBACK (cameraCaptureSessionCaptureProgressedCallback,        "cameraCaptureSessionCaptureProgressed",        "(JZLandroid/hardware/camera2/CameraCaptureSession;Landroid/hardware/camera2/CaptureRequest;Landroid/hardware/camera2/CaptureResult;)V") \

  1726.                    CALLBACK (cameraCaptureSessionCaptureStartedCallback,           "cameraCaptureSessionCaptureStarted",           "(JZLandroid/hardware/camera2/CameraCaptureSession;Landroid/hardware/camera2/CaptureRequest;JJ)V") \

  1727.                    CALLBACK (cameraCaptureSessionCaptureSequenceAbortedCallback,   "cameraCaptureSessionCaptureSequenceAborted",   "(JZLandroid/hardware/camera2/CameraCaptureSession;I)V") \

  1728.                    CALLBACK (cameraCaptureSessionCaptureSequenceCompletedCallback, "cameraCaptureSessionCaptureSequenceCompleted", "(JZLandroid/hardware/camera2/CameraCaptureSession;IJ)V")

  1729. 

  1730.                 DECLARE_JNI_CLASS_WITH_BYTECODE (CameraCaptureSessionCaptureCallback, "com/rmsl/juce/CameraCaptureSessionCaptureCallback", 21, CameraSupportByteCode, sizeof(CameraSupportByteCode))

  1731.                 #undef JNI_CLASS_MEMBERS

  1732. 

  1733.                 LocalRef<jobject> createCaptureSessionCallback (bool createPreviewSession)

  1734.                 {

  1735.                     return LocalRef<jobject>(getEnv()->NewObject (CameraCaptureSessionCaptureCallback,

  1736.                                                                   CameraCaptureSessionCaptureCallback.constructor,

  1737.                                                                   reinterpret_cast<jlong> (this),

  1738.                                                                   createPreviewSession ? 1 : 0));

  1739.                 }

  1740. 

  1741.                 //==============================================================================

  1742. 

  1743.                 enum class State

  1744.                 {

  1745.                     idle = 0,

  1746.                     pendingFocusLock,

  1747.                     pendingExposurePrecapture,

  1748.                     pendingExposurePostPrecapture,

  1749.                     pictureTaken

  1750.                 };

  1751. 

  1752.                 State currentState = State::idle;

  1753. 

  1754.                 void lockFocus()

  1755.                 {

  1756.                     if (jniCheckHasExceptionOccurredAndClear())

  1757.                         return;

  1758. 

  1759.                     JUCE_CAMERA_LOG ("Performing auto-focus if possible...");

  1760. 

  1761.                     currentState = State::pendingFocusLock;

  1762. 

  1763.                     auto* env = getEnv();

  1764. 

  1765.                     // NB: auto-focus may be unavailable on a device, in which case it may have already

  1766.                     // automatically adjusted the exposure. We check for that in updateState().

  1767.                     static constexpr int controlAfTriggerStart = 1;

  1768.                     CaptureSession::setCaptureRequestBuilderIntegerKey (captureRequestBuilder.get(),

  1769.                                                                         CaptureRequest.CONTROL_AF_TRIGGER,

  1770.                                                                         controlAfTriggerStart);

  1771. 

  1772.                     auto previewRequest = LocalRef<jobject> (env->CallObjectMethod (captureRequestBuilder,

  1773.                                                                                     CaptureRequestBuilder.build));

  1774. 

  1775.                     env->CallIntMethod (captureSession, CameraCaptureSession.capture, previewRequest.get(),

  1776.                                         captureSessionPreviewCaptureCallback.get(), handler.get());

  1777.                 }

  1778. 

  1779.                 void updateState (jobject captureResult)

  1780.                 {

  1781.                     // IllegalStateException can be thrown when accessing CaptureSession,

  1782.                     // claiming that capture session was already closed but we may not

  1783.                     // get relevant callback yet, so check for this and bailout when needed.

  1784.                     if (jniCheckHasExceptionOccurredAndClear())

  1785.                         return;

  1786. 

  1787.                     switch (currentState)

  1788.                     {

  1789.                         case State::pendingFocusLock:

  1790.                         {

  1791.                             JUCE_CAMERA_LOG ("Still picture capture, updateState(), State::pendingFocusLock...");

  1792. 

  1793.                             auto controlAfStateValue = getCaptureResultIntegerKeyValue (CaptureResult.CONTROL_AF_STATE, captureResult);

  1794. 

  1795.                             if (controlAfStateValue.get() == nullptr)

  1796.                             {

  1797.                                 captureStillPictureDelayed();

  1798.                                 return;

  1799.                             }

  1800. 

  1801.                             auto autoToFocusNotAvailable = autoFocusMode == 0;

  1802. 

  1803.                             if (autoToFocusNotAvailable || autoFocusHasFinished (controlAfStateValue))

  1804.                             {

  1805.                                 auto controlAeStateIntValue = getControlAEState (captureResult);

  1806.                                 static constexpr int controlAeStateConverged = 2;

  1807. 

  1808.                                 if (controlAeStateIntValue == -1 || controlAeStateIntValue == controlAeStateConverged)

  1809.                                 {

  1810.                                     currentState = State::pictureTaken;

  1811.                                     captureStillPictureDelayed();

  1812.                                 }

  1813.                                 else

  1814.                                 {

  1815.                                     runPrecaptureSequence();

  1816.                                 }

  1817.                             }

  1818. 

  1819.                             break;

  1820.                         }

  1821. 

  1822.                         case State::pendingExposurePrecapture:

  1823.                         {

  1824.                             JUCE_CAMERA_LOG ("Still picture capture, updateState(), State::pendingExposurePrecapture...");

  1825. 

  1826.                             auto controlAeStateIntValue = getControlAEState (captureResult);

  1827.                             static constexpr int controlAeStateFlashRequired = 4;

  1828.                             static constexpr int controlAeStatePrecapture = 5;

  1829. 

  1830.                             if (controlAeStateIntValue == -1 || controlAeStateIntValue == controlAeStateFlashRequired

  1831.                                                              || controlAeStateIntValue == controlAeStatePrecapture)

  1832.                             {

  1833.                                 currentState = State::pendingExposurePostPrecapture;

  1834.                             }

  1835. 

  1836.                             break;

  1837.                         }

  1838. 

  1839.                         case State::pendingExposurePostPrecapture:

  1840.                         {

  1841.                             JUCE_CAMERA_LOG ("Still picture capture, updateState(), State::pendingExposurePostPrecapture...");

  1842. 

  1843.                             auto controlAeStateIntValue = getControlAEState (captureResult);

  1844.                             static constexpr int controlAeStatePrecapture = 5;

  1845. 

  1846.                             if (controlAeStateIntValue == -1 || controlAeStateIntValue != controlAeStatePrecapture)

  1847.                             {

  1848.                                 currentState = State::pictureTaken;

  1849.                                 captureStillPictureDelayed();

  1850.                             }

  1851. 

  1852.                             break;

  1853.                         }

  1854.                         case State::idle:

  1855.                         case State::pictureTaken:

  1856.                             { /* do nothing */ break; }

  1857.                     };

  1858.                 }

  1859. 

  1860.                 static int getControlAEState (jobject captureResult)

  1861.                 {

  1862.                     auto controlAeStateValue = getCaptureResultIntegerKeyValue (CaptureResult.CONTROL_AE_STATE, captureResult);

  1863. 

  1864.                     return controlAeStateValue.get() != nullptr

  1865.                                     ? getEnv()->CallIntMethod (controlAeStateValue, JavaInteger.intValue) : -1;

  1866.                 }

  1867. 

  1868.                 static bool autoFocusHasFinished (const LocalRef<jobject>& controlAfStateValue)

  1869.                 {

  1870.                     static constexpr int controlAfStateFocusedLocked = 4;

  1871.                     static constexpr int controlAfStateNotFocusedLocked = 5;

  1872. 

  1873.                     auto controlAfStateIntValue = getEnv()->CallIntMethod (controlAfStateValue, JavaInteger.intValue);

  1874. 

  1875.                     return controlAfStateIntValue == controlAfStateFocusedLocked || controlAfStateIntValue == controlAfStateNotFocusedLocked;

  1876.                 }

  1877. 

  1878.                 static LocalRef<jobject> getCaptureResultIntegerKeyValue (jfieldID key, jobject captureResult)

  1879.                 {

  1880.                     auto* env = getEnv();

  1881. 

  1882.                     auto jKey = LocalRef<jobject> (env->GetStaticObjectField (CaptureResult, key));

  1883.                     return LocalRef<jobject> (env->CallObjectMethod (captureResult, CaptureResult.get, jKey.get()));

  1884.                 }

  1885. 

  1886.                 void captureStillPictureDelayed()

  1887.                 {

  1888.                     if (jniCheckHasExceptionOccurredAndClear())

  1889.                         return;

  1890. 

  1891.                     JUCE_CAMERA_LOG ("Still picture capture, device ready, capturing now...");

  1892. 

  1893.                     auto* env = getEnv();

  1894. 

  1895.                     env->CallVoidMethod (captureSession, CameraCaptureSession.stopRepeating);

  1896. 

  1897.                     if (jniCheckHasExceptionOccurredAndClear())

  1898.                         return;

  1899. 

  1900.                     env->CallVoidMethod (captureSession, CameraCaptureSession.abortCaptures);

  1901. 

  1902.                     if (jniCheckHasExceptionOccurredAndClear())

  1903.                         return;

  1904. 

  1905.                     // Delay still picture capture for devices that can't handle it right after

  1906.                     // stopRepeating/abortCaptures calls.

  1907.                     if (delayedCaptureRunnable.get() == nullptr)

  1908.                         delayedCaptureRunnable = GlobalRef (CreateJavaInterface (&runnable, "java/lang/Runnable"));

  1909. 

  1910.                     env->CallBooleanMethod (handler, AndroidHandler.postDelayed, delayedCaptureRunnable.get(), (jlong) 200);

  1911.                 }

  1912. 

  1913.                 void runPrecaptureSequence()

  1914.                 {

  1915.                     if (jniCheckHasExceptionOccurredAndClear())

  1916.                         return;

  1917. 

  1918.                     auto* env = getEnv();

  1919. 

  1920.                     static constexpr int controlAePrecaptureTriggerStart = 1;

  1921.                     CaptureSession::setCaptureRequestBuilderIntegerKey (captureRequestBuilder.get(),

  1922.                                                                         CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,

  1923.                                                                         controlAePrecaptureTriggerStart);

  1924. 

  1925.                     currentState = State::pendingExposurePrecapture;

  1926. 

  1927.                     auto previewRequest = LocalRef<jobject> (env->CallObjectMethod (captureRequestBuilder,

  1928.                                                                                     CaptureRequestBuilder.build));

  1929. 

  1930.                     env->CallIntMethod (captureSession, CameraCaptureSession.capture, previewRequest.get(),

  1931.                                         captureSessionPreviewCaptureCallback.get(), handler.get());

  1932.                 }

  1933. 

  1934.                 void unlockFocus()

  1935.                 {

  1936.                     if (jniCheckHasExceptionOccurredAndClear())

  1937.                         return;

  1938. 

  1939.                     JUCE_CAMERA_LOG ("Unlocking focus...");

  1940. 

  1941.                     currentState = State::idle;

  1942. 

  1943.                     auto* env = getEnv();

  1944. 

  1945.                     static constexpr int controlAfTriggerCancel = 2;

  1946.                     CaptureSession::setCaptureRequestBuilderIntegerKey (captureRequestBuilder.get(),

  1947.                                                                         CaptureRequest.CONTROL_AF_TRIGGER,

  1948.                                                                         controlAfTriggerCancel);

  1949. 

  1950.                     auto resetAutoFocusRequest = LocalRef<jobject> (env->CallObjectMethod (captureRequestBuilder,

  1951.                                                                                            CaptureRequestBuilder.build));

  1952. 

  1953.                     env->CallIntMethod (captureSession, CameraCaptureSession.capture, resetAutoFocusRequest.get(),

  1954.                                         nullptr, handler.get());

  1955. 

  1956.                     if (jniCheckHasExceptionOccurredAndClear())

  1957.                         return;

  1958. 

  1959.                     // NB: for preview, using preview capture request again

  1960.                     env->CallIntMethod (captureSession, CameraCaptureSession.setRepeatingRequest, previewCaptureRequest.get(),

  1961.                                         nullptr, handler.get());

  1962.                 }

  1963.                 //==============================================================================

  1964.                 void run() override

  1965.                 {

  1966.                     captureStillPicture();

  1967.                 }

  1968. 

  1969.                 void captureStillPicture()

  1970.                 {

  1971.                     getEnv()->CallIntMethod (captureSession, CameraCaptureSession.capture,

  1972.                                              stillPictureCaptureRequest.get(), captureSessionStillPictureCaptureCallback.get(),

  1973.                                              nullptr);

  1974.                 }

  1975. 

  1976.                 //==============================================================================

  1977.                 void cameraCaptureSessionCaptureCompleted (bool isPreview, jobject session, jobject request, jobject result)

  1978.                 {

  1979.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureCompleted()");

  1980. 

  1981.                     ignoreUnused (session, request);

  1982. 

  1983.                     if (isPreview)

  1984.                         updateState (result);

  1985.                     else if (currentState != State::idle)

  1986.                         unlockFocus();

  1987.                 }

  1988. 

  1989.                 void cameraCaptureSessionCaptureFailed (bool isPreview, jobject session, jobject request, jobject failure)

  1990.                 {

  1991.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureFailed()");

  1992. 

  1993.                     ignoreUnused (isPreview, session, request, failure);

  1994.                 }

  1995. 

  1996.                 void cameraCaptureSessionCaptureProgressed (bool isPreview, jobject session, jobject request, jobject partialResult)

  1997.                 {

  1998.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureProgressed()");

  1999. 

  2000.                     ignoreUnused (session, request);

  2001. 

  2002.                     if (isPreview)

  2003.                         updateState (partialResult);

  2004.                 }

  2005. 

  2006.                 void cameraCaptureSessionCaptureSequenceAborted (bool isPreview, jobject session, int sequenceId)

  2007.                 {

  2008.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureSequenceAborted()");

  2009. 

  2010.                     ignoreUnused (isPreview, isPreview, session, sequenceId);

  2011.                 }

  2012. 

  2013.                 void cameraCaptureSessionCaptureSequenceCompleted (bool isPreview, jobject session, int sequenceId, int64 frameNumber)

  2014.                 {

  2015.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureSequenceCompleted()");

  2016. 

  2017.                     ignoreUnused (isPreview, session, sequenceId, frameNumber);

  2018.                 }

  2019. 

  2020.                 void cameraCaptureSessionCaptureStarted (bool isPreview, jobject session, jobject request, int64 timestamp, int64 frameNumber)

  2021.                 {

  2022.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureStarted()");

  2023. 

  2024.                     ignoreUnused (isPreview, session, request, timestamp, frameNumber);

  2025.                 }

  2026. 

  2027.                 //==============================================================================

  2028.                 static void cameraCaptureSessionCaptureCompletedCallback (JNIEnv*, jobject /*object*/, jlong host, jboolean isPreview, jobject rawSession, jobject rawRequest, jobject rawResult)

  2029.                 {

  2030.                     if (auto* myself = reinterpret_cast<StillPictureTaker*> (host))

  2031.                     {

  2032.                         LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2033.                         LocalRef<jobject> request (getEnv()->NewLocalRef(rawRequest));

  2034.                         LocalRef<jobject> result (getEnv()->NewLocalRef(rawResult));

  2035. 

  2036.                         myself->cameraCaptureSessionCaptureCompleted (isPreview != 0, session, request, result);

  2037.                     }

  2038.                 }

  2039. 

  2040.                 static void cameraCaptureSessionCaptureFailedCallback (JNIEnv*, jobject /*object*/, jlong host, jboolean isPreview, jobject rawSession, jobject rawRequest, jobject rawResult)

  2041.                 {

  2042.                     if (auto* myself = reinterpret_cast<StillPictureTaker*> (host))

  2043.                     {

  2044.                         LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2045.                         LocalRef<jobject> request (getEnv()->NewLocalRef(rawRequest));

  2046.                         LocalRef<jobject> result (getEnv()->NewLocalRef(rawResult));

  2047. 

  2048.                         myself->cameraCaptureSessionCaptureFailed (isPreview != 0, session, request, result);

  2049.                     }

  2050.                 }

  2051. 

  2052.                 static void cameraCaptureSessionCaptureProgressedCallback (JNIEnv*, jobject /*object*/, jlong host, jboolean isPreview, jobject rawSession, jobject rawRequest, jobject rawResult)

  2053.                 {

  2054.                     if (auto* myself = reinterpret_cast<StillPictureTaker*> (host))

  2055.                     {

  2056.                         LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2057.                         LocalRef<jobject> request (getEnv()->NewLocalRef(rawRequest));

  2058.                         LocalRef<jobject> result (getEnv()->NewLocalRef(rawResult));

  2059. 

  2060.                         myself->cameraCaptureSessionCaptureProgressed (isPreview != 0, session, request, result);

  2061.                     }

  2062.                 }

  2063. 

  2064.                 static void cameraCaptureSessionCaptureSequenceAbortedCallback (JNIEnv*, jobject /*object*/, jlong host, jboolean isPreview, jobject rawSession, jint sequenceId)

  2065.                 {

  2066.                     if (auto* myself = reinterpret_cast<StillPictureTaker*> (host))

  2067.                     {

  2068.                         LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2069. 

  2070.                         myself->cameraCaptureSessionCaptureSequenceAborted (isPreview != 0, session, sequenceId);

  2071.                     }

  2072.                 }

  2073. 

  2074.                 static void cameraCaptureSessionCaptureSequenceCompletedCallback (JNIEnv*, jobject /*object*/, jlong host, jboolean isPreview, jobject rawSession, jint sequenceId, jlong frameNumber)

  2075.                 {

  2076.                     if (auto* myself = reinterpret_cast<StillPictureTaker*> (host))

  2077.                     {

  2078.                         LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2079. 

  2080.                         myself->cameraCaptureSessionCaptureSequenceCompleted (isPreview != 0, session, sequenceId, frameNumber);

  2081.                     }

  2082.                 }

  2083. 

  2084.                 static void cameraCaptureSessionCaptureStartedCallback (JNIEnv*, jobject /*object*/, jlong host, jboolean isPreview, jobject rawSession, jobject rawRequest, jlong timestamp, jlong frameNumber)

  2085.                 {

  2086.                     if (auto* myself = reinterpret_cast<StillPictureTaker*> (host))

  2087.                     {

  2088.                         LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2089.                         LocalRef<jobject> request (getEnv()->NewLocalRef(rawRequest));

  2090. 

  2091.                         myself->cameraCaptureSessionCaptureStarted (isPreview != 0, session, request, timestamp, frameNumber);

  2092.                     }

  2093.                 }

  2094.             };

  2095. 

  2096.             //==============================================================================

  2097.             ScopedCameraDevice& scopedCameraDevice;

  2098.             ConfiguredCallback& configuredCallback;

  2099.             GlobalRef& handler;

  2100. 

  2101.             GlobalRef captureRequestBuilder;

  2102.             GlobalRef previewCaptureRequest;

  2103. 

  2104.             GlobalRef captureSessionStateCallback;

  2105.             int autoFocusMode;

  2106. 

  2107.             GlobalRef captureSession;

  2108.             CriticalSection captureSessionLock;

  2109. 

  2110.             Atomic<int> pendingClose { 0 };

  2111. 

  2112.             std::unique_ptr<StillPictureTaker> stillPictureTaker;

  2113. 

  2114.             WaitableEvent closedEvent;

  2115. 

  2116.             JUCE_DECLARE_WEAK_REFERENCEABLE (CaptureSession)

  2117. 

  2118.             //==============================================================================

  2119.             #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK)    \

  2120.                 METHOD (constructor, "<init>", "(J)V") \

  2121.                 CALLBACK(cameraCaptureSessionActiveCallback,          "cameraCaptureSessionActive",          "(JLandroid/hardware/camera2/CameraCaptureSession;)V") \

  2122.                 CALLBACK(cameraCaptureSessionClosedCallback,          "cameraCaptureSessionClosed",          "(JLandroid/hardware/camera2/CameraCaptureSession;)V") \

  2123.                 CALLBACK(cameraCaptureSessionConfigureFailedCallback, "cameraCaptureSessionConfigureFailed", "(JLandroid/hardware/camera2/CameraCaptureSession;)V") \

  2124.                 CALLBACK(cameraCaptureSessionConfiguredCallback,      "cameraCaptureSessionConfigured",      "(JLandroid/hardware/camera2/CameraCaptureSession;)V") \

  2125.                 CALLBACK(cameraCaptureSessionReadyCallback,           "cameraCaptureSessionReady",           "(JLandroid/hardware/camera2/CameraCaptureSession;)V")

  2126. 

  2127.             DECLARE_JNI_CLASS_WITH_MIN_SDK (CameraCaptureSessionStateCallback, "com/rmsl/juce/CameraCaptureSessionStateCallback", 21)

  2128.             #undef JNI_CLASS_MEMBERS

  2129. 

  2130. 

  2131.             //==============================================================================

  2132.             CaptureSession (ScopedCameraDevice& scopedCameraDeviceToUse, ConfiguredCallback& configuredCallbackToUse,

  2133.                             const LocalRef<jobject>& surfacesList, GlobalRef& handlerToUse,

  2134.                             int captureSessionTemplate, int autoFocusModeToUse)

  2135.                 : scopedCameraDevice (scopedCameraDeviceToUse),

  2136.                   configuredCallback (configuredCallbackToUse),

  2137.                   handler (handlerToUse),

  2138.                   captureRequestBuilder (LocalRef<jobject> (getEnv()->CallObjectMethod (scopedCameraDevice.cameraDevice,

  2139.                                                                                         AndroidCameraDevice.createCaptureRequest,

  2140.                                                                                         (jint) captureSessionTemplate))),

  2141.                   captureSessionStateCallback (LocalRef<jobject> (getEnv()->NewObject (CameraCaptureSessionStateCallback,

  2142.                                                                                        CameraCaptureSessionStateCallback.constructor,

  2143.                                                                                        reinterpret_cast<jlong> (this)))),

  2144.                   autoFocusMode (autoFocusModeToUse)

  2145.             {

  2146.                 auto* env = getEnv();

  2147. 

  2148.                 env->CallVoidMethod (scopedCameraDevice.cameraDevice, AndroidCameraDevice.createCaptureSession,

  2149.                                      surfacesList.get(), captureSessionStateCallback.get(), handler.get());

  2150. 

  2151.                 static constexpr int controlModeAuto = 1;

  2152.                 setCaptureRequestBuilderIntegerKey (captureRequestBuilder.get(), CaptureRequest.CONTROL_MODE, controlModeAuto);

  2153. 

  2154.                 setCaptureRequestBuilderIntegerKey (captureRequestBuilder.get(), CaptureRequest.CONTROL_AF_MODE, autoFocusMode);

  2155.             }

  2156. 

  2157.             static void setCaptureRequestBuilderIntegerKey (jobject captureRequestBuilder, jfieldID key, int value)

  2158.             {

  2159.                 auto* env = getEnv();

  2160. 

  2161.                 auto jKey = LocalRef<jobject> (env->GetStaticObjectField (CaptureRequest, key));

  2162.                 auto jValue = LocalRef<jobject> (env->CallStaticObjectMethod (JavaInteger, JavaInteger.valueOf, (jint) value));

  2163. 

  2164.                 env->CallVoidMethod (captureRequestBuilder, CaptureRequestBuilder.set, jKey.get(), jValue.get());

  2165.             }

  2166. 

  2167.             void cameraCaptureSessionActive (jobject session)

  2168.             {

  2169.                 JUCE_CAMERA_LOG ("cameraCaptureSessionActive()");

  2170.                 ignoreUnused (session);

  2171.             }

  2172. 

  2173.             void cameraCaptureSessionClosed (jobject session)

  2174.             {

  2175.                 JUCE_CAMERA_LOG ("cameraCaptureSessionClosed()");

  2176.                 ignoreUnused (session);

  2177. 

  2178.                 closedEvent.signal();

  2179.             }

  2180. 

  2181.             void cameraCaptureSessionConfigureFailed (jobject session)

  2182.             {

  2183.                 JUCE_CAMERA_LOG ("cameraCaptureSessionConfigureFailed()");

  2184.                 ignoreUnused (session);

  2185. 

  2186.                 WeakReference<CaptureSession> weakRef (this);

  2187. 

  2188.                 MessageManager::callAsync ([this, weakRef]()

  2189.                 {

  2190.                     if (weakRef == nullptr)

  2191.                         return;

  2192. 

  2193.                     configuredCallback.captureSessionConfigured (nullptr);

  2194.                 });

  2195.             }

  2196. 

  2197.             void cameraCaptureSessionConfigured (const LocalRef<jobject>& session)

  2198.             {

  2199.                 JUCE_CAMERA_LOG ("cameraCaptureSessionConfigured()");

  2200. 

  2201.                 if (pendingClose.get() == 1)

  2202.                 {

  2203.                     // Already closing, bailout.

  2204.                     closedEvent.signal();

  2205. 

  2206.                     GlobalRef s (session);

  2207. 

  2208.                     MessageManager::callAsync ([s]()

  2209.                         {

  2210.                             getEnv()->CallVoidMethod (s, CameraCaptureSession.close);

  2211.                         });

  2212. 

  2213.                     return;

  2214.                 }

  2215. 

  2216.                 {

  2217.                     const ScopedLock lock (captureSessionLock);

  2218.                     captureSession = GlobalRef (session);

  2219.                 }

  2220. 

  2221.                 WeakReference<CaptureSession> weakRef (this);

  2222. 

  2223.                 MessageManager::callAsync ([this, weakRef]()

  2224.                 {

  2225.                     if (weakRef == nullptr)

  2226.                         return;

  2227. 

  2228.                     stillPictureTaker.reset (new StillPictureTaker (captureSession, captureRequestBuilder,

  2229.                                                                     previewCaptureRequest, handler, autoFocusMode));

  2230. 

  2231.                     configuredCallback.captureSessionConfigured (this);

  2232.                 });

  2233.             }

  2234. 

  2235.             void cameraCaptureSessionReady (const LocalRef<jobject>& session)

  2236.             {

  2237.                 JUCE_CAMERA_LOG ("cameraCaptureSessionReady()");

  2238.                 ignoreUnused (session);

  2239.             }

  2240. 

  2241.             //==============================================================================

  2242.             static void cameraCaptureSessionActiveCallback (JNIEnv*, jobject, jlong host, jobject rawSession)

  2243.             {

  2244.                 if (auto* myself = reinterpret_cast<CaptureSession*> (host))

  2245.                 {

  2246.                     LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2247. 

  2248.                     myself->cameraCaptureSessionActive (session);

  2249.                 }

  2250.             }

  2251. 

  2252.             static void cameraCaptureSessionClosedCallback (JNIEnv*, jobject, jlong host, jobject rawSession)

  2253.             {

  2254.                 if (auto* myself = reinterpret_cast<CaptureSession*> (host))

  2255.                 {

  2256.                     LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2257. 

  2258.                     myself->cameraCaptureSessionClosed (session);

  2259.                 }

  2260.             }

  2261. 

  2262.             static void cameraCaptureSessionConfigureFailedCallback (JNIEnv*, jobject, jlong host, jobject rawSession)

  2263.             {

  2264.                 if (auto* myself = reinterpret_cast<CaptureSession*> (host))

  2265.                 {

  2266.                     LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2267. 

  2268.                     myself->cameraCaptureSessionConfigureFailed (session);

  2269.                 }

  2270.             }

  2271. 

  2272.             static void cameraCaptureSessionConfiguredCallback (JNIEnv*, jobject, jlong host, jobject rawSession)

  2273.             {

  2274.                 if (auto* myself = reinterpret_cast<CaptureSession*> (host))

  2275.                 {

  2276.                     LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2277. 

  2278.                     myself->cameraCaptureSessionConfigured (session);

  2279.                 }

  2280.             }

  2281. 

  2282.             static void cameraCaptureSessionReadyCallback (JNIEnv*, jobject, jlong host, jobject rawSession)

  2283.             {

  2284.                 if (auto* myself = reinterpret_cast<CaptureSession*> (host))

  2285.                 {

  2286.                     LocalRef<jobject> session (getEnv()->NewLocalRef(rawSession));

  2287. 

  2288.                     myself->cameraCaptureSessionReady (session);

  2289.                 }

  2290.             }

  2291. 

  2292.             //==============================================================================

  2293.             friend class ScopedCameraDevice;

  2294. 

  2295.             JUCE_DECLARE_NON_COPYABLE (CaptureSession)

  2296.         };

  2297. 

  2298.         //==============================================================================

  2299.         ScopedCameraDevice (Pimpl& ownerToUse, const String& cameraIdToUse, GlobalRef& cameraManagerToUse,

  2300.                             GlobalRef& handlerToUse, int autoFocusModeToUse)

  2301.             : owner (ownerToUse),

  2302.               cameraId (cameraIdToUse),

  2303.               cameraManager (cameraManagerToUse),

  2304.               handler (handlerToUse),

  2305.               cameraStateCallback (createCameraStateCallbackObject()),

  2306.               autoFocusMode (autoFocusModeToUse)

  2307.         {

  2308.             open();

  2309.         }

  2310. 

  2311.         ~ScopedCameraDevice()

  2312.         {

  2313.             close();

  2314.         }

  2315. 

  2316.         void open()

  2317.         {

  2318.             pendingOpen.set (1);

  2319. 

  2320.             auto* env = getEnv();

  2321. 

  2322.             env->CallVoidMethod (cameraManager, CameraManager.openCamera,

  2323.                                  javaString (cameraId).get(),

  2324.                                  cameraStateCallback.get(), handler.get());

  2325. 

  2326.             // If something went wrong we will be pinged in cameraDeviceStateError()

  2327.             // callback, silence the redundant exception.

  2328.             jniCheckHasExceptionOccurredAndClear();

  2329.         }

  2330. 

  2331.         void close()

  2332.         {

  2333.             if (pendingClose.compareAndSetBool (1, 0))

  2334.             {

  2335.                 auto* env = getEnv();

  2336. 

  2337.                 if (cameraDevice.get() != nullptr)

  2338.                 {

  2339.                     env->CallVoidMethod (cameraDevice, AndroidCameraDevice.close);

  2340.                     closedEvent.wait (-1);

  2341.                 }

  2342. 

  2343.                 pendingClose.set (0);

  2344.                 pendingOpen .set (0);

  2345.                 cameraDevice.clear();

  2346.             }

  2347.         }

  2348. 

  2349.         bool openedOk() const { return cameraDevice != nullptr; }

  2350. 

  2351.         bool hasErrorOccurred() const { return fatalErrorOccurred.get(); }

  2352. 

  2353.         CaptureSession* createCaptureSession (CaptureSession::ConfiguredCallback& cc,

  2354.                                               const LocalRef<jobject>& surfacesList,

  2355.                                               GlobalRef& handlerToUse,

  2356.                                               int captureSessionTemplate)

  2357.         {

  2358.             if (! openedOk())

  2359.             {

  2360.                 jassertfalse;

  2361.                 return nullptr;

  2362.             }

  2363. 

  2364.             return new CaptureSession (*this, cc, surfacesList, handlerToUse, captureSessionTemplate, autoFocusMode);

  2365.         }

  2366. 

  2367.     private:

  2368.         Pimpl& owner;

  2369.         const String cameraId;

  2370.         GlobalRef& cameraManager;

  2371.         GlobalRef& handler;

  2372. 

  2373.         GlobalRef cameraStateCallback;

  2374.         int autoFocusMode;

  2375. 

  2376.         GlobalRef cameraDevice;

  2377.         Atomic<int> pendingOpen { 0 };

  2378.         Atomic<int> pendingClose { 0 };

  2379.         Atomic<int> fatalErrorOccurred { 0 };

  2380.         String openError;

  2381. 

  2382.         WaitableEvent closedEvent;

  2383. 

  2384.         //==============================================================================

  2385.         #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK)    \

  2386.             METHOD (constructor, "<init>", "(J)V") \

  2387.             CALLBACK (cameraDeviceStateClosedCallback,       "cameraDeviceStateClosed",       "(JLandroid/hardware/camera2/CameraDevice;)V")  \

  2388.             CALLBACK (cameraDeviceStateDisconnectedCallback, "cameraDeviceStateDisconnected", "(JLandroid/hardware/camera2/CameraDevice;)V")  \

  2389.             CALLBACK (cameraDeviceStateErrorCallback,        "cameraDeviceStateError",        "(JLandroid/hardware/camera2/CameraDevice;I)V") \

  2390.             CALLBACK (cameraDeviceStateOpenedCallback,       "cameraDeviceStateOpened",       "(JLandroid/hardware/camera2/CameraDevice;)V")

  2391. 

  2392.         DECLARE_JNI_CLASS_WITH_MIN_SDK (CameraDeviceStateCallback, "com/rmsl/juce/CameraDeviceStateCallback", 21)

  2393.         #undef JNI_CLASS_MEMBERS

  2394. 

  2395.         LocalRef<jobject> createCameraStateCallbackObject()

  2396.         {

  2397.             return LocalRef<jobject> (getEnv()->NewObject (CameraDeviceStateCallback,

  2398.                                                            CameraDeviceStateCallback.constructor,

  2399.                                                            reinterpret_cast<jlong> (this)));

  2400.         }

  2401. 

  2402.         //==============================================================================

  2403.         void cameraDeviceStateClosed()

  2404.         {

  2405.             JUCE_CAMERA_LOG ("cameraDeviceStateClosed()");

  2406. 

  2407.             closedEvent.signal();

  2408.         }

  2409. 

  2410.         void cameraDeviceStateDisconnected()

  2411.         {

  2412.             JUCE_CAMERA_LOG ("cameraDeviceStateDisconnected()");

  2413. 

  2414.             if (pendingOpen.compareAndSetBool (0, 1))

  2415.             {

  2416.                 openError = "Device disconnected";

  2417. 

  2418.                 notifyOpenResult();

  2419.             }

  2420. 

  2421.             MessageManager::callAsync ([this]() { close(); });

  2422.         }

  2423. 

  2424.         void cameraDeviceStateError (int errorCode)

  2425.         {

  2426.             String error = cameraErrorCodeToString (errorCode);

  2427. 

  2428.             JUCE_CAMERA_LOG ("cameraDeviceStateError(), error: " + error);

  2429. 

  2430.             if (pendingOpen.compareAndSetBool (0, 1))

  2431.             {

  2432.                 openError = error;

  2433. 

  2434.                 notifyOpenResult();

  2435.             }

  2436. 

  2437.             fatalErrorOccurred.set (1);

  2438. 

  2439.             MessageManager::callAsync ([this, error]()

  2440.                                        {

  2441.                                            owner.cameraDeviceError (error);

  2442.                                            close();

  2443.                                        });

  2444.         }

  2445. 

  2446.         void cameraDeviceStateOpened (const LocalRef<jobject>& cameraDeviceToUse)

  2447.         {

  2448.             JUCE_CAMERA_LOG ("cameraDeviceStateOpened()");

  2449. 

  2450.             pendingOpen.set (0);

  2451. 

  2452.             cameraDevice = GlobalRef (cameraDeviceToUse);

  2453. 

  2454.             notifyOpenResult();

  2455.         }

  2456. 

  2457.         void notifyOpenResult()

  2458.         {

  2459.             MessageManager::callAsync ([this]() { owner.cameraOpenFinished (openError); });

  2460.         }

  2461. 

  2462.         //==============================================================================

  2463.         static void JNICALL cameraDeviceStateClosedCallback (JNIEnv*, jobject, jlong host, jobject)

  2464.         {

  2465.             if (auto* myself = reinterpret_cast<ScopedCameraDevice*>(host))

  2466.                 myself->cameraDeviceStateClosed();

  2467.         }

  2468. 

  2469.         static void JNICALL cameraDeviceStateDisconnectedCallback (JNIEnv*, jobject, jlong host, jobject)

  2470.         {

  2471.             if (auto* myself = reinterpret_cast<ScopedCameraDevice*>(host))

  2472.                 myself->cameraDeviceStateDisconnected();

  2473.         }

  2474. 

  2475.         static void JNICALL cameraDeviceStateErrorCallback (JNIEnv*, jobject, jlong host, jobject, jint error)

  2476.         {

  2477.             if (auto* myself = reinterpret_cast<ScopedCameraDevice*>(host))

  2478.                 myself->cameraDeviceStateError (error);

  2479.         }

  2480. 

  2481.         static void JNICALL cameraDeviceStateOpenedCallback (JNIEnv*, jobject, jlong host, jobject rawCamera)

  2482.         {

  2483.             if (auto* myself = reinterpret_cast<ScopedCameraDevice*>(host))

  2484.             {

  2485.                 LocalRef<jobject> camera(getEnv()->NewLocalRef(rawCamera));

  2486. 

  2487.                 myself->cameraDeviceStateOpened (camera);

  2488.             }

  2489.         }

  2490.     };

  2491. 

  2492.     //==============================================================================

  2493.     struct CaptureSessionModeBase

  2494.     {

  2495.         virtual ~CaptureSessionModeBase() = default;

  2496. 

  2497.         virtual bool isVideoRecordSession() const = 0;

  2498. 

  2499.         virtual void triggerStillPictureCapture() = 0;

  2500.     };

  2501. 

  2502.     //==============================================================================

  2503.     template <typename Mode>

  2504.     struct CaptureSessionMode   : public CaptureSessionModeBase,

  2505.                                   private PreviewDisplay::Listener,

  2506.                                   private ScopedCameraDevice::CaptureSession::ConfiguredCallback

  2507.     {

  2508.         ~CaptureSessionMode() override

  2509.         {

  2510.             captureSession.reset();

  2511. 

  2512.             previewDisplay.removeListener (this);

  2513.         }

  2514. 

  2515.         bool isVideoRecordSession() const override

  2516.         {

  2517.             return Mode::isVideoRecord();

  2518.         }

  2519. 

  2520.         void triggerStillPictureCapture() override

  2521.         {

  2522.             if (captureSession == nullptr)

  2523.             {

  2524.                 // The capture session must be ready before taking a still picture.

  2525.                 // Did you remember to create and show a preview display?

  2526.                 jassertfalse;

  2527.                 return;

  2528.             }

  2529. 

  2530.             crtp().takeStillPicture();

  2531.         }

  2532. 

  2533.     protected:

  2534.         CaptureSessionMode (Pimpl& ownerToUse, ScopedCameraDevice& cameraDeviceToUse,

  2535.                             GlobalRef& handlerToUse, PreviewDisplay& pd, int cameraSensorOrientationToUse,

  2536.                             int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

  2537.             : owner (ownerToUse),

  2538.               scopedCameraDevice (cameraDeviceToUse),

  2539.               handler (handlerToUse),

  2540.               previewDisplay (pd),

  2541.               cameraSensorOrientation (cameraSensorOrientationToUse),

  2542.               cameraLensFacing (cameraLensFacingToUse),

  2543.               streamConfigurationMap (streamConfigurationMapToUse)

  2544.         {

  2545.             WeakReference<CaptureSessionMode<Mode>> weakRef (this);

  2546. 

  2547.             if (weakRef == nullptr)

  2548.                 return;

  2549. 

  2550.             // async so that the object is fully constructed before the callback gets invoked

  2551.             MessageManager::callAsync ([this, weakRef]()

  2552.             {

  2553.                 if (weakRef == nullptr)

  2554.                     return;

  2555. 

  2556.                 previewDisplay.addListener (this);

  2557.             });

  2558.         }

  2559. 

  2560.         Mode& crtp() { return static_cast<Mode&> (*this); }

  2561. 

  2562.         void previewDisplayReady() override

  2563.         {

  2564.             jassert (previewDisplay.isReady());

  2565. 

  2566.             JUCE_CAMERA_LOG ("previewDisplayReady()");

  2567. 

  2568.             // close previous capture session first

  2569.             captureSession.reset();

  2570. 

  2571.             if (scopedCameraDevice.hasErrorOccurred())

  2572.             {

  2573.                 JUCE_CAMERA_LOG ("Device error detected, not recreating a new camera session. The device needs to be reopened.");

  2574.                 return;

  2575.             }

  2576. 

  2577.             captureSession.reset (scopedCameraDevice.createCaptureSession (*this, crtp().getCaptureSessionSurfaces(),

  2578.                                                                            handler, Mode::getTemplate()));

  2579.         }

  2580. 

  2581.         void previewDisplayAboutToBeDestroyed() override

  2582.         {

  2583.             JUCE_CAMERA_LOG ("previewDisplayAboutToBeDestroyed()");

  2584. 

  2585.             stopPreview();

  2586.         }

  2587. 

  2588.         void captureSessionConfigured (ScopedCameraDevice::CaptureSession* session) override

  2589.         {

  2590.             if (session == nullptr)

  2591.             {

  2592.                 owner.cameraDeviceError ("Failed to configure camera session.");

  2593.                 return;

  2594.             }

  2595. 

  2596.             jassert (session == captureSession.get());

  2597. 

  2598.             startSession();

  2599.         }

  2600. 

  2601.         void startSession()

  2602.         {

  2603.             if (! captureSession->start (crtp().getTargetSurfaces(), handler))

  2604.             {

  2605.                 jassertfalse;

  2606.                 JUCE_CAMERA_LOG ("Could not start capture session");

  2607.             }

  2608. 

  2609.             crtp().sessionStarted();

  2610.         }

  2611. 

  2612.         void stopPreview()

  2613.         {

  2614.             if (captureSession != nullptr)

  2615.             {

  2616.                 auto session = captureSession->getNativeSession();

  2617. 

  2618.                 auto* env = getEnv();

  2619. 

  2620.                 env->CallVoidMethod (session, CameraCaptureSession.stopRepeating);

  2621. 

  2622.                 if (jniCheckHasExceptionOccurredAndClear())

  2623.                     return;

  2624. 

  2625.                 env->CallVoidMethod (session, CameraCaptureSession.abortCaptures);

  2626. 

  2627.                 jniCheckHasExceptionOccurredAndClear();

  2628.             }

  2629.         }

  2630. 

  2631.         Pimpl& owner;

  2632.         ScopedCameraDevice& scopedCameraDevice;

  2633.         GlobalRef& handler;

  2634.         PreviewDisplay& previewDisplay;

  2635.         int cameraSensorOrientation;

  2636.         int cameraLensFacing;

  2637.         StreamConfigurationMap& streamConfigurationMap;

  2638. 

  2639.         std::unique_ptr<ScopedCameraDevice::CaptureSession> captureSession;

  2640. 

  2641.         JUCE_DECLARE_WEAK_REFERENCEABLE (CaptureSessionMode<Mode>)

  2642.     };

  2643. 

  2644.     //==============================================================================

  2645.     struct CaptureSessionPreviewMode : public CaptureSessionMode<CaptureSessionPreviewMode>

  2646.     {

  2647.         CaptureSessionPreviewMode (Pimpl& ownerToUse, ScopedCameraDevice& cameraDeviceToUse, GlobalRef& handlerToUse,

  2648.                                    PreviewDisplay& pd, ImageReader& ir, int sensorOrientation,

  2649.                                    int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

  2650.             : CaptureSessionMode<CaptureSessionPreviewMode> (ownerToUse, cameraDeviceToUse, handlerToUse, pd,

  2651.                                                              sensorOrientation, cameraLensFacingToUse, streamConfigurationMapToUse),

  2652.               imageReader (ir)

  2653.         {

  2654.         }

  2655. 

  2656.         // Surfaces passed to newly created capture session.

  2657.         LocalRef<jobject> getCaptureSessionSurfaces() const

  2658.         {

  2659.             auto* env = getEnv();

  2660. 

  2661.             auto previewSurface = LocalRef<jobject> (previewDisplay.createSurface());

  2662.             auto imageSurface = LocalRef<jobject> (imageReader.getSurface());

  2663. 

  2664.             auto arrayList = LocalRef<jobject> (env->NewObject (JavaArrayList, JavaArrayList.constructor, 2));

  2665.             env->CallBooleanMethod (arrayList, JavaArrayList.add, previewSurface.get());

  2666.             env->CallBooleanMethod (arrayList, JavaArrayList.add, imageSurface.get());

  2667. 

  2668.             auto supported = streamConfigurationMap.isOutputSupportedForSurface (imageSurface);

  2669. 

  2670.             // Output surface is not supported by this device, still image capture will not work!

  2671.             jassert (supported);

  2672. 

  2673.             return arrayList;

  2674.         }

  2675. 

  2676.         // Surfaces set as target during capture.

  2677.         LocalRef<jobject> getTargetSurfaces() const

  2678.         {

  2679.             auto* env = getEnv();

  2680. 

  2681.             auto previewSurface = LocalRef<jobject> (previewDisplay.createSurface());

  2682. 

  2683.             auto arrayList = LocalRef<jobject> (env->NewObject (JavaArrayList, JavaArrayList.constructor, 1));

  2684.             env->CallBooleanMethod (arrayList, JavaArrayList.add, previewSurface.get());

  2685. 

  2686.             return arrayList;

  2687.         }

  2688. 

  2689.         static int getTemplate()

  2690.         {

  2691.             static constexpr int templatePreview = 1;

  2692.             return templatePreview;

  2693.         }

  2694. 

  2695.         static bool isVideoRecord() { return false; }

  2696. 

  2697.         void sessionStarted() {}

  2698. 

  2699.         void takeStillPicture()

  2700.         {

  2701.             imageReader.resetNotificationFlag();

  2702.             captureSession->takeStillPicture (imageReader.getSurface());

  2703.         }

  2704. 

  2705.     private:

  2706.         ImageReader& imageReader;

  2707.     };

  2708. 

  2709.     //==============================================================================

  2710.     struct CaptureSessionVideoRecordingMode : public CaptureSessionMode<CaptureSessionVideoRecordingMode>

  2711.     {

  2712.         CaptureSessionVideoRecordingMode (Pimpl& ownerToUse, ScopedCameraDevice& cameraDeviceToUse, GlobalRef& handlerToUse,

  2713.                                           PreviewDisplay& pd, MediaRecorder& mr, int sensorOrientation,

  2714.                                           int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

  2715.             : CaptureSessionMode<CaptureSessionVideoRecordingMode> (ownerToUse, cameraDeviceToUse, handlerToUse, pd,

  2716.                                                                     sensorOrientation, cameraLensFacingToUse, streamConfigurationMapToUse),

  2717.               mediaRecorder (mr)

  2718.         {

  2719.         }

  2720. 

  2721.         ~CaptureSessionVideoRecordingMode()

  2722.         {

  2723.             // We need to explicitly stop the preview before stopping the media recorder,

  2724.             // because legacy devices can't handle recording stop before stopping the preview.

  2725.             stopPreview();

  2726. 

  2727.             mediaRecorder.stop();

  2728.         }

  2729. 

  2730.         // Surfaces passed to newly created capture session.

  2731.         LocalRef<jobject> getCaptureSessionSurfaces() const

  2732.         {

  2733.             auto* env = getEnv();

  2734. 

  2735.             auto previewSurface = LocalRef<jobject> (previewDisplay.createSurface());

  2736.             auto mediaRecorderSurface = LocalRef<jobject> (mediaRecorder.getSurface());

  2737. 

  2738.             auto arrayList = LocalRef<jobject> (env->NewObject (JavaArrayList, JavaArrayList.constructor, 2));

  2739.             env->CallBooleanMethod (arrayList, JavaArrayList.add, previewSurface.get());

  2740.             env->CallBooleanMethod (arrayList, JavaArrayList.add, mediaRecorderSurface.get());

  2741. 

  2742.             return arrayList;

  2743.         }

  2744. 

  2745.         // Surfaces set as target during capture.

  2746.         LocalRef<jobject> getTargetSurfaces() const

  2747.         {

  2748.             // Same surfaces used.

  2749.             return getCaptureSessionSurfaces();

  2750.         }

  2751. 

  2752.         static int getTemplate()

  2753.         {

  2754.             static constexpr int templateRecord = 3;

  2755.             return templateRecord;

  2756.         }

  2757. 

  2758.         static bool isVideoRecord() { return true; }

  2759. 

  2760.         void sessionStarted()

  2761.         {

  2762.             MessageManager::callAsync ([this]() { mediaRecorder.start(); });

  2763.         }

  2764. 

  2765.         void takeStillPicture()

  2766.         {

  2767.             // Taking still pictures while recording video is not supported on Android.

  2768.             jassertfalse;

  2769.         }

  2770. 

  2771.     private:

  2772.         MediaRecorder& mediaRecorder;

  2773.     };

  2774. 

  2775.     //==============================================================================

  2776.     class DeviceOrientationChangeListener   : private Timer

  2777.     {

  2778.     public:

  2779.         DeviceOrientationChangeListener (PreviewDisplay& pd)

  2780.             : previewDisplay (pd),

  2781.               orientationEventListener (createOrientationEventListener()),

  2782.               canDetectChange (getEnv()->CallBooleanMethod (orientationEventListener,

  2783.                                                             OrientationEventListener.canDetectOrientation) != 0),

  2784.               deviceOrientation (Desktop::getInstance().getCurrentOrientation()),

  2785.               lastKnownScreenOrientation (deviceOrientation)

  2786.         {

  2787.             setEnabled (true);

  2788.         }

  2789. 

  2790.         ~DeviceOrientationChangeListener() override

  2791.         {

  2792.             setEnabled (false);

  2793.         }

  2794. 

  2795.         void setEnabled (bool shouldBeEnabled)

  2796.         {

  2797.             if (shouldBeEnabled && ! canDetectChange)

  2798.             {

  2799.                 // This device does not support orientation listening, photos may have wrong orientation!

  2800.                 jassertfalse;

  2801.                 return;

  2802.             }

  2803. 

  2804.             if (shouldBeEnabled)

  2805.                 getEnv()->CallVoidMethod (orientationEventListener, OrientationEventListener.enable);

  2806.             else

  2807.                 getEnv()->CallVoidMethod (orientationEventListener, OrientationEventListener.disable);

  2808.         }

  2809. 

  2810.         bool isSupported() const noexcept { return canDetectChange; }

  2811. 

  2812.         Desktop::DisplayOrientation getDeviceOrientation() const noexcept

  2813.         {

  2814.             return deviceOrientation;

  2815.         }

  2816. 

  2817.     private:

  2818.         PreviewDisplay& previewDisplay;

  2819. 

  2820.         GlobalRef orientationEventListener;

  2821.         static constexpr jint sensorDelayUI = 2;

  2822. 

  2823.         bool canDetectChange;

  2824.         Desktop::DisplayOrientation deviceOrientation;

  2825. 

  2826.         Desktop::DisplayOrientation lastKnownScreenOrientation;

  2827.         int numChecksForOrientationChange = 10;

  2828. 

  2829.         //==============================================================================

  2830.         #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  2831.             METHOD (canDetectOrientation, "canDetectOrientation", "()Z") \

  2832.             METHOD (constructor,          "<init>",               "(JLandroid/content/Context;I)V") \

  2833.             METHOD (disable,              "disable",              "()V") \

  2834.             METHOD (enable,               "enable",               "()V") \

  2835.             CALLBACK (deviceOrientationChanged, "deviceOrientationChanged", "(JI)V")

  2836. 

  2837.         DECLARE_JNI_CLASS_WITH_MIN_SDK (OrientationEventListener, "com/rmsl/juce/JuceOrientationEventListener", 21)

  2838.         #undef JNI_CLASS_MEMBERS

  2839. 

  2840.         LocalRef<jobject> createOrientationEventListener()

  2841.         {

  2842.             return LocalRef<jobject> (getEnv()->NewObject (OrientationEventListener,

  2843.                                                            OrientationEventListener.constructor,

  2844.                                                            reinterpret_cast<jlong> (this),

  2845.                                                            getAppContext().get(),

  2846.                                                            sensorDelayUI));

  2847.         }

  2848. 

  2849.         //==============================================================================

  2850.         void orientationChanged (int orientation)

  2851.         {

  2852.             jassert (orientation < 360);

  2853. 

  2854.             // -1 == unknown

  2855.             if (orientation < 0)

  2856.                 return;

  2857. 

  2858.             auto oldOrientation = deviceOrientation;

  2859. 

  2860.             // NB: this assumes natural position to be portrait always, but some devices may be landscape...

  2861.             if (orientation > (360 - 45) || orientation < 45)

  2862.                 deviceOrientation = Desktop::upright;

  2863.             else if (orientation < 135)

  2864.                 deviceOrientation = Desktop::rotatedClockwise;

  2865.             else if (orientation < 225)

  2866.                 deviceOrientation = Desktop::upsideDown;

  2867.             else

  2868.                 deviceOrientation = Desktop::rotatedAntiClockwise;

  2869. 

  2870.             if (oldOrientation != deviceOrientation)

  2871.             {

  2872.                 lastKnownScreenOrientation = Desktop::getInstance().getCurrentOrientation();

  2873. 

  2874.                 // Need to update preview transform, but screen orientation will change slightly

  2875.                 // later than sensor orientation.

  2876.                 startTimer (500);

  2877.             }

  2878.         }

  2879. 

  2880.         void timerCallback() override

  2881.         {

  2882.             auto currentOrientation = Desktop::getInstance().getCurrentOrientation();

  2883. 

  2884.             if (lastKnownScreenOrientation != currentOrientation)

  2885.             {

  2886.                 lastKnownScreenOrientation = currentOrientation;

  2887. 

  2888.                 stopTimer();

  2889.                 numChecksForOrientationChange = 10;

  2890.                 previewDisplay.updateSurfaceTransform();

  2891. 

  2892.                 return;

  2893.             }

  2894. 

  2895.             if (--numChecksForOrientationChange == 0)

  2896.             {

  2897.                 stopTimer();

  2898.                 numChecksForOrientationChange = 10;

  2899.             }

  2900.         }

  2901. 

  2902.         static void deviceOrientationChanged (JNIEnv*, jobject /*obj*/, jlong host, jint orientation)

  2903.         {

  2904.             if (auto* myself = reinterpret_cast<DeviceOrientationChangeListener*> (host))

  2905.                 myself->orientationChanged (orientation);

  2906.         }

  2907.     };

  2908. 

  2909.     //==============================================================================

  2910.     CameraDevice& owner;

  2911.     int minWidth, minHeight, maxWidth, maxHeight;

  2912. 

  2913.     String cameraId;

  2914.     InternalOpenCameraResultCallback cameraOpenCallback;

  2915. 

  2916.     GlobalRef activityLifeListener;

  2917. 

  2918.     GlobalRef cameraManager;

  2919.     GlobalRef cameraCharacteristics;

  2920.     GlobalRef handlerThread;

  2921.     GlobalRef handler;

  2922. 

  2923.     StreamConfigurationMap streamConfigurationMap;

  2924.     PreviewDisplay previewDisplay;

  2925.     DeviceOrientationChangeListener deviceOrientationChangeListener;

  2926.     std::unique_ptr<ImageReader> imageReader;

  2927.     std::unique_ptr<MediaRecorder> mediaRecorder;

  2928. 

  2929.     std::unique_ptr<CaptureSessionModeBase> currentCaptureSessionMode;

  2930. 

  2931.     std::unique_ptr<ScopedCameraDevice> scopedCameraDevice;

  2932. 

  2933.     CriticalSection listenerLock;

  2934.     ListenerList<Listener> listeners;

  2935. 

  2936.     std::function<void (const Image&)> pictureTakenCallback;

  2937. 

  2938.     Time firstRecordedFrameTimeMs;

  2939.     bool notifiedOfCameraOpening = false;

  2940. 

  2941.     bool appWasPaused = false;

  2942. 

  2943.     //==============================================================================

  2944.     int getCameraSensorOrientation() const

  2945.     {

  2946.         return getCameraCharacteristicsIntegerKeyValue (CameraCharacteristics.SENSOR_ORIENTATION);

  2947.     }

  2948. 

  2949.     int getAutoFocusModeToUse() const

  2950.     {

  2951.         auto supportedModes = getSupportedAutoFocusModes();

  2952. 

  2953.         enum

  2954.         {

  2955.             CONTROL_AF_MODE_OFF = 0,

  2956.             CONTROL_AF_MODE_AUTO = 1,

  2957.             CONTROL_AF_MODE_CONTINUOUS_PICTURE = 4

  2958.         };

  2959. 

  2960.         if (supportedModes.contains (CONTROL_AF_MODE_CONTINUOUS_PICTURE))

  2961.             return CONTROL_AF_MODE_CONTINUOUS_PICTURE;

  2962. 

  2963.         if (supportedModes.contains (CONTROL_AF_MODE_AUTO))

  2964.             return CONTROL_AF_MODE_AUTO;

  2965. 

  2966.         return CONTROL_AF_MODE_OFF;

  2967.     }

  2968. 

  2969.     Array<int> getSupportedAutoFocusModes() const

  2970.     {

  2971.         auto* env = getEnv();

  2972. 

  2973.         auto jKey = LocalRef<jobject> (env->GetStaticObjectField (CameraCharacteristics, CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES));

  2974. 

  2975.         auto supportedModes = LocalRef<jintArray> ((jintArray) env->CallObjectMethod (cameraCharacteristics,

  2976.                                                                                       CameraCharacteristics.get,

  2977.                                                                                       jKey.get()));

  2978. 

  2979.         return jintArrayToJuceArray (supportedModes);

  2980.     }

  2981. 

  2982.     static Array<int> jintArrayToJuceArray (const LocalRef<jintArray>& jArray)

  2983.     {

  2984.         auto* env = getEnv();

  2985. 

  2986.         auto* jArrayElems = env->GetIntArrayElements (jArray, nullptr);

  2987.         auto numElems = env->GetArrayLength (jArray);

  2988. 

  2989.         Array<int> juceArray;

  2990. 

  2991.         for (int s = 0; s < numElems; ++s)

  2992.             juceArray.add (jArrayElems[s]);

  2993. 

  2994.         env->ReleaseIntArrayElements (jArray, jArrayElems, 0);

  2995.         return juceArray;

  2996.     }

  2997. 

  2998.     int getCameraCharacteristicsIntegerKeyValue (jfieldID key) const

  2999.     {

  3000.         auto* env = getEnv();

  3001. 

  3002.         auto jKey = LocalRef<jobject> (env->GetStaticObjectField (CameraCharacteristics, key));

  3003. 

  3004.         auto jValue = LocalRef<jobject> (env->CallObjectMethod (cameraCharacteristics,

  3005.                                                                 CameraCharacteristics.get,

  3006.                                                                 jKey.get()));

  3007. 

  3008.         return env->CallIntMethod (jValue, JavaInteger.intValue);

  3009.     }

  3010. 

  3011.     int getCameraLensFacing() const

  3012.     {

  3013.         return getCameraCharacteristicsIntegerKeyValue (CameraCharacteristics.LENS_FACING);

  3014.     }

  3015. 

  3016.     //==============================================================================

  3017.     void cameraOpenFinished (const String& error)

  3018.     {

  3019.         JUCE_CAMERA_LOG ("cameraOpenFinished(), error = " + error);

  3020. 

  3021.         if (error.isEmpty())

  3022.         {

  3023.             setupStillImageSize();

  3024.             startPreviewMode (*imageReader);

  3025.         }

  3026. 

  3027.         // Do not notify about camera being reopened on app resume.

  3028.         if (! notifiedOfCameraOpening)

  3029.         {

  3030.             notifiedOfCameraOpening = true;

  3031. 

  3032.             invokeCameraOpenCallback (error);

  3033.         }

  3034.     }

  3035. 

  3036.     void cameraDeviceError (const String& error)

  3037.     {

  3038.         if (owner.onErrorOccurred != nullptr)

  3039.             owner.onErrorOccurred (error);

  3040.     }

  3041. 

  3042.     void invokeCameraOpenCallback (const String& error)

  3043.     {

  3044.         JUCE_CAMERA_LOG ("invokeCameraOpenCallback(), error = " + error);

  3045. 

  3046.         if (cameraOpenCallback != nullptr)

  3047.             cameraOpenCallback (cameraId, error);

  3048.     }

  3049. 

  3050.     //==============================================================================

  3051.     void callListeners (const Image& image)

  3052.     {

  3053.         const ScopedLock sl (listenerLock);

  3054.         listeners.call ([=] (Listener& l) { l.imageReceived (image); });

  3055.     }

  3056. 

  3057.     void notifyPictureTaken (const Image& image)

  3058.     {

  3059.         JUCE_CAMERA_LOG ("notifyPictureTaken()");

  3060. 

  3061.         if (pictureTakenCallback != nullptr)

  3062.             pictureTakenCallback (image);

  3063.     }

  3064. 

  3065.     void triggerStillPictureCapture()

  3066.     {

  3067.         currentCaptureSessionMode->triggerStillPictureCapture();

  3068.     }

  3069. 

  3070.     //==============================================================================

  3071.     void setupStillImageSize()

  3072.     {

  3073.         imageReader.reset();

  3074. 

  3075.         auto imageSize = chooseBestSize (minWidth, minHeight, maxWidth, maxHeight,

  3076.                                          streamConfigurationMap.getSupportedStillImageOutputSizes());

  3077. 

  3078.         imageReader.reset (new ImageReader (*this, handler, imageSize.getWidth(), imageSize.getHeight(),

  3079.                                             getCameraSensorOrientation()));

  3080.     }

  3081. 

  3082.     static Rectangle<int> chooseBestSize (int minWidth, int minHeight, int maxWidth, int maxHeight,

  3083.                                           Array<Rectangle<int>> supportedSizes)

  3084.     {

  3085.         Rectangle<int> result;

  3086. 

  3087.         for (auto& size : supportedSizes)

  3088.         {

  3089.             auto width  = size.getWidth();

  3090.             auto height = size.getHeight();

  3091. 

  3092.             if (width < minWidth || width > maxWidth || height < minHeight || height > maxHeight)

  3093.                 continue;

  3094. 

  3095.             if (size.contains (result))

  3096.                 result = size;

  3097.         }

  3098. 

  3099.         // None of the supported sizes matches required width & height limitations, picking

  3100.         // the first one available...

  3101.         jassert (! result.isEmpty());

  3102. 

  3103.         if (result.isEmpty())

  3104.             result = supportedSizes[0];

  3105. 

  3106.         return result;

  3107.     }

  3108. 

  3109.     //==============================================================================

  3110.     void startPreviewMode (ImageReader& ir)

  3111.     {

  3112.         if (currentCaptureSessionMode != nullptr && ! currentCaptureSessionMode->isVideoRecordSession())

  3113.             return;

  3114. 

  3115.         // previous mode has to be stopped first

  3116.         jassert (currentCaptureSessionMode.get() == nullptr);

  3117. 

  3118.         if (scopedCameraDevice == nullptr || ! scopedCameraDevice->openedOk())

  3119.             return;

  3120. 

  3121.         currentCaptureSessionMode.reset (new CaptureSessionPreviewMode (*this, *scopedCameraDevice, handler,

  3122.                                                                         previewDisplay, ir,

  3123.                                                                         getCameraSensorOrientation(),

  3124.                                                                         getCameraLensFacing(),

  3125.                                                                         streamConfigurationMap));

  3126.     }

  3127. 

  3128.     void startVideoRecordingMode (MediaRecorder& mr)

  3129.     {

  3130.         if (currentCaptureSessionMode != nullptr && currentCaptureSessionMode->isVideoRecordSession())

  3131.             return;

  3132. 

  3133.         // previous mode has to be stopped first

  3134.         jassert (currentCaptureSessionMode.get() == nullptr);

  3135. 

  3136.         jassert (scopedCameraDevice != nullptr && scopedCameraDevice->openedOk());

  3137. 

  3138.         if (scopedCameraDevice == nullptr || ! scopedCameraDevice->openedOk())

  3139.             return;

  3140. 

  3141.         currentCaptureSessionMode.reset (new CaptureSessionVideoRecordingMode (*this, *scopedCameraDevice, handler,

  3142.                                                                                previewDisplay, mr,

  3143.                                                                                getCameraSensorOrientation(),

  3144.                                                                                getCameraLensFacing(),

  3145.                                                                                streamConfigurationMap));

  3146.     }

  3147. 

  3148.     //==============================================================================

  3149.     void onActivityPaused (jobject) override

  3150.     {

  3151.         JUCE_CAMERA_LOG ("appPaused, closing camera...");

  3152. 

  3153.         appWasPaused = true;

  3154. 

  3155.         deviceOrientationChangeListener.setEnabled (false);

  3156. 

  3157.         // We need to restart the whole session mode when the app gets resumed.

  3158.         currentCaptureSessionMode.reset();

  3159. 

  3160.         if (scopedCameraDevice != nullptr)

  3161.             scopedCameraDevice->close();

  3162. 

  3163.         stopBackgroundThread();

  3164.     }

  3165. 

  3166.     void onActivityResumed (jobject) override

  3167.     {

  3168.         // Only care about resumed event when paused event was called first.

  3169.         if (! appWasPaused)

  3170.             return;

  3171. 

  3172.         JUCE_CAMERA_LOG ("appResumed, opening camera...");

  3173. 

  3174.         deviceOrientationChangeListener.setEnabled (true);

  3175. 

  3176.         startBackgroundThread();

  3177. 

  3178.         if (scopedCameraDevice != nullptr)

  3179.             scopedCameraDevice->open();

  3180.     }

  3181. 

  3182.     void startBackgroundThread()

  3183.     {

  3184.         auto* env = getEnv();

  3185. 

  3186.         handlerThread = GlobalRef (LocalRef<jobject> (env->NewObject (AndroidHandlerThread,

  3187.                                                                       AndroidHandlerThread.constructor,

  3188.                                                                       javaString ("JuceCameraDeviceBackgroundThread").get())));

  3189.         // handler thread has to be started before its looper can be fetched

  3190.         env->CallVoidMethod (handlerThread, AndroidHandlerThread.start);

  3191.         handler = GlobalRef (LocalRef<jobject> (env->NewObject (AndroidHandler,

  3192.                                                                 AndroidHandler.constructorWithLooper,

  3193.                                                                 env->CallObjectMethod (handlerThread, AndroidHandlerThread.getLooper))));

  3194.     }

  3195. 

  3196.     void stopBackgroundThread()

  3197.     {

  3198.         auto* env = getEnv();

  3199. 

  3200.         auto quitSafelyMethod = env->GetMethodID(AndroidHandlerThread, "quitSafely", "()Z");

  3201. 

  3202.         // this code will only run on SDK >= 21

  3203.         jassert(quitSafelyMethod != nullptr);

  3204. 

  3205.         env->CallBooleanMethod (handlerThread, quitSafelyMethod);

  3206.         env->CallVoidMethod (handlerThread, AndroidHandlerThread.join);

  3207. 

  3208.         jniCheckHasExceptionOccurredAndClear();

  3209. 

  3210.         handlerThread.clear();

  3211.         handler.clear();

  3212.     }

  3213. 

  3214.     friend struct CameraDevice::ViewerComponent;

  3215. 

  3216.     JUCE_DECLARE_NON_COPYABLE (Pimpl)

  3217. };

  3218. 

  3219. //==============================================================================

  3220. struct CameraDevice::ViewerComponent  : public Component,

  3221.                                         private ComponentMovementWatcher

  3222. {

  3223.     ViewerComponent (CameraDevice& device) : ComponentMovementWatcher (this)

  3224.     {

  3225.         auto previewSize = device.pimpl->streamConfigurationMap.getDefaultPreviewSize();

  3226. 

  3227.         targetAspectRatio = previewSize.getWidth() / (float) previewSize.getHeight();

  3228. 

  3229.         if (isOrientationLandscape())

  3230.             setBounds (previewSize);

  3231.         else

  3232.             setBounds (0, 0, previewSize.getHeight(), previewSize.getWidth());

  3233. 

  3234.         addAndMakeVisible (viewerComponent);

  3235.         viewerComponent.setView (device.pimpl->previewDisplay.getNativeView());

  3236.     }

  3237. 

  3238. private:

  3239.     AndroidViewComponent viewerComponent;

  3240. 

  3241.     float targetAspectRatio = 1.0f;

  3242. 

  3243.     void componentMovedOrResized (bool, bool) override

  3244.     {

  3245.         auto b = getLocalBounds();

  3246. 

  3247.         auto targetWidth  = b.getWidth();

  3248.         auto targetHeight = b.getHeight();

  3249. 

  3250.         if (isOrientationLandscape())

  3251.         {

  3252.             auto currentAspectRatio = b.getWidth() / (float) b.getHeight();

  3253. 

  3254.             if (currentAspectRatio > targetAspectRatio)

  3255.                 targetWidth = static_cast<int> (targetWidth * targetAspectRatio / currentAspectRatio);

  3256.             else

  3257.                 targetHeight = static_cast<int> (targetHeight * currentAspectRatio / targetAspectRatio);

  3258.         }

  3259.         else

  3260.         {

  3261.             auto currentAspectRatio = b.getHeight() / (float) b.getWidth();

  3262. 

  3263.             if (currentAspectRatio > targetAspectRatio)

  3264.                 targetHeight = static_cast<int> (targetHeight * targetAspectRatio / currentAspectRatio);

  3265.             else

  3266.                 targetWidth = static_cast<int> (targetWidth * currentAspectRatio / targetAspectRatio);

  3267.         }

  3268. 

  3269.         viewerComponent.setBounds (Rectangle<int> (0, 0, targetWidth, targetHeight).withCentre (b.getCentre()));

  3270.     }

  3271. 

  3272.     bool isOrientationLandscape() const

  3273.     {

  3274.         auto o = Desktop::getInstance().getCurrentOrientation();

  3275.         return o == Desktop::rotatedClockwise || o == Desktop::rotatedAntiClockwise;

  3276.     }

  3277. 

  3278.     void componentPeerChanged() override {}

  3279.     void componentVisibilityChanged() override {}

  3280. 

  3281.     JUCE_DECLARE_NON_COPYABLE (ViewerComponent)

  3282. };

  3283. 

  3284. String CameraDevice::getFileExtension()

  3285. {

  3286.     return ".mp4";

  3287. }

  3288. 

  3289. //==============================================================================

  3290. CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::StillPictureTaker::CameraCaptureSessionCaptureCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::StillPictureTaker::CameraCaptureSessionCaptureCallback;

  3291. CameraDevice::Pimpl::ScopedCameraDevice::CameraDeviceStateCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CameraDeviceStateCallback;

  3292. CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::CameraCaptureSessionStateCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::CameraCaptureSessionStateCallback;

  3293. CameraDevice::Pimpl::DeviceOrientationChangeListener::OrientationEventListener_Class CameraDevice::Pimpl::DeviceOrientationChangeListener::OrientationEventListener;