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.
11016 Commits
9 Branches
3.4GB
Tree: bf51d2c076
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bf51d2c076'
${ noResults }
JUCE/modules/juce_video/native/juce_android_CameraDevice.h

3287 lines
146KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE 6 technical preview.

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

  6. 

  7.    You may use this code under the terms of the GPL v3

  8.    (see www.gnu.org/licenses).

  9. 

  10.    For this technical preview, this file is not subject to commercial licensing.

  11. 

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

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

  14.    DISCLAIMED.

  15. 

  16.   ==============================================================================

  17. */

  18. 

  19. //==============================================================================

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

  21. //

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

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

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

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

  26. //

  27. // files with min sdk version 21

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

  29. static const uint8 CameraSupportByteCode[] =

  30. {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,

  31. 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,

  32. 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,

  33. 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,

  34. 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,

  35. 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,

  36. 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,

  37. 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,

  38. 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,

  39. 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,

  40. 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,

  41. 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,

  42. 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,

  43. 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,

  44. 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,

  45. 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,

  46. 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,

  47. 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,

  48. 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,

  49. 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,

  50. 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,

  51. 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,

  52. 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,

  53. 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,

  54. 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,

  55. 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,

  56. 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,

  57. 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,

  58. 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,

  59. 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,

  60. 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,

  61. 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,

  62. 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,

  63. 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,

  64. 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,

  65. 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,

  66. 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,

  67. 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,

  68. 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,

  69. 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,

  70. 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,

  71. 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,

  72. 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,

  73. 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,

  74. 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,

  75. 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,

  76. 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,

  77. 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,

  78. 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,

  79. 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,

  80. 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,

  81. 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,

  82. 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,

  83. 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,

  84. 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,

  85. 0,0,0,0};

  86. 

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

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

  89. 

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

  91. #undef JNI_CLASS_MEMBERS

  92. 

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

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

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

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

  97. 

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

  99. #undef JNI_CLASS_MEMBERS

  100. 

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

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

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

  104. 

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

  106. #undef JNI_CLASS_MEMBERS

  107. 

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

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

  110. 

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

  112. #undef JNI_CLASS_MEMBERS

  113. 

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

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

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

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

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

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

  120. 

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

  122. #undef JNI_CLASS_MEMBERS

  123. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  143. 

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

  145. #undef JNI_CLASS_MEMBERS

  146. 

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

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

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

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

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

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

  153. 

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

  155. #undef JNI_CLASS_MEMBERS

  156. 

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

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

  159. 

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

  161. #undef JNI_CLASS_MEMBERS

  162. 

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

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

  165. 

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

  167. #undef JNI_CLASS_MEMBERS

  168. 

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

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

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

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

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

  174. 

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

  176. #undef JNI_CLASS_MEMBERS

  177. 

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

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

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

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

  182. 

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

  184. #undef JNI_CLASS_MEMBERS

  185. 

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

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

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

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

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

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

  192. 

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

  194. #undef JNI_CLASS_MEMBERS

  195. 

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

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

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

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

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

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

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

  203. 

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

  205. #undef JNI_CLASS_MEMBERS

  206. 

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

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

  209. 

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

  211. #undef JNI_CLASS_MEMBERS

  212. 

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

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

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

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

  217. 

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

  219. #undef JNI_CLASS_MEMBERS

  220. 

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

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

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

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

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

  226. 

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

  228. #undef JNI_CLASS_MEMBERS

  229. 

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

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

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

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

  234. 

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

  236. #undef JNI_CLASS_MEMBERS

  237. 

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

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

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

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

  242. 

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

  244. #undef JNI_CLASS_MEMBERS

  245. 

  246. //==============================================================================

  247. class AndroidRunnable  : public juce::AndroidInterfaceImplementer

  248. {

  249. public:

  250.     struct Owner

  251.     {

  252.         virtual ~Owner() {}

  253. 

  254.         virtual void run() = 0;

  255.     };

  256. 

  257.     AndroidRunnable (Owner& ownerToUse)

  258.         : owner (ownerToUse)

  259.     {}

  260. 

  261. private:

  262.     Owner& owner;

  263. 

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

  265.     {

  266.         auto* env = getEnv();

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

  268. 

  269.         if (methodName == "run")

  270.         {

  271.             owner.run();

  272.             return nullptr;

  273.         }

  274. 

  275.         // invoke base class

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

  277.     }

  278. };

  279. 

  280. //==============================================================================

  281. class TextureViewSurfaceTextureListener     : public AndroidInterfaceImplementer

  282. {

  283. public:

  284.     struct Owner

  285.     {

  286.         virtual ~Owner() {}

  287. 

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

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

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

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

  292.     };

  293. 

  294.     TextureViewSurfaceTextureListener (Owner& ownerToUse)

  295.         : owner (ownerToUse)

  296.     {}

  297. 

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

  299.     {

  300.         auto* env = getEnv();

  301. 

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

  303. 

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

  305. 

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

  307.         {

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

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

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

  311. 

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

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

  314. 

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

  316.             return nullptr;

  317.         }

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

  319.         {

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

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

  322. 

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

  324.         }

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

  326.         {

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

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

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

  330. 

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

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

  333. 

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

  335.             return nullptr;

  336.         }

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

  338.         {

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

  340. 

  341.             owner.onSurfaceTextureUpdated (surface);

  342.             return nullptr;

  343.         }

  344. 

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

  346.     }

  347. 

  348. private:

  349.     Owner& owner;

  350. };

  351. 

  352. //==============================================================================

  353. class ImageReaderOnImageAvailableListener     : public AndroidInterfaceImplementer

  354. {

  355. public:

  356.     struct Owner

  357.     {

  358.         virtual ~Owner() {}

  359. 

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

  361.     };

  362. 

  363.     ImageReaderOnImageAvailableListener (Owner& ownerToUse)

  364.         : owner (ownerToUse)

  365.     {}

  366. 

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

  368.     {

  369.         auto* env = getEnv();

  370. 

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

  372. 

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

  374. 

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

  376.         {

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

  378. 

  379.             owner.onImageAvailable (imageReader);

  380.             return nullptr;

  381.         }

  382. 

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

  384.     }

  385. 

  386. private:

  387.     Owner& owner;

  388. };

  389. 

  390. //==============================================================================

  391. class MediaRecorderOnInfoListener     : public AndroidInterfaceImplementer

  392. {

  393. public:

  394.     struct Owner

  395.     {

  396.         virtual ~Owner() {}

  397. 

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

  399.     };

  400. 

  401.     MediaRecorderOnInfoListener (Owner& ownerToUse)

  402.         : owner (ownerToUse)

  403.     {}

  404. 

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

  406.     {

  407.         auto* env = getEnv();

  408. 

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

  410. 

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

  412. 

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

  414.         {

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

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

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

  418. 

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

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

  421. 

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

  423.             return nullptr;

  424.         }

  425. 

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

  427.     }

  428. 

  429. private:

  430.     Owner& owner;

  431. };

  432. 

  433. //==============================================================================

  434. class MediaRecorderOnErrorListener     : public AndroidInterfaceImplementer

  435. {

  436. public:

  437.     struct Owner

  438.     {

  439.         virtual ~Owner() {}

  440. 

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

  442.     };

  443. 

  444.     MediaRecorderOnErrorListener (Owner& ownerToUse)

  445.         : owner (ownerToUse)

  446.     {}

  447. 

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

  449.     {

  450.         auto* env = getEnv();

  451. 

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

  453. 

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

  455. 

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

  457.         {

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

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

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

  461. 

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

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

  464. 

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

  466.             return nullptr;

  467.         }

  468. 

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

  470.     }

  471. 

  472. private:

  473.     Owner& owner;

  474. };

  475. 

  476. //==============================================================================

  477. struct CameraDevice::Pimpl

  478.     : private ActivityLifecycleCallbacks

  479. {

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

  481. 

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

  483.            int minWidthToUse, int minHeightToUse, int maxWidthToUse, int maxHeightToUse,

  484.            bool /*useHighQuality*/)

  485.         : owner (ownerToUse),

  486.           minWidth (minWidthToUse),

  487.           minHeight (minHeightToUse),

  488.           maxWidth (maxWidthToUse),

  489.           maxHeight (maxHeightToUse),

  490.           cameraId (cameraIdToUse),

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

  492.           cameraManager (initialiseCameraManager()),

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

  494.           streamConfigurationMap (cameraCharacteristics),

  495.           previewDisplay (streamConfigurationMap.getPreviewBufferSize()),

  496.           deviceOrientationChangeListener (previewDisplay)

  497.     {

  498.         startBackgroundThread();

  499.     }

  500. 

  501.     ~Pimpl() override

  502.     {

  503.         auto* env = getEnv();

  504. 

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

  506.         activityLifeListener.clear();

  507.     }

  508. 

  509.     JUCE_DECLARE_WEAK_REFERENCEABLE (Pimpl)

  510. 

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

  512. 

  513.     void open (InternalOpenCameraResultCallback cameraOpenCallbackToUse)

  514.     {

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

  516. 

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

  518.         jassert (cameraOpenCallback != nullptr);

  519. 

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

  521.         jassert (scopedCameraDevice == nullptr);

  522. 

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

  524.             return;

  525. 

  526.         WeakReference<Pimpl> safeThis (this);

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

  528.                                      {

  529.                                          if (safeThis != nullptr)

  530.                                              safeThis->continueOpenRequest (granted);

  531.                                      });

  532.     }

  533. 

  534.     void continueOpenRequest (bool granted)

  535.     {

  536.         if (getAndroidSDKVersion() >= 21)

  537.         {

  538.             if (granted)

  539.             {

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

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

  542.             }

  543.             else

  544.             {

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

  546.             }

  547.         }

  548.         else

  549.         {

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

  551.         }

  552.     }

  553. 

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

  555. 

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

  557.     {

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

  559.         {

  560.             jassertfalse;

  561.             return;

  562.         }

  563. 

  564.         if (currentCaptureSessionMode->isVideoRecordSession())

  565.         {

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

  567.             jassertfalse;

  568.             return;

  569.         }

  570. 

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

  572. 

  573.         triggerStillPictureCapture();

  574.     }

  575. 

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

  577.     {

  578.         if (! openedOk())

  579.         {

  580.             jassertfalse;

  581.             return;

  582.         }

  583. 

  584.         if (! previewDisplay.isReady())

  585.         {

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

  587.             jassertfalse;

  588.             return;

  589.         }

  590. 

  591.         file.deleteFile();

  592.         file.create();

  593.         jassert (file.existsAsFile());

  594. 

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

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

  597.                                          streamConfigurationMap.getSupportedVideoRecordingOutputSizes());

  598. 

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

  600.                                                 getCameraSensorOrientation(), getCameraLensFacing()));

  601. 

  602.         firstRecordedFrameTimeMs = Time::getCurrentTime();

  603. 

  604.         currentCaptureSessionMode.reset();

  605.         startVideoRecordingMode (*mediaRecorder);

  606.     }

  607. 

  608.     void stopRecording()

  609.     {

  610.         currentCaptureSessionMode.reset();

  611.         mediaRecorder.reset();

  612. 

  613.         startPreviewMode (*imageReader);

  614.     }

  615. 

  616.     Time getTimeOfFirstRecordedFrame() const

  617.     {

  618.         return firstRecordedFrameTimeMs;

  619.     }

  620. 

  621.     static StringArray getAvailableDevices()

  622.     {

  623.         if (getAndroidSDKVersion() < 21)

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

  625. 

  626.         StringArray results;

  627. 

  628.         auto* env = getEnv();

  629. 

  630.         auto cameraManagerToUse = initialiseCameraManager();

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

  632.                                                                                            CameraManager.getCameraIdList));

  633. 

  634.         results = javaStringArrayToJuce (cameraIdArray);

  635. 

  636.         for (auto& result : results)

  637.             printDebugCameraInfo (cameraManagerToUse, result);

  638. 

  639.         return results;

  640.     }

  641. 

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

  643.     {

  644.         const ScopedLock sl (listenerLock);

  645.         listeners.add (listenerToAdd);

  646. 

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

  648.             triggerStillPictureCapture();

  649.     }

  650. 

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

  652.     {

  653.         const ScopedLock sl (listenerLock);

  654.         listeners.remove (listenerToRemove);

  655.     }

  656. 

  657. private:

  658.     enum

  659.     {

  660.         ERROR_CAMERA_IN_USE = 1,

  661.         ERROR_MAX_CAMERAS_IN_USE = 2,

  662.         ERROR_CAMERA_DISABLED = 3,

  663.         ERROR_CAMERA_DEVICE = 4,

  664.         ERROR_CAMERA_SERVICE = 5

  665.     };

  666. 

  667.     static String cameraErrorCodeToString (int errorCode)

  668.     {

  669.         switch (errorCode)

  670.         {

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

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

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

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

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

  676.             default:                       return "Unknown error.";

  677.         }

  678.     }

  679. 

  680.     static LocalRef<jobject> initialiseCameraManager()

  681.     {

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

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

  684.     }

  685. 

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

  687.     {

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

  689.                                                               CameraManager.getCameraCharacteristics,

  690.                                                               javaString (cameraId).get()));

  691.     }

  692. 

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

  694.     {

  695.         auto* env = getEnv();

  696. 

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

  698.                                                                          CameraManager.getCameraCharacteristics,

  699.                                                                          javaString (cameraId).get()));

  700. 

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

  702. 

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

  704. 

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

  706. 

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

  708.         {

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

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

  711.             auto keyName = juceString (jKeyName);

  712. 

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

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

  715.             auto keyValueString = juceString (jKeyValueString);

  716. 

  717.             auto &kvs = keyValueString;

  718. 

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

  720.             {

  721.                 printPrimitiveArrayElements (keyValue, keyName, keyValueString);

  722.             }

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

  724.             {

  725.                 printRangeArrayElements (keyValue, keyName);

  726.             }

  727.             else

  728.             {

  729.                 int chunkSize = 256;

  730. 

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

  732.                 {

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

  734. 

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

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

  737.                 }

  738.                 else

  739.                 {

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

  741.                 }

  742.             }

  743. 

  744.             ignoreUnused (keyName);

  745.         }

  746.     }

  747. 

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

  749.                                              const String& keyValueString)

  750.     {

  751.         ignoreUnused (keyName);

  752. 

  753.         String result = "[";

  754. 

  755.         auto* env = getEnv();

  756. 

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

  758.         {                                                                                                           \

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

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

  761.                                                                                                                     \

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

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

  764.                                                                                                                     \

  765.             if (size > 0)                                                                                           \

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

  767.                                                                                                                     \

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

  769.         }

  770. 

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

  772.             PRINT_ELEMENTS (jint, jintArray, Int)

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

  774.             PRINT_ELEMENTS (float, jfloatArray, Float)

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

  776.             PRINT_ELEMENTS (jboolean, jbooleanArray, Boolean)

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

  778.             PRINT_ELEMENTS (jbyte, jbyteArray, Byte);

  779. 

  780.         #undef PRINT_ELEMENTS

  781. 

  782.         result << "]";

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

  784.     }

  785. 

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

  787.     {

  788.         auto* env = getEnv();

  789. 

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

  791. 

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

  793. 

  794.         String result;

  795. 

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

  797.         {

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

  799. 

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

  801. 

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

  803.         }

  804. 

  805.         ignoreUnused (keyName);

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

  807.     }

  808. 

  809.     //==============================================================================

  810.     class StreamConfigurationMap

  811.     {

  812.     public:

  813.         StreamConfigurationMap (const GlobalRef& cameraCharacteristicsToUse)

  814.             : scalerStreamConfigurationMap (getStreamConfigurationMap (cameraCharacteristicsToUse)),

  815.               supportedPreviewOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

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

  817.                                                                 -1)),

  818.               supportedStillImageOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

  819.                                                                    LocalRef<jobject>(),

  820.                                                                    jpegImageFormat)),

  821.               supportedVideoRecordingOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

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

  823.                                                                        -1)),

  824.               defaultPreviewSize (getSmallestSize (supportedPreviewOutputSizes)),

  825.               previewBufferSize (getLargestSize (supportedPreviewOutputSizes))

  826.         {

  827.             printSizesLog (supportedPreviewOutputSizes, "SurfaceTexture");

  828.             printSizesLog (supportedStillImageOutputSizes, "JPEG");

  829.             printSizesLog (supportedVideoRecordingOutputSizes, "MediaRecorder");

  830.         }

  831. 

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

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

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

  835. 

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

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

  838. 

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

  840.         {

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

  842.         }

  843. 

  844.         static constexpr int jpegImageFormat = 256;

  845. 

  846.     private:

  847.         GlobalRef scalerStreamConfigurationMap;

  848. 

  849.         Array<Rectangle<int>> supportedPreviewOutputSizes;

  850.         Array<Rectangle<int>> supportedStillImageOutputSizes;

  851.         Array<Rectangle<int>> supportedVideoRecordingOutputSizes;

  852.         Rectangle<int> defaultPreviewSize, previewBufferSize;

  853. 

  854.         GlobalRef getStreamConfigurationMap (const GlobalRef& cameraCharacteristicsToUse)

  855.         {

  856.             auto* env = getEnv();

  857. 

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

  859.                                                                                                  CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP));

  860. 

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

  862.                                                                         CameraCharacteristics.get,

  863.                                                                         scalerStreamConfigurationMapKey.get())));

  864.         }

  865. 

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

  867.                                                           const LocalRef<jobject>& outputClass,

  868.                                                           int format)

  869.         {

  870.             Array<Rectangle<int>> result;

  871. 

  872.             auto* env = getEnv();

  873. 

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

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

  876.                                                                                              AndroidStreamConfigurationMap.getOutputSizesForClass,

  877.                                                                                              outputClass.get()))

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

  879.                                                                                              AndroidStreamConfigurationMap.getOutputSizesForFormat,

  880.                                                                                              (jint) format));

  881. 

  882.             if (format != -1)

  883.             {

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

  885. 

  886.                 if (! supported)

  887.                 {

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

  889.                     jassertfalse;

  890.                     return {};

  891.                 }

  892.             }

  893. 

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

  895. 

  896.             jassert (numSizes > 0);

  897. 

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

  899.             {

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

  901. 

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

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

  904. 

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

  906.             }

  907. 

  908.             return result;

  909.         }

  910. 

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

  912.         {

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

  914.                                                                         javaString (name).get()));

  915.         }

  916. 

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

  918.         {

  919.             ignoreUnused (sizes, className);

  920. 

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

  922. 

  923.           #if JUCE_CAMERA_LOG_ENABLED

  924.             for (auto& s : sizes)

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

  926.           #endif

  927.         }

  928. 

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

  930.         {

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

  932.                 return {};

  933. 

  934.             auto smallestSize = sizes[0];

  935. 

  936.             for (auto& size : sizes)

  937.             {

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

  939.                     smallestSize = size;

  940.             }

  941. 

  942.             return smallestSize;

  943.         }

  944. 

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

  946.         {

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

  948.                 return {};

  949. 

  950.             auto largestSize = sizes[0];

  951. 

  952.             for (auto& size : sizes)

  953.             {

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

  955.                     largestSize = size;

  956.             }

  957. 

  958.             return largestSize;

  959.         }

  960.     };

  961. 

  962.     //==============================================================================

  963.     class PreviewDisplay    : private TextureViewSurfaceTextureListener::Owner

  964.     {

  965.     public:

  966.         struct Listener

  967.         {

  968.             virtual ~Listener() {}

  969. 

  970.             virtual void previewDisplayReady() = 0;

  971.             virtual void previewDisplayAboutToBeDestroyed() = 0;

  972.         };

  973. 

  974.         PreviewDisplay (Rectangle<int> bufferSize)

  975.             : textureViewSurfaceTextureListener (*this),

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

  977.                                                                    getAppContext().get()))),

  978.               bufferWidth (bufferSize.getWidth()),

  979.               bufferHeight (bufferSize.getHeight())

  980.         {

  981.             auto* env = getEnv();

  982. 

  983.             if (! isReady())

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

  985.                                      CreateJavaInterface (&textureViewSurfaceTextureListener,

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

  987.         }

  988. 

  989.         ~PreviewDisplay() override

  990.         {

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

  992.         }

  993. 

  994.         void addListener (Listener* l)

  995.         {

  996.             if (l == nullptr)

  997.             {

  998.                 jassertfalse;

  999.                 return;

  1000.             }

  1001. 

  1002.             listeners.add (l);

  1003. 

  1004.             if (isReady())

  1005.                 l->previewDisplayReady();

  1006.         }

  1007. 

  1008.         void removeListener (Listener* l)

  1009.         {

  1010.             if (l == nullptr)

  1011.             {

  1012.                 jassertfalse;

  1013.                 return;

  1014.             }

  1015. 

  1016.             listeners.remove (l);

  1017.         }

  1018. 

  1019.         bool isReady() const

  1020.         {

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

  1022.                     && width > 0 && height > 0;

  1023.         }

  1024. 

  1025.         LocalRef<jobject> createSurface()

  1026.         {

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

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

  1029.             if (! isReady())

  1030.                 return LocalRef<jobject> (nullptr);

  1031. 

  1032.             auto* env = getEnv();

  1033. 

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

  1035.                                                                             AndroidTextureView.getSurfaceTexture));

  1036. 

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

  1038.             //     can result in a cropped preview.

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

  1040. 

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

  1042. 

  1043.             return surface;

  1044.         }

  1045. 

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

  1047. 

  1048.         void updateSurfaceTransform()

  1049.         {

  1050.             auto* env = getEnv();

  1051. 

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

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

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

  1055. 

  1056.             static constexpr int rotation90 = 1;

  1057.             static constexpr int rotation270 = 3;

  1058. 

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

  1060. 

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

  1062.             {

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

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

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

  1066.             }

  1067. 

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

  1069.         }

  1070. 

  1071.     private:

  1072.         ListenerList<Listener> listeners;

  1073. 

  1074.         TextureViewSurfaceTextureListener textureViewSurfaceTextureListener;

  1075.         GlobalRef textureView;

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

  1077.         int bufferWidth, bufferHeight;

  1078. 

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

  1080.         {

  1081.             JUCE_CAMERA_LOG ("onSurfaceTextureAvailable()");

  1082. 

  1083.             width = widthToUse;

  1084.             height = heightToUse;

  1085. 

  1086.             updateSurfaceTransform();

  1087. 

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

  1089.         }

  1090. 

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

  1092.         {

  1093.             JUCE_CAMERA_LOG ("onSurfaceTextureDestroyed()");

  1094. 

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

  1096. 

  1097.             return true;

  1098.         }

  1099. 

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

  1101.         {

  1102.             JUCE_CAMERA_LOG ("onSurfaceTextureSizeChanged()");

  1103. 

  1104.             width = widthToUse;

  1105.             height = heightToUse;

  1106. 

  1107.             updateSurfaceTransform();

  1108.         }

  1109. 

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

  1111.         {

  1112.             JUCE_CAMERA_LOG ("onSurfaceTextureUpdated()");

  1113.         }

  1114. 

  1115.         JUCE_DECLARE_NON_COPYABLE (PreviewDisplay)

  1116.     };

  1117. 

  1118.     //==============================================================================

  1119.     class ImageReader   : private ImageReaderOnImageAvailableListener::Owner

  1120.     {

  1121.     public:

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

  1123.                      int imageWidth, int imageHeight, int cameraSensorOrientationToUse)

  1124.             : owner (ownerToUse),

  1125.               cameraSensorOrientation (cameraSensorOrientationToUse),

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

  1127.                                                                                 imageWidth, imageHeight, StreamConfigurationMap::jpegImageFormat,

  1128.                                                                                 numImagesToKeep))),

  1129.               onImageAvailableListener (*this)

  1130.         {

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

  1132.                                       CreateJavaInterface (&onImageAvailableListener,

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

  1134.                                       handlerToUse.get());

  1135.         }

  1136. 

  1137.         ~ImageReader() override

  1138.         {

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

  1140.         }

  1141. 

  1142.         LocalRef<jobject> getSurface() const

  1143.         {

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

  1145.         }

  1146. 

  1147.         void resetNotificationFlag()

  1148.         {

  1149.             hasNotifiedListeners.set (0);

  1150.         }

  1151. 

  1152.     private:

  1153.         Pimpl& owner;

  1154.         int cameraSensorOrientation;

  1155. 

  1156.         GlobalRef imageReader;

  1157.         ImageReaderOnImageAvailableListener onImageAvailableListener;

  1158.         static constexpr int numImagesToKeep = 2;

  1159.         Atomic<int> hasNotifiedListeners { 0 };

  1160. 

  1161.         JUCE_DECLARE_WEAK_REFERENCEABLE (ImageReader)

  1162. 

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

  1164.         {

  1165.             JUCE_CAMERA_LOG ("onImageAvailable()");

  1166. 

  1167.             auto* env = getEnv();

  1168. 

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

  1170. 

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

  1172.                 return;

  1173. 

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

  1175. 

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

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

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

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

  1180.                                                                  cameraLensFrontFacing,

  1181.                                                                  cameraSensorOrientation);

  1182. 

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

  1184. 

  1185.             WeakReference<ImageReader> safeThis (this);

  1186. 

  1187.             owner.callListeners (image);

  1188. 

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

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

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

  1192.         }

  1193. 

  1194.         struct ImageBuffer

  1195.         {

  1196.             LocalRef<jbyteArray> byteArray;

  1197.             int size;

  1198.         };

  1199. 

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

  1201.                                                              Desktop::DisplayOrientation deviceOrientationFromAccelerometerSensor,

  1202.                                                              Desktop::DisplayOrientation targetOrientation,

  1203.                                                              bool cameraLensFrontFacing,

  1204.                                                              int cameraSensorOrientation)

  1205.         {

  1206.             auto* env = getEnv();

  1207. 

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

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

  1210. 

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

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

  1213. 

  1214.             ImageBuffer correctedBuffer = getImageBufferWithCorrectedOrientationFrom (byteBuffer, deviceOrientationFromAccelerometerSensor,

  1215.                                                                                       targetOrientation, cameraLensFrontFacing, cameraSensorOrientation);

  1216. 

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

  1218. 

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

  1220. 

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

  1222. 

  1223.             return result;

  1224.         }

  1225. 

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

  1227.                                                                        Desktop::DisplayOrientation deviceOrientationFromAccelerometerSensor,

  1228.                                                                        Desktop::DisplayOrientation targetOrientation,

  1229.                                                                        bool cameraLensFrontFacing,

  1230.                                                                        int cameraSensorOrientation)

  1231.         {

  1232.             auto* env = getEnv();

  1233. 

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

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

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

  1237. 

  1238.             auto rotationAngle = getRotationAngle (deviceOrientationFromAccelerometerSensor, targetOrientation,

  1239.                                                   cameraLensFrontFacing, cameraSensorOrientation);

  1240. 

  1241.             if (rotationAngle == 0)

  1242.             {

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

  1244.                 return { byteArray, bufferSize };

  1245.             }

  1246. 

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

  1248.                                                                               AndroidBitmapFactory.decodeByteArray,

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

  1250. 

  1251.             if (origBitmap == nullptr)

  1252.             {

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

  1254.                 return { byteArray, bufferSize };

  1255.             }

  1256. 

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

  1258. 

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

  1260.                                                                             ByteArrayOutputStream.constructor));

  1261. 

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

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

  1264.                                                                                   AndroidBitmapCompressFormat.valueOf,

  1265.                                                                                   jCompressFormatString.get()));

  1266. 

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

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

  1269.             {

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

  1271.                                                                                                     ByteArrayOutputStream.toByteArray));

  1272. 

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

  1274. 

  1275.                 return { correctedByteArray, correctedByteArraySize };

  1276.             }

  1277. 

  1278.             jassertfalse;

  1279.             // fallback, return original bitmap

  1280.             return { byteArray, bufferSize };

  1281.         }

  1282. 

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

  1284.                                      Desktop::DisplayOrientation targetOrientation,

  1285.                                      bool cameraLensFrontFacing,

  1286.                                      int cameraSensorOrientation)

  1287.         {

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

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

  1290. 

  1291.             if (cameraLensFrontFacing && isSensorOrientationHorizontal)

  1292.             {

  1293.                 // flip angles for front camera

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

  1295.             }

  1296. 

  1297.             switch (targetOrientation)

  1298.             {

  1299.                 case Desktop::rotatedAntiClockwise:

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

  1301.                 case Desktop::rotatedClockwise:

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

  1303.                 case Desktop::upright:

  1304.                 case Desktop::upsideDown:

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

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

  1307.                     {

  1308.                         return cameraSensorOrientation;

  1309.                     }

  1310.                     else

  1311.                     {

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

  1313.                             return cameraSensorOrientation;

  1314.                         else

  1315.                             return (cameraSensorOrientation + 180) % 360;

  1316.                     }

  1317.                     break;

  1318.                 case Desktop::allOrientations:

  1319.                 default:

  1320.                     return 0;

  1321.             }

  1322.         }

  1323. 

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

  1325.         {

  1326.             auto* env = getEnv();

  1327. 

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

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

  1330. 

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

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

  1333. 

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

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

  1336.                                                                                  (jint) origBitmapWidth, (jint) origBitmapHeight,

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

  1338. 

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

  1340. 

  1341.             return rotatedBitmap;

  1342.         }

  1343.     };

  1344. 

  1345.     //==============================================================================

  1346.     class MediaRecorder : private MediaRecorderOnInfoListener::Owner,

  1347.                           private MediaRecorderOnErrorListener::Owner

  1348.     {

  1349.     public:

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

  1351.                        int sensorOrientation, int cameraLensFacing)

  1352.             : onInfoListener (*this),

  1353.               onErrorListener (*this),

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

  1355.                                                                      AndroidMediaRecorder.constructor)))

  1356.         {

  1357.             auto* env = getEnv();

  1358. 

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

  1360.                                  CreateJavaInterface (&onInfoListener,

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

  1362. 

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

  1364.                                  CreateJavaInterface (&onErrorListener,

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

  1366. 

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

  1368.             //     the order is changed.

  1369.             static constexpr int audioSourceMic = 1;

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

  1371. 

  1372.             static constexpr int videoSourceSurface = 2;

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

  1374. 

  1375.             static constexpr int outputFormatMPEG4 = 2;

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

  1377. 

  1378.             static constexpr int audioEncoderAAC = 3;

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

  1380. 

  1381.             static constexpr int videoEncoderH264 = 2;

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

  1383. 

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

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

  1386. 

  1387.             auto frontFacing = cameraLensFacing == 0;

  1388. 

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

  1390. 

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

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

  1393. 

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

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

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

  1397.         }

  1398. 

  1399.         ~MediaRecorder() override

  1400.         {

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

  1402.         }

  1403. 

  1404.         LocalRef<jobject> getSurface()

  1405.         {

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

  1407.         }

  1408. 

  1409.         void start()

  1410.         {

  1411.             lockScreenOrientation();

  1412. 

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

  1414. 

  1415.             hasStartedRecording = true;

  1416.         }

  1417. 

  1418.         void stop()

  1419.         {

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

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

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

  1423.             if (! hasStartedRecording)

  1424.                 return;

  1425. 

  1426.             hasStartedRecording = false;

  1427. 

  1428.             auto* env = getEnv();

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

  1430. 

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

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

  1433.             jniCheckHasExceptionOccurredAndClear();

  1434. 

  1435.             unlockScreenOrientation();

  1436.         }

  1437. 

  1438.     private:

  1439.         MediaRecorderOnInfoListener onInfoListener;

  1440.         MediaRecorderOnErrorListener onErrorListener;

  1441.         GlobalRef mediaRecorder;

  1442.         bool hasStartedRecording = false;

  1443.         int orientationsEnabled = -1;

  1444. 

  1445.         void lockScreenOrientation()

  1446.         {

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

  1448. 

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

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

  1451.         }

  1452. 

  1453.         static jint juceOrientationToNativeOrientation (int orientations) noexcept

  1454.         {

  1455.             enum

  1456.             {

  1457.                 SCREEN_ORIENTATION_LANDSCAPE          = 0,

  1458.                 SCREEN_ORIENTATION_PORTRAIT           = 1,

  1459.                 SCREEN_ORIENTATION_USER               = 2,

  1460.                 SCREEN_ORIENTATION_REVERSE_LANDSCAPE  = 8,

  1461.                 SCREEN_ORIENTATION_REVERSE_PORTRAIT   = 9,

  1462.                 SCREEN_ORIENTATION_USER_LANDSCAPE     = 11,

  1463.                 SCREEN_ORIENTATION_USER_PORTRAIT      = 12,

  1464.             };

  1465. 

  1466.             switch (orientations)

  1467.             {

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

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

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

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

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

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

  1474.                 default:                                                        return (jint) SCREEN_ORIENTATION_USER;

  1475.             }

  1476.         }

  1477. 

  1478.         void unlockScreenOrientation()

  1479.         {

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

  1481.         }

  1482. 

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

  1484.         {

  1485.             ignoreUnused (recorder, what, extra);

  1486. 

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

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

  1489.         }

  1490. 

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

  1492.         {

  1493.             ignoreUnused (recorder, what, extra);

  1494. 

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

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

  1497.         }

  1498. 

  1499.         static String getInfoStringFromCode (int what)

  1500.         {

  1501.             enum

  1502.             {

  1503.                 MEDIA_RECORDER_INFO_UNKNOWN = 1,

  1504.                 MEDIA_RECORDER_INFO_MAX_DURATION_REACHED = 800,

  1505.                 MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED = 801,

  1506.                 MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING = 802,

  1507.                 MEDIA_RECORDER_INFO_NEXT_OUTPUT_FILE_STARTED = 803

  1508.             };

  1509. 

  1510.             switch (what)

  1511.             {

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

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

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

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

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

  1517.                 default: return String (what);

  1518.             };

  1519.         }

  1520. 

  1521.         static String getErrorStringFromCode (int what)

  1522.         {

  1523.             enum

  1524.             {

  1525.                 MEDIA_RECORDER_ERROR_UNKNOWN = 1,

  1526.                 MEDIA_ERROR_SERVER_DIED = 100

  1527.             };

  1528. 

  1529.             switch (what)

  1530.             {

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

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

  1533.                 default: return String (what);

  1534.             };

  1535.         }

  1536. 

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

  1538.         {

  1539.             auto* env = getEnv();

  1540. 

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

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

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

  1544. 

  1545.             enum

  1546.             {

  1547.                 ROTATION_0 = 0,

  1548.                 ROTATION_90,

  1549.                 ROTATION_180,

  1550.                 ROTATION_270

  1551.             };

  1552. 

  1553.             int hint = 0;

  1554. 

  1555.             switch (rotation)

  1556.             {

  1557.                 case ROTATION_0:   hint = cameraSensorOrientation;       break;

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

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

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

  1561.                 default: jassertfalse;

  1562.             }

  1563. 

  1564.             return (hint + 360) % 360;

  1565.         }

  1566.     };

  1567. 

  1568.     //==============================================================================

  1569.     class ScopedCameraDevice

  1570.     {

  1571.     public:

  1572.         //==============================================================================

  1573.         class CaptureSession

  1574.         {

  1575.         public:

  1576.             struct ConfiguredCallback

  1577.             {

  1578.                 virtual ~ConfiguredCallback() {}

  1579. 

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

  1581.             };

  1582. 

  1583.             ~CaptureSession()

  1584.             {

  1585.                 bool calledClose = false;

  1586. 

  1587.                 auto* env = getEnv();

  1588. 

  1589.                 {

  1590.                     const ScopedLock lock (captureSessionLock);

  1591. 

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

  1593.                     {

  1594.                         calledClose = true;

  1595. 

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

  1597.                     }

  1598.                 }

  1599. 

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

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

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

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

  1604.                 {

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

  1606.                 }

  1607.                 else if (calledClose)

  1608.                 {

  1609.                     pendingClose.set (1);

  1610.                     closedEvent.wait (-1);

  1611.                 }

  1612.             }

  1613. 

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

  1615. 

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

  1617. 

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

  1619.             {

  1620.                 if (! openedOk())

  1621.                 {

  1622.                     jassertfalse;

  1623.                     return false;

  1624.                 }

  1625. 

  1626.                 auto* env = getEnv();

  1627. 

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

  1629. 

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

  1631.                 {

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

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

  1634.                 }

  1635. 

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

  1637. 

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

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

  1640. 

  1641.                 return true;

  1642.             }

  1643. 

  1644.             void takeStillPicture (jobject targetSurface)

  1645.             {

  1646.                 if (stillPictureTaker == nullptr)

  1647.                 {

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

  1649.                     jassertfalse;

  1650.                     return;

  1651.                 }

  1652. 

  1653.                 auto* env = getEnv();

  1654. 

  1655.                 static constexpr int templateStillCapture = 2;

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

  1657.                                                                          AndroidCameraDevice.createCaptureRequest,

  1658.                                                                          (jint) templateStillCapture));

  1659. 

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

  1661. 

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

  1663. 

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

  1665. 

  1666.                 stillPictureTaker->takePicture (stillPictureCaptureRequest);

  1667.             }

  1668. 

  1669.         private:

  1670.             //==============================================================================

  1671.             class StillPictureTaker   : private AndroidRunnable::Owner

  1672.             {

  1673.             public:

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

  1675.                                    GlobalRef& previewCaptureRequestToUse, GlobalRef& handlerToUse,

  1676.                                    int autoFocusModeToUse)

  1677.                     : captureSession (captureSessionToUse),

  1678.                       captureRequestBuilder (captureRequestBuilderToUse),

  1679.                       previewCaptureRequest (previewCaptureRequestToUse),

  1680.                       handler (handlerToUse),

  1681.                       runnable (*this),

  1682.                       captureSessionPreviewCaptureCallback (createCaptureSessionCallback (true)),

  1683.                       captureSessionStillPictureCaptureCallback (createCaptureSessionCallback (false)),

  1684.                       autoFocusMode (autoFocusModeToUse)

  1685.                 {

  1686.                 }

  1687. 

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

  1689.                 {

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

  1691. 

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

  1693. 

  1694.                     lockFocus();

  1695.                 }

  1696. 

  1697.             private:

  1698.                 GlobalRef& captureSession;

  1699.                 GlobalRef& captureRequestBuilder;

  1700.                 GlobalRef& previewCaptureRequest;

  1701.                 GlobalRef& handler;

  1702. 

  1703.                 AndroidRunnable runnable;

  1704.                 GlobalRef delayedCaptureRunnable;

  1705. 

  1706.                 GlobalRef captureSessionPreviewCaptureCallback;

  1707. 

  1708.                 GlobalRef stillPictureCaptureRequest;

  1709.                 GlobalRef captureSessionStillPictureCaptureCallback;

  1710. 

  1711.                 int autoFocusMode;

  1712. 

  1713.                 //==============================================================================

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

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

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

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

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

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

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

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

  1722. 

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

  1724.                 #undef JNI_CLASS_MEMBERS

  1725. 

  1726.                 LocalRef<jobject> createCaptureSessionCallback (bool createPreviewSession)

  1727.                 {

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

  1729.                                                                   CameraCaptureSessionCaptureCallback.constructor,

  1730.                                                                   reinterpret_cast<jlong> (this),

  1731.                                                                   createPreviewSession ? 1 : 0));

  1732.                 }

  1733. 

  1734.                 //==============================================================================

  1735. 

  1736.                 enum class State

  1737.                 {

  1738.                     idle = 0,

  1739.                     pendingFocusLock,

  1740.                     pendingExposurePrecapture,

  1741.                     pendingExposurePostPrecapture,

  1742.                     pictureTaken

  1743.                 };

  1744. 

  1745.                 State currentState = State::idle;

  1746. 

  1747.                 void lockFocus()

  1748.                 {

  1749.                     if (jniCheckHasExceptionOccurredAndClear())

  1750.                         return;

  1751. 

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

  1753. 

  1754.                     currentState = State::pendingFocusLock;

  1755. 

  1756.                     auto* env = getEnv();

  1757. 

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

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

  1760.                     static constexpr int controlAfTriggerStart = 1;

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

  1762.                                                                         CaptureRequest.CONTROL_AF_TRIGGER,

  1763.                                                                         controlAfTriggerStart);

  1764. 

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

  1766.                                                                                     CaptureRequestBuilder.build));

  1767. 

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

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

  1770.                 }

  1771. 

  1772.                 void updateState (jobject captureResult)

  1773.                 {

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

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

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

  1777.                     if (jniCheckHasExceptionOccurredAndClear())

  1778.                         return;

  1779. 

  1780.                     switch (currentState)

  1781.                     {

  1782.                         case State::pendingFocusLock:

  1783.                         {

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

  1785. 

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

  1787. 

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

  1789.                             {

  1790.                                 captureStillPictureDelayed();

  1791.                                 return;

  1792.                             }

  1793. 

  1794.                             auto autoToFocusNotAvailable = autoFocusMode == 0;

  1795. 

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

  1797.                             {

  1798.                                 auto controlAeStateIntValue = getControlAEState (captureResult);

  1799.                                 static constexpr int controlAeStateConverged = 2;

  1800. 

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

  1802.                                 {

  1803.                                     currentState = State::pictureTaken;

  1804.                                     captureStillPictureDelayed();

  1805.                                 }

  1806.                                 else

  1807.                                 {

  1808.                                     runPrecaptureSequence();

  1809.                                 }

  1810.                             }

  1811. 

  1812.                             break;

  1813.                         }

  1814. 

  1815.                         case State::pendingExposurePrecapture:

  1816.                         {

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

  1818. 

  1819.                             auto controlAeStateIntValue = getControlAEState (captureResult);

  1820.                             static constexpr int controlAeStateFlashRequired = 4;

  1821.                             static constexpr int controlAeStatePrecapture = 5;

  1822. 

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

  1824.                                                              || controlAeStateIntValue == controlAeStatePrecapture)

  1825.                             {

  1826.                                 currentState = State::pendingExposurePostPrecapture;

  1827.                             }

  1828. 

  1829.                             break;

  1830.                         }

  1831. 

  1832.                         case State::pendingExposurePostPrecapture:

  1833.                         {

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

  1835. 

  1836.                             auto controlAeStateIntValue = getControlAEState (captureResult);

  1837.                             static constexpr int controlAeStatePrecapture = 5;

  1838. 

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

  1840.                             {

  1841.                                 currentState = State::pictureTaken;

  1842.                                 captureStillPictureDelayed();

  1843.                             }

  1844. 

  1845.                             break;

  1846.                         }

  1847.                         case State::idle:

  1848.                         case State::pictureTaken:

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

  1850.                     };

  1851.                 }

  1852. 

  1853.                 static int getControlAEState (jobject captureResult)

  1854.                 {

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

  1856. 

  1857.                     return controlAeStateValue.get() != nullptr

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

  1859.                 }

  1860. 

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

  1862.                 {

  1863.                     static constexpr int controlAfStateFocusedLocked = 4;

  1864.                     static constexpr int controlAfStateNotFocusedLocked = 5;

  1865. 

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

  1867. 

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

  1869.                 }

  1870. 

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

  1872.                 {

  1873.                     auto* env = getEnv();

  1874. 

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

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

  1877.                 }

  1878. 

  1879.                 void captureStillPictureDelayed()

  1880.                 {

  1881.                     if (jniCheckHasExceptionOccurredAndClear())

  1882.                         return;

  1883. 

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

  1885. 

  1886.                     auto* env = getEnv();

  1887. 

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

  1889. 

  1890.                     if (jniCheckHasExceptionOccurredAndClear())

  1891.                         return;

  1892. 

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

  1894. 

  1895.                     if (jniCheckHasExceptionOccurredAndClear())

  1896.                         return;

  1897. 

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

  1899.                     // stopRepeating/abortCaptures calls.

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

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

  1902. 

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

  1904.                 }

  1905. 

  1906.                 void runPrecaptureSequence()

  1907.                 {

  1908.                     if (jniCheckHasExceptionOccurredAndClear())

  1909.                         return;

  1910. 

  1911.                     auto* env = getEnv();

  1912. 

  1913.                     static constexpr int controlAePrecaptureTriggerStart = 1;

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

  1915.                                                                         CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,

  1916.                                                                         controlAePrecaptureTriggerStart);

  1917. 

  1918.                     currentState = State::pendingExposurePrecapture;

  1919. 

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

  1921.                                                                                     CaptureRequestBuilder.build));

  1922. 

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

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

  1925.                 }

  1926. 

  1927.                 void unlockFocus()

  1928.                 {

  1929.                     if (jniCheckHasExceptionOccurredAndClear())

  1930.                         return;

  1931. 

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

  1933. 

  1934.                     currentState = State::idle;

  1935. 

  1936.                     auto* env = getEnv();

  1937. 

  1938.                     static constexpr int controlAfTriggerCancel = 2;

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

  1940.                                                                         CaptureRequest.CONTROL_AF_TRIGGER,

  1941.                                                                         controlAfTriggerCancel);

  1942. 

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

  1944.                                                                                            CaptureRequestBuilder.build));

  1945. 

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

  1947.                                         nullptr, handler.get());

  1948. 

  1949.                     if (jniCheckHasExceptionOccurredAndClear())

  1950.                         return;

  1951. 

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

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

  1954.                                         nullptr, handler.get());

  1955.                 }

  1956.                 //==============================================================================

  1957.                 void run() override

  1958.                 {

  1959.                     captureStillPicture();

  1960.                 }

  1961. 

  1962.                 void captureStillPicture()

  1963.                 {

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

  1965.                                              stillPictureCaptureRequest.get(), captureSessionStillPictureCaptureCallback.get(),

  1966.                                              nullptr);

  1967.                 }

  1968. 

  1969.                 //==============================================================================

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

  1971.                 {

  1972.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureCompleted()");

  1973. 

  1974.                     ignoreUnused (session, request);

  1975. 

  1976.                     if (isPreview)

  1977.                         updateState (result);

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

  1979.                         unlockFocus();

  1980.                 }

  1981. 

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

  1983.                 {

  1984.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureFailed()");

  1985. 

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

  1987.                 }

  1988. 

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

  1990.                 {

  1991.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureProgressed()");

  1992. 

  1993.                     ignoreUnused (session, request);

  1994. 

  1995.                     if (isPreview)

  1996.                         updateState (partialResult);

  1997.                 }

  1998. 

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

  2000.                 {

  2001.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureSequenceAborted()");

  2002. 

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

  2004.                 }

  2005. 

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

  2007.                 {

  2008.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureSequenceCompleted()");

  2009. 

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

  2011.                 }

  2012. 

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

  2014.                 {

  2015.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureStarted()");

  2016. 

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

  2018.                 }

  2019. 

  2020.                 //==============================================================================

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

  2022.                 {

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

  2024.                     {

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

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

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

  2028. 

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

  2030.                     }

  2031.                 }

  2032. 

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

  2034.                 {

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

  2036.                     {

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

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

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

  2040. 

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

  2042.                     }

  2043.                 }

  2044. 

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

  2046.                 {

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

  2048.                     {

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

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

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

  2052. 

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

  2054.                     }

  2055.                 }

  2056. 

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

  2058.                 {

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

  2060.                     {

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

  2062. 

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

  2064.                     }

  2065.                 }

  2066. 

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

  2068.                 {

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

  2070.                     {

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

  2072. 

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

  2074.                     }

  2075.                 }

  2076. 

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

  2078.                 {

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

  2080.                     {

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

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

  2083. 

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

  2085.                     }

  2086.                 }

  2087.             };

  2088. 

  2089.             //==============================================================================

  2090.             ScopedCameraDevice& scopedCameraDevice;

  2091.             ConfiguredCallback& configuredCallback;

  2092.             GlobalRef& handler;

  2093. 

  2094.             GlobalRef captureRequestBuilder;

  2095.             GlobalRef previewCaptureRequest;

  2096. 

  2097.             GlobalRef captureSessionStateCallback;

  2098.             int autoFocusMode;

  2099. 

  2100.             GlobalRef captureSession;

  2101.             CriticalSection captureSessionLock;

  2102. 

  2103.             Atomic<int> pendingClose { 0 };

  2104. 

  2105.             std::unique_ptr<StillPictureTaker> stillPictureTaker;

  2106. 

  2107.             WaitableEvent closedEvent;

  2108. 

  2109.             JUCE_DECLARE_WEAK_REFERENCEABLE (CaptureSession)

  2110. 

  2111.             //==============================================================================

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

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

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

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

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

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

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

  2119. 

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

  2121.             #undef JNI_CLASS_MEMBERS

  2122. 

  2123. 

  2124.             //==============================================================================

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

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

  2127.                             int captureSessionTemplate, int autoFocusModeToUse)

  2128.                 : scopedCameraDevice (scopedCameraDeviceToUse),

  2129.                   configuredCallback (configuredCallbackToUse),

  2130.                   handler (handlerToUse),

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

  2132.                                                                                         AndroidCameraDevice.createCaptureRequest,

  2133.                                                                                         (jint) captureSessionTemplate))),

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

  2135.                                                                                        CameraCaptureSessionStateCallback.constructor,

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

  2137.                   autoFocusMode (autoFocusModeToUse)

  2138.             {

  2139.                 auto* env = getEnv();

  2140. 

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

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

  2143. 

  2144.                 static constexpr int controlModeAuto = 1;

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

  2146. 

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

  2148.             }

  2149. 

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

  2151.             {

  2152.                 auto* env = getEnv();

  2153. 

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

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

  2156. 

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

  2158.             }

  2159. 

  2160.             void cameraCaptureSessionActive (jobject session)

  2161.             {

  2162.                 JUCE_CAMERA_LOG ("cameraCaptureSessionActive()");

  2163.                 ignoreUnused (session);

  2164.             }

  2165. 

  2166.             void cameraCaptureSessionClosed (jobject session)

  2167.             {

  2168.                 JUCE_CAMERA_LOG ("cameraCaptureSessionClosed()");

  2169.                 ignoreUnused (session);

  2170. 

  2171.                 closedEvent.signal();

  2172.             }

  2173. 

  2174.             void cameraCaptureSessionConfigureFailed (jobject session)

  2175.             {

  2176.                 JUCE_CAMERA_LOG ("cameraCaptureSessionConfigureFailed()");

  2177.                 ignoreUnused (session);

  2178. 

  2179.                 WeakReference<CaptureSession> weakRef (this);

  2180. 

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

  2182.                 {

  2183.                     if (weakRef == nullptr)

  2184.                         return;

  2185. 

  2186.                     configuredCallback.captureSessionConfigured (nullptr);

  2187.                 });

  2188.             }

  2189. 

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

  2191.             {

  2192.                 JUCE_CAMERA_LOG ("cameraCaptureSessionConfigured()");

  2193. 

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

  2195.                 {

  2196.                     // Already closing, bailout.

  2197.                     closedEvent.signal();

  2198. 

  2199.                     GlobalRef s (session);

  2200. 

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

  2202.                         {

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

  2204.                         });

  2205. 

  2206.                     return;

  2207.                 }

  2208. 

  2209.                 {

  2210.                     const ScopedLock lock (captureSessionLock);

  2211.                     captureSession = GlobalRef (session);

  2212.                 }

  2213. 

  2214.                 WeakReference<CaptureSession> weakRef (this);

  2215. 

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

  2217.                 {

  2218.                     if (weakRef == nullptr)

  2219.                         return;

  2220. 

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

  2222.                                                                     previewCaptureRequest, handler, autoFocusMode));

  2223. 

  2224.                     configuredCallback.captureSessionConfigured (this);

  2225.                 });

  2226.             }

  2227. 

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

  2229.             {

  2230.                 JUCE_CAMERA_LOG ("cameraCaptureSessionReady()");

  2231.                 ignoreUnused (session);

  2232.             }

  2233. 

  2234.             //==============================================================================

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

  2236.             {

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

  2238.                 {

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

  2240. 

  2241.                     myself->cameraCaptureSessionActive (session);

  2242.                 }

  2243.             }

  2244. 

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

  2246.             {

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

  2248.                 {

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

  2250. 

  2251.                     myself->cameraCaptureSessionClosed (session);

  2252.                 }

  2253.             }

  2254. 

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

  2256.             {

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

  2258.                 {

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

  2260. 

  2261.                     myself->cameraCaptureSessionConfigureFailed (session);

  2262.                 }

  2263.             }

  2264. 

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

  2266.             {

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

  2268.                 {

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

  2270. 

  2271.                     myself->cameraCaptureSessionConfigured (session);

  2272.                 }

  2273.             }

  2274. 

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

  2276.             {

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

  2278.                 {

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

  2280. 

  2281.                     myself->cameraCaptureSessionReady (session);

  2282.                 }

  2283.             }

  2284. 

  2285.             //==============================================================================

  2286.             friend class ScopedCameraDevice;

  2287. 

  2288.             JUCE_DECLARE_NON_COPYABLE (CaptureSession)

  2289.         };

  2290. 

  2291.         //==============================================================================

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

  2293.                             GlobalRef& handlerToUse, int autoFocusModeToUse)

  2294.             : owner (ownerToUse),

  2295.               cameraId (cameraIdToUse),

  2296.               cameraManager (cameraManagerToUse),

  2297.               handler (handlerToUse),

  2298.               cameraStateCallback (createCameraStateCallbackObject()),

  2299.               autoFocusMode (autoFocusModeToUse)

  2300.         {

  2301.             open();

  2302.         }

  2303. 

  2304.         ~ScopedCameraDevice()

  2305.         {

  2306.             close();

  2307.         }

  2308. 

  2309.         void open()

  2310.         {

  2311.             pendingOpen.set (1);

  2312. 

  2313.             auto* env = getEnv();

  2314. 

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

  2316.                                  javaString (cameraId).get(),

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

  2318. 

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

  2320.             // callback, silence the redundant exception.

  2321.             jniCheckHasExceptionOccurredAndClear();

  2322.         }

  2323. 

  2324.         void close()

  2325.         {

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

  2327.             {

  2328.                 auto* env = getEnv();

  2329. 

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

  2331.                 {

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

  2333.                     closedEvent.wait (-1);

  2334.                 }

  2335. 

  2336.                 pendingClose.set (0);

  2337.                 pendingOpen .set (0);

  2338.                 cameraDevice.clear();

  2339.             }

  2340.         }

  2341. 

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

  2343. 

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

  2345. 

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

  2347.                                               const LocalRef<jobject>& surfacesList,

  2348.                                               GlobalRef& handlerToUse,

  2349.                                               int captureSessionTemplate)

  2350.         {

  2351.             if (! openedOk())

  2352.             {

  2353.                 jassertfalse;

  2354.                 return nullptr;

  2355.             }

  2356. 

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

  2358.         }

  2359. 

  2360.     private:

  2361.         Pimpl& owner;

  2362.         const String cameraId;

  2363.         GlobalRef& cameraManager;

  2364.         GlobalRef& handler;

  2365. 

  2366.         GlobalRef cameraStateCallback;

  2367.         int autoFocusMode;

  2368. 

  2369.         GlobalRef cameraDevice;

  2370.         Atomic<int> pendingOpen { 0 };

  2371.         Atomic<int> pendingClose { 0 };

  2372.         Atomic<int> fatalErrorOccurred { 0 };

  2373.         String openError;

  2374. 

  2375.         WaitableEvent closedEvent;

  2376. 

  2377.         //==============================================================================

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

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

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

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

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

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

  2384. 

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

  2386.         #undef JNI_CLASS_MEMBERS

  2387. 

  2388.         LocalRef<jobject> createCameraStateCallbackObject()

  2389.         {

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

  2391.                                                            CameraDeviceStateCallback.constructor,

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

  2393.         }

  2394. 

  2395.         //==============================================================================

  2396.         void cameraDeviceStateClosed()

  2397.         {

  2398.             JUCE_CAMERA_LOG ("cameraDeviceStateClosed()");

  2399. 

  2400.             closedEvent.signal();

  2401.         }

  2402. 

  2403.         void cameraDeviceStateDisconnected()

  2404.         {

  2405.             JUCE_CAMERA_LOG ("cameraDeviceStateDisconnected()");

  2406. 

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

  2408.             {

  2409.                 openError = "Device disconnected";

  2410. 

  2411.                 notifyOpenResult();

  2412.             }

  2413. 

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

  2415.         }

  2416. 

  2417.         void cameraDeviceStateError (int errorCode)

  2418.         {

  2419.             String error = cameraErrorCodeToString (errorCode);

  2420. 

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

  2422. 

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

  2424.             {

  2425.                 openError = error;

  2426. 

  2427.                 notifyOpenResult();

  2428.             }

  2429. 

  2430.             fatalErrorOccurred.set (1);

  2431. 

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

  2433.                                        {

  2434.                                            owner.cameraDeviceError (error);

  2435.                                            close();

  2436.                                        });

  2437.         }

  2438. 

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

  2440.         {

  2441.             JUCE_CAMERA_LOG ("cameraDeviceStateOpened()");

  2442. 

  2443.             pendingOpen.set (0);

  2444. 

  2445.             cameraDevice = GlobalRef (cameraDeviceToUse);

  2446. 

  2447.             notifyOpenResult();

  2448.         }

  2449. 

  2450.         void notifyOpenResult()

  2451.         {

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

  2453.         }

  2454. 

  2455.         //==============================================================================

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

  2457.         {

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

  2459.                 myself->cameraDeviceStateClosed();

  2460.         }

  2461. 

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

  2463.         {

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

  2465.                 myself->cameraDeviceStateDisconnected();

  2466.         }

  2467. 

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

  2469.         {

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

  2471.                 myself->cameraDeviceStateError (error);

  2472.         }

  2473. 

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

  2475.         {

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

  2477.             {

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

  2479. 

  2480.                 myself->cameraDeviceStateOpened (camera);

  2481.             }

  2482.         }

  2483.     };

  2484. 

  2485.     //==============================================================================

  2486.     struct CaptureSessionModeBase

  2487.     {

  2488.         virtual ~CaptureSessionModeBase() = default;

  2489. 

  2490.         virtual bool isVideoRecordSession() const = 0;

  2491. 

  2492.         virtual void triggerStillPictureCapture() = 0;

  2493.     };

  2494. 

  2495.     //==============================================================================

  2496.     template <typename Mode>

  2497.     struct CaptureSessionMode   : public CaptureSessionModeBase,

  2498.                                   private PreviewDisplay::Listener,

  2499.                                   private ScopedCameraDevice::CaptureSession::ConfiguredCallback

  2500.     {

  2501.         ~CaptureSessionMode() override

  2502.         {

  2503.             captureSession.reset();

  2504. 

  2505.             previewDisplay.removeListener (this);

  2506.         }

  2507. 

  2508.         bool isVideoRecordSession() const override

  2509.         {

  2510.             return Mode::isVideoRecord();

  2511.         }

  2512. 

  2513.         void triggerStillPictureCapture() override

  2514.         {

  2515.             if (captureSession == nullptr)

  2516.             {

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

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

  2519.                 jassertfalse;

  2520.                 return;

  2521.             }

  2522. 

  2523.             crtp().takeStillPicture();

  2524.         }

  2525. 

  2526.     protected:

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

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

  2529.                             int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

  2530.             : owner (ownerToUse),

  2531.               scopedCameraDevice (cameraDeviceToUse),

  2532.               handler (handlerToUse),

  2533.               previewDisplay (pd),

  2534.               cameraSensorOrientation (cameraSensorOrientationToUse),

  2535.               cameraLensFacing (cameraLensFacingToUse),

  2536.               streamConfigurationMap (streamConfigurationMapToUse)

  2537.         {

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

  2539. 

  2540.             if (weakRef == nullptr)

  2541.                 return;

  2542. 

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

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

  2545.             {

  2546.                 if (weakRef == nullptr)

  2547.                     return;

  2548. 

  2549.                 previewDisplay.addListener (this);

  2550.             });

  2551.         }

  2552. 

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

  2554. 

  2555.         void previewDisplayReady() override

  2556.         {

  2557.             jassert (previewDisplay.isReady());

  2558. 

  2559.             JUCE_CAMERA_LOG ("previewDisplayReady()");

  2560. 

  2561.             // close previous capture session first

  2562.             captureSession.reset();

  2563. 

  2564.             if (scopedCameraDevice.hasErrorOccurred())

  2565.             {

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

  2567.                 return;

  2568.             }

  2569. 

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

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

  2572.         }

  2573. 

  2574.         void previewDisplayAboutToBeDestroyed() override

  2575.         {

  2576.             JUCE_CAMERA_LOG ("previewDisplayAboutToBeDestroyed()");

  2577. 

  2578.             stopPreview();

  2579.         }

  2580. 

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

  2582.         {

  2583.             if (session == nullptr)

  2584.             {

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

  2586.                 return;

  2587.             }

  2588. 

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

  2590. 

  2591.             startSession();

  2592.         }

  2593. 

  2594.         void startSession()

  2595.         {

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

  2597.             {

  2598.                 jassertfalse;

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

  2600.             }

  2601. 

  2602.             crtp().sessionStarted();

  2603.         }

  2604. 

  2605.         void stopPreview()

  2606.         {

  2607.             if (captureSession != nullptr)

  2608.             {

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

  2610. 

  2611.                 auto* env = getEnv();

  2612. 

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

  2614. 

  2615.                 if (jniCheckHasExceptionOccurredAndClear())

  2616.                     return;

  2617. 

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

  2619. 

  2620.                 jniCheckHasExceptionOccurredAndClear();

  2621.             }

  2622.         }

  2623. 

  2624.         Pimpl& owner;

  2625.         ScopedCameraDevice& scopedCameraDevice;

  2626.         GlobalRef& handler;

  2627.         PreviewDisplay& previewDisplay;

  2628.         int cameraSensorOrientation;

  2629.         int cameraLensFacing;

  2630.         StreamConfigurationMap& streamConfigurationMap;

  2631. 

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

  2633. 

  2634.         JUCE_DECLARE_WEAK_REFERENCEABLE (CaptureSessionMode<Mode>)

  2635.     };

  2636. 

  2637.     //==============================================================================

  2638.     struct CaptureSessionPreviewMode : public CaptureSessionMode<CaptureSessionPreviewMode>

  2639.     {

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

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

  2642.                                    int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

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

  2644.                                                              sensorOrientation, cameraLensFacingToUse, streamConfigurationMapToUse),

  2645.               imageReader (ir)

  2646.         {

  2647.         }

  2648. 

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

  2650.         LocalRef<jobject> getCaptureSessionSurfaces() const

  2651.         {

  2652.             auto* env = getEnv();

  2653. 

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

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

  2656. 

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

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

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

  2660. 

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

  2662. 

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

  2664.             jassert (supported);

  2665. 

  2666.             return arrayList;

  2667.         }

  2668. 

  2669.         // Surfaces set as target during capture.

  2670.         LocalRef<jobject> getTargetSurfaces() const

  2671.         {

  2672.             auto* env = getEnv();

  2673. 

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

  2675. 

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

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

  2678. 

  2679.             return arrayList;

  2680.         }

  2681. 

  2682.         static int getTemplate()

  2683.         {

  2684.             static constexpr int templatePreview = 1;

  2685.             return templatePreview;

  2686.         }

  2687. 

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

  2689. 

  2690.         void sessionStarted() {}

  2691. 

  2692.         void takeStillPicture()

  2693.         {

  2694.             imageReader.resetNotificationFlag();

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

  2696.         }

  2697. 

  2698.     private:

  2699.         ImageReader& imageReader;

  2700.     };

  2701. 

  2702.     //==============================================================================

  2703.     struct CaptureSessionVideoRecordingMode : public CaptureSessionMode<CaptureSessionVideoRecordingMode>

  2704.     {

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

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

  2707.                                           int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

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

  2709.                                                                     sensorOrientation, cameraLensFacingToUse, streamConfigurationMapToUse),

  2710.               mediaRecorder (mr)

  2711.         {

  2712.         }

  2713. 

  2714.         ~CaptureSessionVideoRecordingMode()

  2715.         {

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

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

  2718.             stopPreview();

  2719. 

  2720.             mediaRecorder.stop();

  2721.         }

  2722. 

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

  2724.         LocalRef<jobject> getCaptureSessionSurfaces() const

  2725.         {

  2726.             auto* env = getEnv();

  2727. 

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

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

  2730. 

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

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

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

  2734. 

  2735.             return arrayList;

  2736.         }

  2737. 

  2738.         // Surfaces set as target during capture.

  2739.         LocalRef<jobject> getTargetSurfaces() const

  2740.         {

  2741.             // Same surfaces used.

  2742.             return getCaptureSessionSurfaces();

  2743.         }

  2744. 

  2745.         static int getTemplate()

  2746.         {

  2747.             static constexpr int templateRecord = 3;

  2748.             return templateRecord;

  2749.         }

  2750. 

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

  2752. 

  2753.         void sessionStarted()

  2754.         {

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

  2756.         }

  2757. 

  2758.         void takeStillPicture()

  2759.         {

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

  2761.             jassertfalse;

  2762.         }

  2763. 

  2764.     private:

  2765.         MediaRecorder& mediaRecorder;

  2766.     };

  2767. 

  2768.     //==============================================================================

  2769.     class DeviceOrientationChangeListener   : private Timer

  2770.     {

  2771.     public:

  2772.         DeviceOrientationChangeListener (PreviewDisplay& pd)

  2773.             : previewDisplay (pd),

  2774.               orientationEventListener (createOrientationEventListener()),

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

  2776.                                                             OrientationEventListener.canDetectOrientation) != 0),

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

  2778.               lastKnownScreenOrientation (deviceOrientation)

  2779.         {

  2780.             setEnabled (true);

  2781.         }

  2782. 

  2783.         ~DeviceOrientationChangeListener() override

  2784.         {

  2785.             setEnabled (false);

  2786.         }

  2787. 

  2788.         void setEnabled (bool shouldBeEnabled)

  2789.         {

  2790.             if (shouldBeEnabled && ! canDetectChange)

  2791.             {

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

  2793.                 jassertfalse;

  2794.                 return;

  2795.             }

  2796. 

  2797.             if (shouldBeEnabled)

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

  2799.             else

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

  2801.         }

  2802. 

  2803.         bool isSupported() const noexcept { return canDetectChange; }

  2804. 

  2805.         Desktop::DisplayOrientation getDeviceOrientation() const noexcept

  2806.         {

  2807.             return deviceOrientation;

  2808.         }

  2809. 

  2810.     private:

  2811.         PreviewDisplay& previewDisplay;

  2812. 

  2813.         GlobalRef orientationEventListener;

  2814.         static constexpr jint sensorDelayUI = 2;

  2815. 

  2816.         bool canDetectChange;

  2817.         Desktop::DisplayOrientation deviceOrientation;

  2818. 

  2819.         Desktop::DisplayOrientation lastKnownScreenOrientation;

  2820.         int numChecksForOrientationChange = 10;

  2821. 

  2822.         //==============================================================================

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

  2824.             METHOD (canDetectOrientation, "canDetectOrientation", "()Z") \

  2825.             METHOD (constructor,          "<init>",               "(JLandroid/content/Context;I)V") \

  2826.             METHOD (disable,              "disable",              "()V") \

  2827.             METHOD (enable,               "enable",               "()V") \

  2828.             CALLBACK (deviceOrientationChanged, "deviceOrientationChanged", "(JI)V")

  2829. 

  2830.         DECLARE_JNI_CLASS_WITH_MIN_SDK (OrientationEventListener, "com/rmsl/juce/JuceOrientationEventListener", 21)

  2831.         #undef JNI_CLASS_MEMBERS

  2832. 

  2833.         LocalRef<jobject> createOrientationEventListener()

  2834.         {

  2835.             return LocalRef<jobject> (getEnv()->NewObject (OrientationEventListener,

  2836.                                                            OrientationEventListener.constructor,

  2837.                                                            reinterpret_cast<jlong> (this),

  2838.                                                            getAppContext().get(),

  2839.                                                            sensorDelayUI));

  2840.         }

  2841. 

  2842.         //==============================================================================

  2843.         void orientationChanged (int orientation)

  2844.         {

  2845.             jassert (orientation < 360);

  2846. 

  2847.             // -1 == unknown

  2848.             if (orientation < 0)

  2849.                 return;

  2850. 

  2851.             auto oldOrientation = deviceOrientation;

  2852. 

  2853.             // NB: this assumes natural position to be portrait always, but some devices may be landscape...

  2854.             if (orientation > (360 - 45) || orientation < 45)

  2855.                 deviceOrientation = Desktop::upright;

  2856.             else if (orientation < 135)

  2857.                 deviceOrientation = Desktop::rotatedClockwise;

  2858.             else if (orientation < 225)

  2859.                 deviceOrientation = Desktop::upsideDown;

  2860.             else

  2861.                 deviceOrientation = Desktop::rotatedAntiClockwise;

  2862. 

  2863.             if (oldOrientation != deviceOrientation)

  2864.             {

  2865.                 lastKnownScreenOrientation = Desktop::getInstance().getCurrentOrientation();

  2866. 

  2867.                 // Need to update preview transform, but screen orientation will change slightly

  2868.                 // later than sensor orientation.

  2869.                 startTimer (500);

  2870.             }

  2871.         }

  2872. 

  2873.         void timerCallback() override

  2874.         {

  2875.             auto currentOrientation = Desktop::getInstance().getCurrentOrientation();

  2876. 

  2877.             if (lastKnownScreenOrientation != currentOrientation)

  2878.             {

  2879.                 lastKnownScreenOrientation = currentOrientation;

  2880. 

  2881.                 stopTimer();

  2882.                 numChecksForOrientationChange = 10;

  2883.                 previewDisplay.updateSurfaceTransform();

  2884. 

  2885.                 return;

  2886.             }

  2887. 

  2888.             if (--numChecksForOrientationChange == 0)

  2889.             {

  2890.                 stopTimer();

  2891.                 numChecksForOrientationChange = 10;

  2892.             }

  2893.         }

  2894. 

  2895.         static void deviceOrientationChanged (JNIEnv*, jobject /*obj*/, jlong host, jint orientation)

  2896.         {

  2897.             if (auto* myself = reinterpret_cast<DeviceOrientationChangeListener*> (host))

  2898.                 myself->orientationChanged (orientation);

  2899.         }

  2900.     };

  2901. 

  2902.     //==============================================================================

  2903.     CameraDevice& owner;

  2904.     int minWidth, minHeight, maxWidth, maxHeight;

  2905. 

  2906.     String cameraId;

  2907.     InternalOpenCameraResultCallback cameraOpenCallback;

  2908. 

  2909.     GlobalRef activityLifeListener;

  2910. 

  2911.     GlobalRef cameraManager;

  2912.     GlobalRef cameraCharacteristics;

  2913.     GlobalRef handlerThread;

  2914.     GlobalRef handler;

  2915. 

  2916.     StreamConfigurationMap streamConfigurationMap;

  2917.     PreviewDisplay previewDisplay;

  2918.     DeviceOrientationChangeListener deviceOrientationChangeListener;

  2919.     std::unique_ptr<ImageReader> imageReader;

  2920.     std::unique_ptr<MediaRecorder> mediaRecorder;

  2921. 

  2922.     std::unique_ptr<CaptureSessionModeBase> currentCaptureSessionMode;

  2923. 

  2924.     std::unique_ptr<ScopedCameraDevice> scopedCameraDevice;

  2925. 

  2926.     CriticalSection listenerLock;

  2927.     ListenerList<Listener> listeners;

  2928. 

  2929.     std::function<void(const Image&)> pictureTakenCallback;

  2930. 

  2931.     Time firstRecordedFrameTimeMs;

  2932.     bool notifiedOfCameraOpening = false;

  2933. 

  2934.     bool appWasPaused = false;

  2935. 

  2936.     //==============================================================================

  2937.     int getCameraSensorOrientation() const

  2938.     {

  2939.         return getCameraCharacteristicsIntegerKeyValue (CameraCharacteristics.SENSOR_ORIENTATION);

  2940.     }

  2941. 

  2942.     int getAutoFocusModeToUse() const

  2943.     {

  2944.         auto supportedModes = getSupportedAutoFocusModes();

  2945. 

  2946.         enum

  2947.         {

  2948.             CONTROL_AF_MODE_OFF = 0,

  2949.             CONTROL_AF_MODE_AUTO = 1,

  2950.             CONTROL_AF_MODE_CONTINUOUS_PICTURE = 4

  2951.         };

  2952. 

  2953.         if (supportedModes.contains (CONTROL_AF_MODE_CONTINUOUS_PICTURE))

  2954.             return CONTROL_AF_MODE_CONTINUOUS_PICTURE;

  2955. 

  2956.         if (supportedModes.contains (CONTROL_AF_MODE_AUTO))

  2957.             return CONTROL_AF_MODE_AUTO;

  2958. 

  2959.         return CONTROL_AF_MODE_OFF;

  2960.     }

  2961. 

  2962.     Array<int> getSupportedAutoFocusModes() const

  2963.     {

  2964.         auto* env = getEnv();

  2965. 

  2966.         auto jKey = LocalRef<jobject> (env->GetStaticObjectField (CameraCharacteristics, CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES));

  2967. 

  2968.         auto supportedModes = LocalRef<jintArray> ((jintArray) env->CallObjectMethod (cameraCharacteristics,

  2969.                                                                                       CameraCharacteristics.get,

  2970.                                                                                       jKey.get()));

  2971. 

  2972.         return jintArrayToJuceArray (supportedModes);

  2973.     }

  2974. 

  2975.     static Array<int> jintArrayToJuceArray (const LocalRef<jintArray>& jArray)

  2976.     {

  2977.         auto* env = getEnv();

  2978. 

  2979.         auto* jArrayElems = env->GetIntArrayElements (jArray, nullptr);

  2980.         auto numElems = env->GetArrayLength (jArray);

  2981. 

  2982.         Array<int> juceArray;

  2983. 

  2984.         for (int s = 0; s < numElems; ++s)

  2985.             juceArray.add (jArrayElems[s]);

  2986. 

  2987.         env->ReleaseIntArrayElements (jArray, jArrayElems, 0);

  2988.         return juceArray;

  2989.     }

  2990. 

  2991.     int getCameraCharacteristicsIntegerKeyValue (jfieldID key) const

  2992.     {

  2993.         auto* env = getEnv();

  2994. 

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

  2996. 

  2997.         auto jValue = LocalRef<jobject> (env->CallObjectMethod (cameraCharacteristics,

  2998.                                                                 CameraCharacteristics.get,

  2999.                                                                 jKey.get()));

  3000. 

  3001.         return env->CallIntMethod (jValue, JavaInteger.intValue);

  3002.     }

  3003. 

  3004.     int getCameraLensFacing() const

  3005.     {

  3006.         return getCameraCharacteristicsIntegerKeyValue (CameraCharacteristics.LENS_FACING);

  3007.     }

  3008. 

  3009.     //==============================================================================

  3010.     void cameraOpenFinished (const String& error)

  3011.     {

  3012.         JUCE_CAMERA_LOG ("cameraOpenFinished(), error = " + error);

  3013. 

  3014.         if (error.isEmpty())

  3015.         {

  3016.             setupStillImageSize();

  3017.             startPreviewMode (*imageReader);

  3018.         }

  3019. 

  3020.         // Do not notify about camera being reopened on app resume.

  3021.         if (! notifiedOfCameraOpening)

  3022.         {

  3023.             notifiedOfCameraOpening = true;

  3024. 

  3025.             invokeCameraOpenCallback (error);

  3026.         }

  3027.     }

  3028. 

  3029.     void cameraDeviceError (const String& error)

  3030.     {

  3031.         if (owner.onErrorOccurred != nullptr)

  3032.             owner.onErrorOccurred (error);

  3033.     }

  3034. 

  3035.     void invokeCameraOpenCallback (const String& error)

  3036.     {

  3037.         JUCE_CAMERA_LOG ("invokeCameraOpenCallback(), error = " + error);

  3038. 

  3039.         if (cameraOpenCallback != nullptr)

  3040.             cameraOpenCallback (cameraId, error);

  3041.     }

  3042. 

  3043.     //==============================================================================

  3044.     void callListeners (const Image& image)

  3045.     {

  3046.         const ScopedLock sl (listenerLock);

  3047.         listeners.call ([=] (Listener& l) { l.imageReceived (image); });

  3048.     }

  3049. 

  3050.     void notifyPictureTaken (const Image& image)

  3051.     {

  3052.         JUCE_CAMERA_LOG ("notifyPictureTaken()");

  3053. 

  3054.         if (pictureTakenCallback != nullptr)

  3055.             pictureTakenCallback (image);

  3056.     }

  3057. 

  3058.     void triggerStillPictureCapture()

  3059.     {

  3060.         currentCaptureSessionMode->triggerStillPictureCapture();

  3061.     }

  3062. 

  3063.     //==============================================================================

  3064.     void setupStillImageSize()

  3065.     {

  3066.         imageReader.reset();

  3067. 

  3068.         auto imageSize = chooseBestSize (minWidth, minHeight, maxWidth, maxHeight,

  3069.                                          streamConfigurationMap.getSupportedStillImageOutputSizes());

  3070. 

  3071.         imageReader.reset (new ImageReader (*this, handler, imageSize.getWidth(), imageSize.getHeight(),

  3072.                                             getCameraSensorOrientation()));

  3073.     }

  3074. 

  3075.     static Rectangle<int> chooseBestSize (int minWidth, int minHeight, int maxWidth, int maxHeight,

  3076.                                           Array<Rectangle<int>> supportedSizes)

  3077.     {

  3078.         Rectangle<int> result;

  3079. 

  3080.         for (auto& size : supportedSizes)

  3081.         {

  3082.             auto width  = size.getWidth();

  3083.             auto height = size.getHeight();

  3084. 

  3085.             if (width < minWidth || width > maxWidth || height < minHeight || height > maxHeight)

  3086.                 continue;

  3087. 

  3088.             if (size.contains (result))

  3089.                 result = size;

  3090.         }

  3091. 

  3092.         // None of the supported sizes matches required width & height limitations, picking

  3093.         // the first one available...

  3094.         jassert (! result.isEmpty());

  3095. 

  3096.         if (result.isEmpty())

  3097.             result = supportedSizes[0];

  3098. 

  3099.         return result;

  3100.     }

  3101. 

  3102.     //==============================================================================

  3103.     void startPreviewMode (ImageReader& ir)

  3104.     {

  3105.         if (currentCaptureSessionMode != nullptr && ! currentCaptureSessionMode->isVideoRecordSession())

  3106.             return;

  3107. 

  3108.         // previous mode has to be stopped first

  3109.         jassert (currentCaptureSessionMode.get() == nullptr);

  3110. 

  3111.         if (scopedCameraDevice == nullptr || ! scopedCameraDevice->openedOk())

  3112.             return;

  3113. 

  3114.         currentCaptureSessionMode.reset (new CaptureSessionPreviewMode (*this, *scopedCameraDevice, handler,

  3115.                                                                         previewDisplay, ir,

  3116.                                                                         getCameraSensorOrientation(),

  3117.                                                                         getCameraLensFacing(),

  3118.                                                                         streamConfigurationMap));

  3119.     }

  3120. 

  3121.     void startVideoRecordingMode (MediaRecorder& mr)

  3122.     {

  3123.         if (currentCaptureSessionMode != nullptr && currentCaptureSessionMode->isVideoRecordSession())

  3124.             return;

  3125. 

  3126.         // previous mode has to be stopped first

  3127.         jassert (currentCaptureSessionMode.get() == nullptr);

  3128. 

  3129.         jassert (scopedCameraDevice != nullptr && scopedCameraDevice->openedOk());

  3130. 

  3131.         if (scopedCameraDevice == nullptr || ! scopedCameraDevice->openedOk())

  3132.             return;

  3133. 

  3134.         currentCaptureSessionMode.reset (new CaptureSessionVideoRecordingMode (*this, *scopedCameraDevice, handler,

  3135.                                                                                previewDisplay, mr,

  3136.                                                                                getCameraSensorOrientation(),

  3137.                                                                                getCameraLensFacing(),

  3138.                                                                                streamConfigurationMap));

  3139.     }

  3140. 

  3141.     //==============================================================================

  3142.     void onActivityPaused (jobject) override

  3143.     {

  3144.         JUCE_CAMERA_LOG ("appPaused, closing camera...");

  3145. 

  3146.         appWasPaused = true;

  3147. 

  3148.         deviceOrientationChangeListener.setEnabled (false);

  3149. 

  3150.         // We need to restart the whole session mode when the app gets resumed.

  3151.         currentCaptureSessionMode.reset();

  3152. 

  3153.         if (scopedCameraDevice != nullptr)

  3154.             scopedCameraDevice->close();

  3155. 

  3156.         stopBackgroundThread();

  3157.     }

  3158. 

  3159.     void onActivityResumed (jobject) override

  3160.     {

  3161.         // Only care about resumed event when paused event was called first.

  3162.         if (! appWasPaused)

  3163.             return;

  3164. 

  3165.         JUCE_CAMERA_LOG ("appResumed, opening camera...");

  3166. 

  3167.         deviceOrientationChangeListener.setEnabled (true);

  3168. 

  3169.         startBackgroundThread();

  3170. 

  3171.         if (scopedCameraDevice != nullptr)

  3172.             scopedCameraDevice->open();

  3173.     }

  3174. 

  3175.     void startBackgroundThread()

  3176.     {

  3177.         auto* env = getEnv();

  3178. 

  3179.         handlerThread = GlobalRef (LocalRef<jobject> (env->NewObject (AndroidHandlerThread,

  3180.                                                                       AndroidHandlerThread.constructor,

  3181.                                                                       javaString ("JuceCameraDeviceBackgroundThread").get())));

  3182.         // handler thread has to be started before its looper can be fetched

  3183.         env->CallVoidMethod (handlerThread, AndroidHandlerThread.start);

  3184.         handler = GlobalRef (LocalRef<jobject> (env->NewObject (AndroidHandler,

  3185.                                                                 AndroidHandler.constructorWithLooper,

  3186.                                                                 env->CallObjectMethod (handlerThread, AndroidHandlerThread.getLooper))));

  3187.     }

  3188. 

  3189.     void stopBackgroundThread()

  3190.     {

  3191.         auto* env = getEnv();

  3192. 

  3193.         auto quitSafelyMethod = env->GetMethodID(AndroidHandlerThread, "quitSafely", "()Z");

  3194. 

  3195.         // this code will only run on SDK >= 21

  3196.         jassert(quitSafelyMethod != nullptr);

  3197. 

  3198.         env->CallBooleanMethod (handlerThread, quitSafelyMethod);

  3199.         env->CallVoidMethod (handlerThread, AndroidHandlerThread.join);

  3200. 

  3201.         jniCheckHasExceptionOccurredAndClear();

  3202. 

  3203.         handlerThread.clear();

  3204.         handler.clear();

  3205.     }

  3206. 

  3207.     friend struct CameraDevice::ViewerComponent;

  3208. 

  3209.     JUCE_DECLARE_NON_COPYABLE (Pimpl)

  3210. };

  3211. 

  3212. //==============================================================================

  3213. struct CameraDevice::ViewerComponent  : public Component,

  3214.                                         private ComponentMovementWatcher

  3215. {

  3216.     ViewerComponent (CameraDevice& device) : ComponentMovementWatcher (this)

  3217.     {

  3218.         auto previewSize = device.pimpl->streamConfigurationMap.getDefaultPreviewSize();

  3219. 

  3220.         targetAspectRatio = previewSize.getWidth() / (float) previewSize.getHeight();

  3221. 

  3222.         if (isOrientationLandscape())

  3223.             setBounds (previewSize);

  3224.         else

  3225.             setBounds (0, 0, previewSize.getHeight(), previewSize.getWidth());

  3226. 

  3227.         addAndMakeVisible (viewerComponent);

  3228.         viewerComponent.setView (device.pimpl->previewDisplay.getNativeView());

  3229.     }

  3230. 

  3231. private:

  3232.     AndroidViewComponent viewerComponent;

  3233. 

  3234.     float targetAspectRatio = 1.0f;

  3235. 

  3236.     void componentMovedOrResized (bool, bool) override

  3237.     {

  3238.         auto b = getLocalBounds();

  3239. 

  3240.         auto targetWidth  = b.getWidth();

  3241.         auto targetHeight = b.getHeight();

  3242. 

  3243.         if (isOrientationLandscape())

  3244.         {

  3245.             auto currentAspectRatio = b.getWidth() / (float) b.getHeight();

  3246. 

  3247.             if (currentAspectRatio > targetAspectRatio)

  3248.                 targetWidth = static_cast<int> (targetWidth * targetAspectRatio / currentAspectRatio);

  3249.             else

  3250.                 targetHeight = static_cast<int> (targetHeight * currentAspectRatio / targetAspectRatio);

  3251.         }

  3252.         else

  3253.         {

  3254.             auto currentAspectRatio = b.getHeight() / (float) b.getWidth();

  3255. 

  3256.             if (currentAspectRatio > targetAspectRatio)

  3257.                 targetHeight = static_cast<int> (targetHeight * targetAspectRatio / currentAspectRatio);

  3258.             else

  3259.                 targetWidth = static_cast<int> (targetWidth * currentAspectRatio / targetAspectRatio);

  3260.         }

  3261. 

  3262.         viewerComponent.setBounds (Rectangle<int> (0, 0, targetWidth, targetHeight).withCentre (b.getCentre()));

  3263.     }

  3264. 

  3265.     bool isOrientationLandscape() const

  3266.     {

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

  3268.         return o == Desktop::rotatedClockwise || o == Desktop::rotatedAntiClockwise;

  3269.     }

  3270. 

  3271.     void componentPeerChanged() override {}

  3272.     void componentVisibilityChanged() override {}

  3273. 

  3274.     JUCE_DECLARE_NON_COPYABLE (ViewerComponent)

  3275. };

  3276. 

  3277. String CameraDevice::getFileExtension()

  3278. {

  3279.     return ".mp4";

  3280. }

  3281. 

  3282. //==============================================================================

  3283. CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::StillPictureTaker::CameraCaptureSessionCaptureCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::StillPictureTaker::CameraCaptureSessionCaptureCallback;

  3284. CameraDevice::Pimpl::ScopedCameraDevice::CameraDeviceStateCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CameraDeviceStateCallback;

  3285. CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::CameraCaptureSessionStateCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::CameraCaptureSessionStateCallback;

  3286. CameraDevice::Pimpl::DeviceOrientationChangeListener::OrientationEventListener_Class CameraDevice::Pimpl::DeviceOrientationChangeListener::OrientationEventListener;