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

3286 lines
146KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

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

  6. 

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

  8.    licensing.

  9. 

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

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

  12. 

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

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

  15. 

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

  17.    www.gnu.org/licenses).

  18. 

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

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

  21.    DISCLAIMED.

  22. 

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

  24. */

  25. 

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

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

  28. //

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

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

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

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

  33. //

  34. // files with min sdk version 21

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

  36. static const uint8 CameraSupportByteCode[] =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  92. 0,0,0,0};

  93. 

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

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

  96. 

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

  98. #undef JNI_CLASS_MEMBERS

  99. 

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

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

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

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

  104. 

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

  106. #undef JNI_CLASS_MEMBERS

  107. 

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

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

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

  111. 

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

  113. #undef JNI_CLASS_MEMBERS

  114. 

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

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

  117. 

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

  119. #undef JNI_CLASS_MEMBERS

  120. 

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

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

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

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

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

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

  127. 

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

  129. #undef JNI_CLASS_MEMBERS

  130. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  150. 

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

  152. #undef JNI_CLASS_MEMBERS

  153. 

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

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

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

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

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

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

  160. 

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

  162. #undef JNI_CLASS_MEMBERS

  163. 

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

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

  166. 

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

  168. #undef JNI_CLASS_MEMBERS

  169. 

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

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

  172. 

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

  174. #undef JNI_CLASS_MEMBERS

  175. 

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

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

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

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

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

  181. 

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

  183. #undef JNI_CLASS_MEMBERS

  184. 

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

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

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

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

  189. 

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

  191. #undef JNI_CLASS_MEMBERS

  192. 

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

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

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

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

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

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

  199. 

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

  201. #undef JNI_CLASS_MEMBERS

  202. 

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

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

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

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

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

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

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

  210. 

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

  212. #undef JNI_CLASS_MEMBERS

  213. 

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

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

  216. 

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

  218. #undef JNI_CLASS_MEMBERS

  219. 

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

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

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

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

  224. 

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

  226. #undef JNI_CLASS_MEMBERS

  227. 

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

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

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

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

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

  233. 

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

  235. #undef JNI_CLASS_MEMBERS

  236. 

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

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

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

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

  241. 

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

  243. #undef JNI_CLASS_MEMBERS

  244. 

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

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

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

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

  249. 

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

  251. #undef JNI_CLASS_MEMBERS

  252. 

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

  254. class AndroidRunnable  : public juce::AndroidInterfaceImplementer

  255. {

  256. public:

  257.     struct Owner

  258.     {

  259.         virtual ~Owner() {}

  260. 

  261.         virtual void run() = 0;

  262.     };

  263. 

  264.     AndroidRunnable (Owner& ownerToUse)

  265.         : owner (ownerToUse)

  266.     {}

  267. 

  268. private:

  269.     Owner& owner;

  270. 

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

  272.     {

  273.         auto* env = getEnv();

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

  275. 

  276.         if (methodName == "run")

  277.         {

  278.             owner.run();

  279.             return nullptr;

  280.         }

  281. 

  282.         // invoke base class

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

  284.     }

  285. };

  286. 

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

  288. class TextureViewSurfaceTextureListener     : public AndroidInterfaceImplementer

  289. {

  290. public:

  291.     struct Owner

  292.     {

  293.         virtual ~Owner() {}

  294. 

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

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

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

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

  299.     };

  300. 

  301.     TextureViewSurfaceTextureListener (Owner& ownerToUse)

  302.         : owner (ownerToUse)

  303.     {}

  304. 

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

  306.     {

  307.         auto* env = getEnv();

  308. 

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

  310. 

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

  312. 

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

  314.         {

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

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

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

  318. 

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

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

  321. 

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

  323.             return nullptr;

  324.         }

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

  326.         {

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

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

  329. 

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

  331.         }

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

  333.         {

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

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

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

  337. 

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

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

  340. 

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

  342.             return nullptr;

  343.         }

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

  345.         {

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

  347. 

  348.             owner.onSurfaceTextureUpdated (surface);

  349.             return nullptr;

  350.         }

  351. 

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

  353.     }

  354. 

  355. private:

  356.     Owner& owner;

  357. };

  358. 

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

  360. class ImageReaderOnImageAvailableListener     : public AndroidInterfaceImplementer

  361. {

  362. public:

  363.     struct Owner

  364.     {

  365.         virtual ~Owner() {}

  366. 

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

  368.     };

  369. 

  370.     ImageReaderOnImageAvailableListener (Owner& ownerToUse)

  371.         : owner (ownerToUse)

  372.     {}

  373. 

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

  375.     {

  376.         auto* env = getEnv();

  377. 

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

  379. 

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

  381. 

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

  383.         {

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

  385. 

  386.             owner.onImageAvailable (imageReader);

  387.             return nullptr;

  388.         }

  389. 

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

  391.     }

  392. 

  393. private:

  394.     Owner& owner;

  395. };

  396. 

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

  398. class MediaRecorderOnInfoListener     : public AndroidInterfaceImplementer

  399. {

  400. public:

  401.     struct Owner

  402.     {

  403.         virtual ~Owner() {}

  404. 

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

  406.     };

  407. 

  408.     MediaRecorderOnInfoListener (Owner& ownerToUse)

  409.         : owner (ownerToUse)

  410.     {}

  411. 

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

  413.     {

  414.         auto* env = getEnv();

  415. 

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

  417. 

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

  419. 

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

  421.         {

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

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

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

  425. 

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

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

  428. 

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

  430.             return nullptr;

  431.         }

  432. 

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

  434.     }

  435. 

  436. private:

  437.     Owner& owner;

  438. };

  439. 

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

  441. class MediaRecorderOnErrorListener     : public AndroidInterfaceImplementer

  442. {

  443. public:

  444.     struct Owner

  445.     {

  446.         virtual ~Owner() {}

  447. 

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

  449.     };

  450. 

  451.     MediaRecorderOnErrorListener (Owner& ownerToUse)

  452.         : owner (ownerToUse)

  453.     {}

  454. 

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

  456.     {

  457.         auto* env = getEnv();

  458. 

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

  460. 

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

  462. 

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

  464.         {

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

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

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

  468. 

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

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

  471. 

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

  473.             return nullptr;

  474.         }

  475. 

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

  477.     }

  478. 

  479. private:

  480.     Owner& owner;

  481. };

  482. 

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

  484. struct CameraDevice::Pimpl

  485.     : private ActivityLifecycleCallbacks

  486. {

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

  488. 

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

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

  491.            bool /*useHighQuality*/)

  492.         : owner (ownerToUse),

  493.           minWidth (minWidthToUse),

  494.           minHeight (minHeightToUse),

  495.           maxWidth (maxWidthToUse),

  496.           maxHeight (maxHeightToUse),

  497.           cameraId (cameraIdToUse),

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

  499.           cameraManager (initialiseCameraManager()),

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

  501.           streamConfigurationMap (cameraCharacteristics),

  502.           previewDisplay (streamConfigurationMap.getPreviewBufferSize()),

  503.           deviceOrientationChangeListener (previewDisplay)

  504.     {

  505.         startBackgroundThread();

  506.     }

  507. 

  508.     ~Pimpl() override

  509.     {

  510.         auto* env = getEnv();

  511. 

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

  513.         activityLifeListener.clear();

  514.     }

  515. 

  516.     JUCE_DECLARE_WEAK_REFERENCEABLE (Pimpl)

  517. 

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

  519. 

  520.     void open (InternalOpenCameraResultCallback cameraOpenCallbackToUse)

  521.     {

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

  523. 

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

  525.         jassert (cameraOpenCallback != nullptr);

  526. 

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

  528.         jassert (scopedCameraDevice == nullptr);

  529. 

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

  531.             return;

  532. 

  533.         RuntimePermissions::request (RuntimePermissions::camera,

  534.                                      [safeThis = WeakReference<Pimpl> { this }] (bool granted) mutable

  535.                                      {

  536.                                          if (safeThis != nullptr)

  537.                                              safeThis->continueOpenRequest (granted);

  538.                                      });

  539.     }

  540. 

  541.     void continueOpenRequest (bool granted)

  542.     {

  543.         if (getAndroidSDKVersion() >= 21)

  544.         {

  545.             if (granted)

  546.             {

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

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

  549.             }

  550.             else

  551.             {

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

  553.             }

  554.         }

  555.         else

  556.         {

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

  558.         }

  559.     }

  560. 

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

  562. 

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

  564.     {

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

  566.         {

  567.             jassertfalse;

  568.             return;

  569.         }

  570. 

  571.         if (currentCaptureSessionMode->isVideoRecordSession())

  572.         {

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

  574.             jassertfalse;

  575.             return;

  576.         }

  577. 

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

  579. 

  580.         triggerStillPictureCapture();

  581.     }

  582. 

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

  584.     {

  585.         if (! openedOk())

  586.         {

  587.             jassertfalse;

  588.             return;

  589.         }

  590. 

  591.         if (! previewDisplay.isReady())

  592.         {

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

  594.             jassertfalse;

  595.             return;

  596.         }

  597. 

  598.         file.deleteFile();

  599.         file.create();

  600.         jassert (file.existsAsFile());

  601. 

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

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

  604.                                          streamConfigurationMap.getSupportedVideoRecordingOutputSizes());

  605. 

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

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

  608. 

  609.         firstRecordedFrameTimeMs = Time::getCurrentTime();

  610. 

  611.         currentCaptureSessionMode.reset();

  612.         startVideoRecordingMode (*mediaRecorder);

  613.     }

  614. 

  615.     void stopRecording()

  616.     {

  617.         currentCaptureSessionMode.reset();

  618.         mediaRecorder.reset();

  619. 

  620.         startPreviewMode (*imageReader);

  621.     }

  622. 

  623.     Time getTimeOfFirstRecordedFrame() const

  624.     {

  625.         return firstRecordedFrameTimeMs;

  626.     }

  627. 

  628.     static StringArray getAvailableDevices()

  629.     {

  630.         if (getAndroidSDKVersion() < 21)

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

  632. 

  633.         StringArray results;

  634. 

  635.         auto* env = getEnv();

  636. 

  637.         auto cameraManagerToUse = initialiseCameraManager();

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

  639.                                                                                            CameraManager.getCameraIdList));

  640. 

  641.         results = javaStringArrayToJuce (cameraIdArray);

  642. 

  643.         for (auto& result : results)

  644.             printDebugCameraInfo (cameraManagerToUse, result);

  645. 

  646.         return results;

  647.     }

  648. 

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

  650.     {

  651.         const ScopedLock sl (listenerLock);

  652.         listeners.add (listenerToAdd);

  653. 

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

  655.             triggerStillPictureCapture();

  656.     }

  657. 

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

  659.     {

  660.         const ScopedLock sl (listenerLock);

  661.         listeners.remove (listenerToRemove);

  662.     }

  663. 

  664. private:

  665.     enum

  666.     {

  667.         ERROR_CAMERA_IN_USE = 1,

  668.         ERROR_MAX_CAMERAS_IN_USE = 2,

  669.         ERROR_CAMERA_DISABLED = 3,

  670.         ERROR_CAMERA_DEVICE = 4,

  671.         ERROR_CAMERA_SERVICE = 5

  672.     };

  673. 

  674.     static String cameraErrorCodeToString (int errorCode)

  675.     {

  676.         switch (errorCode)

  677.         {

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

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

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

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

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

  683.             default:                       return "Unknown error.";

  684.         }

  685.     }

  686. 

  687.     static LocalRef<jobject> initialiseCameraManager()

  688.     {

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

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

  691.     }

  692. 

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

  694.     {

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

  696.                                                               CameraManager.getCameraCharacteristics,

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

  698.     }

  699. 

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

  701.     {

  702.         auto* env = getEnv();

  703. 

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

  705.                                                                          CameraManager.getCameraCharacteristics,

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

  707. 

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

  709. 

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

  711. 

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

  713. 

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

  715.         {

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

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

  718.             auto keyName = juceString (jKeyName);

  719. 

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

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

  722.             auto keyValueString = juceString (jKeyValueString);

  723. 

  724.             auto &kvs = keyValueString;

  725. 

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

  727.             {

  728.                 printPrimitiveArrayElements (keyValue, keyName, keyValueString);

  729.             }

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

  731.             {

  732.                 printRangeArrayElements (keyValue, keyName);

  733.             }

  734.             else

  735.             {

  736.                 int chunkSize = 256;

  737. 

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

  739.                 {

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

  741. 

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

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

  744.                 }

  745.                 else

  746.                 {

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

  748.                 }

  749.             }

  750. 

  751.             ignoreUnused (keyName);

  752.         }

  753.     }

  754. 

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

  756.                                              const String& keyValueString)

  757.     {

  758.         ignoreUnused (keyName);

  759. 

  760.         String result = "[";

  761. 

  762.         auto* env = getEnv();

  763. 

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

  765.         {                                                                                                           \

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

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

  768.                                                                                                                     \

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

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

  771.                                                                                                                     \

  772.             if (size > 0)                                                                                           \

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

  774.                                                                                                                     \

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

  776.         }

  777. 

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

  779.             PRINT_ELEMENTS (jint, jintArray, Int)

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

  781.             PRINT_ELEMENTS (float, jfloatArray, Float)

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

  783.             PRINT_ELEMENTS (jboolean, jbooleanArray, Boolean)

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

  785.             PRINT_ELEMENTS (jbyte, jbyteArray, Byte);

  786. 

  787.         #undef PRINT_ELEMENTS

  788. 

  789.         result << "]";

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

  791.     }

  792. 

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

  794.     {

  795.         auto* env = getEnv();

  796. 

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

  798. 

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

  800. 

  801.         String result;

  802. 

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

  804.         {

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

  806. 

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

  808. 

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

  810.         }

  811. 

  812.         ignoreUnused (keyName);

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

  814.     }

  815. 

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

  817.     class StreamConfigurationMap

  818.     {

  819.     public:

  820.         StreamConfigurationMap (const GlobalRef& cameraCharacteristicsToUse)

  821.             : scalerStreamConfigurationMap (getStreamConfigurationMap (cameraCharacteristicsToUse)),

  822.               supportedPreviewOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

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

  824.                                                                 -1)),

  825.               supportedStillImageOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

  826.                                                                    LocalRef<jobject>(),

  827.                                                                    jpegImageFormat)),

  828.               supportedVideoRecordingOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

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

  830.                                                                        -1)),

  831.               defaultPreviewSize (getSmallestSize (supportedPreviewOutputSizes)),

  832.               previewBufferSize (getLargestSize (supportedPreviewOutputSizes))

  833.         {

  834.             printSizesLog (supportedPreviewOutputSizes, "SurfaceTexture");

  835.             printSizesLog (supportedStillImageOutputSizes, "JPEG");

  836.             printSizesLog (supportedVideoRecordingOutputSizes, "MediaRecorder");

  837.         }

  838. 

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

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

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

  842. 

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

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

  845. 

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

  847.         {

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

  849.         }

  850. 

  851.         static constexpr int jpegImageFormat = 256;

  852. 

  853.     private:

  854.         GlobalRef scalerStreamConfigurationMap;

  855. 

  856.         Array<Rectangle<int>> supportedPreviewOutputSizes;

  857.         Array<Rectangle<int>> supportedStillImageOutputSizes;

  858.         Array<Rectangle<int>> supportedVideoRecordingOutputSizes;

  859.         Rectangle<int> defaultPreviewSize, previewBufferSize;

  860. 

  861.         GlobalRef getStreamConfigurationMap (const GlobalRef& cameraCharacteristicsToUse)

  862.         {

  863.             auto* env = getEnv();

  864. 

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

  866.                                                                                                  CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP));

  867. 

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

  869.                                                                         CameraCharacteristics.get,

  870.                                                                         scalerStreamConfigurationMapKey.get())));

  871.         }

  872. 

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

  874.                                                           const LocalRef<jobject>& outputClass,

  875.                                                           int format)

  876.         {

  877.             Array<Rectangle<int>> result;

  878. 

  879.             auto* env = getEnv();

  880. 

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

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

  883.                                                                                              AndroidStreamConfigurationMap.getOutputSizesForClass,

  884.                                                                                              outputClass.get()))

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

  886.                                                                                              AndroidStreamConfigurationMap.getOutputSizesForFormat,

  887.                                                                                              (jint) format));

  888. 

  889.             if (format != -1)

  890.             {

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

  892. 

  893.                 if (! supported)

  894.                 {

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

  896.                     jassertfalse;

  897.                     return {};

  898.                 }

  899.             }

  900. 

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

  902. 

  903.             jassert (numSizes > 0);

  904. 

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

  906.             {

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

  908. 

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

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

  911. 

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

  913.             }

  914. 

  915.             return result;

  916.         }

  917. 

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

  919.         {

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

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

  922.         }

  923. 

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

  925.         {

  926.             ignoreUnused (sizes, className);

  927. 

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

  929. 

  930.           #if JUCE_CAMERA_LOG_ENABLED

  931.             for (auto& s : sizes)

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

  933.           #endif

  934.         }

  935. 

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

  937.         {

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

  939.                 return {};

  940. 

  941.             auto smallestSize = sizes[0];

  942. 

  943.             for (auto& size : sizes)

  944.             {

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

  946.                     smallestSize = size;

  947.             }

  948. 

  949.             return smallestSize;

  950.         }

  951. 

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

  953.         {

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

  955.                 return {};

  956. 

  957.             auto largestSize = sizes[0];

  958. 

  959.             for (auto& size : sizes)

  960.             {

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

  962.                     largestSize = size;

  963.             }

  964. 

  965.             return largestSize;

  966.         }

  967.     };

  968. 

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

  970.     class PreviewDisplay    : private TextureViewSurfaceTextureListener::Owner

  971.     {

  972.     public:

  973.         struct Listener

  974.         {

  975.             virtual ~Listener() {}

  976. 

  977.             virtual void previewDisplayReady() = 0;

  978.             virtual void previewDisplayAboutToBeDestroyed() = 0;

  979.         };

  980. 

  981.         PreviewDisplay (Rectangle<int> bufferSize)

  982.             : textureViewSurfaceTextureListener (*this),

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

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

  985.               bufferWidth (bufferSize.getWidth()),

  986.               bufferHeight (bufferSize.getHeight())

  987.         {

  988.             auto* env = getEnv();

  989. 

  990.             if (! isReady())

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

  992.                                      CreateJavaInterface (&textureViewSurfaceTextureListener,

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

  994.         }

  995. 

  996.         ~PreviewDisplay() override

  997.         {

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

  999.         }

  1000. 

  1001.         void addListener (Listener* l)

  1002.         {

  1003.             if (l == nullptr)

  1004.             {

  1005.                 jassertfalse;

  1006.                 return;

  1007.             }

  1008. 

  1009.             listeners.add (l);

  1010. 

  1011.             if (isReady())

  1012.                 l->previewDisplayReady();

  1013.         }

  1014. 

  1015.         void removeListener (Listener* l)

  1016.         {

  1017.             if (l == nullptr)

  1018.             {

  1019.                 jassertfalse;

  1020.                 return;

  1021.             }

  1022. 

  1023.             listeners.remove (l);

  1024.         }

  1025. 

  1026.         bool isReady() const

  1027.         {

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

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

  1030.         }

  1031. 

  1032.         LocalRef<jobject> createSurface()

  1033.         {

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

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

  1036.             if (! isReady())

  1037.                 return LocalRef<jobject> (nullptr);

  1038. 

  1039.             auto* env = getEnv();

  1040. 

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

  1042.                                                                             AndroidTextureView.getSurfaceTexture));

  1043. 

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

  1045.             //     can result in a cropped preview.

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

  1047. 

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

  1049. 

  1050.             return surface;

  1051.         }

  1052. 

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

  1054. 

  1055.         void updateSurfaceTransform()

  1056.         {

  1057.             auto* env = getEnv();

  1058. 

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

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

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

  1062. 

  1063.             static constexpr int rotation90 = 1;

  1064.             static constexpr int rotation270 = 3;

  1065. 

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

  1067. 

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

  1069.             {

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

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

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

  1073.             }

  1074. 

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

  1076.         }

  1077. 

  1078.     private:

  1079.         ListenerList<Listener> listeners;

  1080. 

  1081.         TextureViewSurfaceTextureListener textureViewSurfaceTextureListener;

  1082.         GlobalRef textureView;

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

  1084.         int bufferWidth, bufferHeight;

  1085. 

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

  1087.         {

  1088.             JUCE_CAMERA_LOG ("onSurfaceTextureAvailable()");

  1089. 

  1090.             width = widthToUse;

  1091.             height = heightToUse;

  1092. 

  1093.             updateSurfaceTransform();

  1094. 

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

  1096.         }

  1097. 

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

  1099.         {

  1100.             JUCE_CAMERA_LOG ("onSurfaceTextureDestroyed()");

  1101. 

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

  1103. 

  1104.             return true;

  1105.         }

  1106. 

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

  1108.         {

  1109.             JUCE_CAMERA_LOG ("onSurfaceTextureSizeChanged()");

  1110. 

  1111.             width = widthToUse;

  1112.             height = heightToUse;

  1113. 

  1114.             updateSurfaceTransform();

  1115.         }

  1116. 

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

  1118.         {

  1119.             JUCE_CAMERA_LOG ("onSurfaceTextureUpdated()");

  1120.         }

  1121. 

  1122.         JUCE_DECLARE_NON_COPYABLE (PreviewDisplay)

  1123.     };

  1124. 

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

  1126.     class ImageReader   : private ImageReaderOnImageAvailableListener::Owner

  1127.     {

  1128.     public:

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

  1130.                      int imageWidth, int imageHeight, int cameraSensorOrientationToUse)

  1131.             : owner (ownerToUse),

  1132.               cameraSensorOrientation (cameraSensorOrientationToUse),

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

  1134.                                                                                 imageWidth, imageHeight, StreamConfigurationMap::jpegImageFormat,

  1135.                                                                                 numImagesToKeep))),

  1136.               onImageAvailableListener (*this)

  1137.         {

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

  1139.                                       CreateJavaInterface (&onImageAvailableListener,

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

  1141.                                       handlerToUse.get());

  1142.         }

  1143. 

  1144.         ~ImageReader() override

  1145.         {

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

  1147.         }

  1148. 

  1149.         LocalRef<jobject> getSurface() const

  1150.         {

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

  1152.         }

  1153. 

  1154.         void resetNotificationFlag()

  1155.         {

  1156.             hasNotifiedListeners.set (0);

  1157.         }

  1158. 

  1159.     private:

  1160.         Pimpl& owner;

  1161.         int cameraSensorOrientation;

  1162. 

  1163.         GlobalRef imageReader;

  1164.         ImageReaderOnImageAvailableListener onImageAvailableListener;

  1165.         static constexpr int numImagesToKeep = 2;

  1166.         Atomic<int> hasNotifiedListeners { 0 };

  1167. 

  1168.         JUCE_DECLARE_WEAK_REFERENCEABLE (ImageReader)

  1169. 

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

  1171.         {

  1172.             JUCE_CAMERA_LOG ("onImageAvailable()");

  1173. 

  1174.             auto* env = getEnv();

  1175. 

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

  1177. 

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

  1179.                 return;

  1180. 

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

  1182. 

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

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

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

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

  1187.                                                                  cameraLensFrontFacing,

  1188.                                                                  cameraSensorOrientation);

  1189. 

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

  1191. 

  1192.             owner.callListeners (image);

  1193. 

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

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

  1196.                 MessageManager::callAsync ([safeThis = WeakReference<ImageReader> { this }, image]() mutable

  1197.                 {

  1198.                     if (safeThis != nullptr)

  1199.                         safeThis->owner.notifyPictureTaken (image);

  1200.                 });

  1201.         }

  1202. 

  1203.         struct ImageBuffer

  1204.         {

  1205.             LocalRef<jbyteArray> byteArray;

  1206.             int size;

  1207.         };

  1208. 

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

  1210.                                                              Desktop::DisplayOrientation deviceOrientationFromAccelerometerSensor,

  1211.                                                              Desktop::DisplayOrientation targetOrientation,

  1212.                                                              bool cameraLensFrontFacing,

  1213.                                                              int cameraSensorOrientation)

  1214.         {

  1215.             auto* env = getEnv();

  1216. 

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

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

  1219. 

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

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

  1222. 

  1223.             ImageBuffer correctedBuffer = getImageBufferWithCorrectedOrientationFrom (byteBuffer, deviceOrientationFromAccelerometerSensor,

  1224.                                                                                       targetOrientation, cameraLensFrontFacing, cameraSensorOrientation);

  1225. 

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

  1227. 

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

  1229. 

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

  1231. 

  1232.             return result;

  1233.         }

  1234. 

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

  1236.                                                                        Desktop::DisplayOrientation deviceOrientationFromAccelerometerSensor,

  1237.                                                                        Desktop::DisplayOrientation targetOrientation,

  1238.                                                                        bool cameraLensFrontFacing,

  1239.                                                                        int cameraSensorOrientation)

  1240.         {

  1241.             auto* env = getEnv();

  1242. 

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

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

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

  1246. 

  1247.             auto rotationAngle = getRotationAngle (deviceOrientationFromAccelerometerSensor, targetOrientation,

  1248.                                                   cameraLensFrontFacing, cameraSensorOrientation);

  1249. 

  1250.             if (rotationAngle == 0)

  1251.             {

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

  1253.                 return { byteArray, bufferSize };

  1254.             }

  1255. 

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

  1257.                                                                               AndroidBitmapFactory.decodeByteArray,

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

  1259. 

  1260.             if (origBitmap == nullptr)

  1261.             {

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

  1263.                 return { byteArray, bufferSize };

  1264.             }

  1265. 

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

  1267. 

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

  1269.                                                                             ByteArrayOutputStream.constructor));

  1270. 

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

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

  1273.                                                                                   AndroidBitmapCompressFormat.valueOf,

  1274.                                                                                   jCompressFormatString.get()));

  1275. 

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

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

  1278.             {

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

  1280.                                                                                                     ByteArrayOutputStream.toByteArray));

  1281. 

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

  1283. 

  1284.                 return { correctedByteArray, correctedByteArraySize };

  1285.             }

  1286. 

  1287.             jassertfalse;

  1288.             // fallback, return original bitmap

  1289.             return { byteArray, bufferSize };

  1290.         }

  1291. 

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

  1293.                                      Desktop::DisplayOrientation targetOrientation,

  1294.                                      bool cameraLensFrontFacing,

  1295.                                      int cameraSensorOrientation)

  1296.         {

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

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

  1299. 

  1300.             if (cameraLensFrontFacing && isSensorOrientationHorizontal)

  1301.             {

  1302.                 // flip angles for front camera

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

  1304.             }

  1305. 

  1306.             switch (targetOrientation)

  1307.             {

  1308.                 case Desktop::rotatedAntiClockwise:

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

  1310.                 case Desktop::rotatedClockwise:

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

  1312.                 case Desktop::upright:

  1313.                 case Desktop::upsideDown:

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

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

  1316.                     {

  1317.                         return cameraSensorOrientation;

  1318.                     }

  1319.                     else

  1320.                     {

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

  1322.                             return cameraSensorOrientation;

  1323.                         else

  1324.                             return (cameraSensorOrientation + 180) % 360;

  1325.                     }

  1326.                     break;

  1327.                 case Desktop::allOrientations:

  1328.                 default:

  1329.                     return 0;

  1330.             }

  1331.         }

  1332. 

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

  1334.         {

  1335.             auto* env = getEnv();

  1336. 

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

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

  1339. 

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

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

  1342. 

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

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

  1345.                                                                                  (jint) origBitmapWidth, (jint) origBitmapHeight,

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

  1347. 

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

  1349. 

  1350.             return rotatedBitmap;

  1351.         }

  1352.     };

  1353. 

  1354.     //==============================================================================

  1355.     class MediaRecorder : private MediaRecorderOnInfoListener::Owner,

  1356.                           private MediaRecorderOnErrorListener::Owner

  1357.     {

  1358.     public:

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

  1360.                        int sensorOrientation, int cameraLensFacing)

  1361.             : onInfoListener (*this),

  1362.               onErrorListener (*this),

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

  1364.                                                                      AndroidMediaRecorder.constructor)))

  1365.         {

  1366.             auto* env = getEnv();

  1367. 

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

  1369.                                  CreateJavaInterface (&onInfoListener,

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

  1371. 

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

  1373.                                  CreateJavaInterface (&onErrorListener,

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

  1375. 

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

  1377.             //     the order is changed.

  1378.             static constexpr int audioSourceMic = 1;

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

  1380. 

  1381.             static constexpr int videoSourceSurface = 2;

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

  1383. 

  1384.             static constexpr int outputFormatMPEG4 = 2;

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

  1386. 

  1387.             static constexpr int audioEncoderAAC = 3;

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

  1389. 

  1390.             static constexpr int videoEncoderH264 = 2;

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

  1392. 

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

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

  1395. 

  1396.             auto frontFacing = cameraLensFacing == 0;

  1397. 

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

  1399. 

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

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

  1402. 

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

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

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

  1406.         }

  1407. 

  1408.         ~MediaRecorder() override

  1409.         {

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

  1411.         }

  1412. 

  1413.         LocalRef<jobject> getSurface()

  1414.         {

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

  1416.         }

  1417. 

  1418.         void start()

  1419.         {

  1420.             lockScreenOrientation();

  1421. 

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

  1423. 

  1424.             hasStartedRecording = true;

  1425.         }

  1426. 

  1427.         void stop()

  1428.         {

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

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

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

  1432.             if (! hasStartedRecording)

  1433.                 return;

  1434. 

  1435.             hasStartedRecording = false;

  1436. 

  1437.             auto* env = getEnv();

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

  1439. 

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

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

  1442.             jniCheckHasExceptionOccurredAndClear();

  1443. 

  1444.             unlockScreenOrientation();

  1445.         }

  1446. 

  1447.     private:

  1448.         MediaRecorderOnInfoListener onInfoListener;

  1449.         MediaRecorderOnErrorListener onErrorListener;

  1450.         GlobalRef mediaRecorder;

  1451.         bool hasStartedRecording = false;

  1452.         int orientationsEnabled = -1;

  1453. 

  1454.         void lockScreenOrientation()

  1455.         {

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

  1457. 

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

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

  1460.         }

  1461. 

  1462.         static jint juceOrientationToNativeOrientation (int orientations) noexcept

  1463.         {

  1464.             enum

  1465.             {

  1466.                 SCREEN_ORIENTATION_LANDSCAPE          = 0,

  1467.                 SCREEN_ORIENTATION_PORTRAIT           = 1,

  1468.                 SCREEN_ORIENTATION_USER               = 2,

  1469.                 SCREEN_ORIENTATION_REVERSE_LANDSCAPE  = 8,

  1470.                 SCREEN_ORIENTATION_REVERSE_PORTRAIT   = 9,

  1471.                 SCREEN_ORIENTATION_USER_LANDSCAPE     = 11,

  1472.                 SCREEN_ORIENTATION_USER_PORTRAIT      = 12,

  1473.             };

  1474. 

  1475.             switch (orientations)

  1476.             {

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

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

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

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

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

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

  1483.                 default:                                                        return (jint) SCREEN_ORIENTATION_USER;

  1484.             }

  1485.         }

  1486. 

  1487.         void unlockScreenOrientation()

  1488.         {

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

  1490.         }

  1491. 

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

  1493.         {

  1494.             ignoreUnused (recorder, what, extra);

  1495. 

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

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

  1498.         }

  1499. 

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

  1501.         {

  1502.             ignoreUnused (recorder, what, extra);

  1503. 

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

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

  1506.         }

  1507. 

  1508.         static String getInfoStringFromCode (int what)

  1509.         {

  1510.             enum

  1511.             {

  1512.                 MEDIA_RECORDER_INFO_UNKNOWN = 1,

  1513.                 MEDIA_RECORDER_INFO_MAX_DURATION_REACHED = 800,

  1514.                 MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED = 801,

  1515.                 MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING = 802,

  1516.                 MEDIA_RECORDER_INFO_NEXT_OUTPUT_FILE_STARTED = 803

  1517.             };

  1518. 

  1519.             switch (what)

  1520.             {

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

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

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

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

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

  1526.                 default: return String (what);

  1527.             };

  1528.         }

  1529. 

  1530.         static String getErrorStringFromCode (int what)

  1531.         {

  1532.             enum

  1533.             {

  1534.                 MEDIA_RECORDER_ERROR_UNKNOWN = 1,

  1535.                 MEDIA_ERROR_SERVER_DIED = 100

  1536.             };

  1537. 

  1538.             switch (what)

  1539.             {

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

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

  1542.                 default: return String (what);

  1543.             };

  1544.         }

  1545. 

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

  1547.         {

  1548.             auto* env = getEnv();

  1549. 

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

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

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

  1553. 

  1554.             enum

  1555.             {

  1556.                 ROTATION_0 = 0,

  1557.                 ROTATION_90,

  1558.                 ROTATION_180,

  1559.                 ROTATION_270

  1560.             };

  1561. 

  1562.             int hint = 0;

  1563. 

  1564.             switch (rotation)

  1565.             {

  1566.                 case ROTATION_0:   hint = cameraSensorOrientation;       break;

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

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

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

  1570.                 default: jassertfalse;

  1571.             }

  1572. 

  1573.             return (hint + 360) % 360;

  1574.         }

  1575.     };

  1576. 

  1577.     //==============================================================================

  1578.     class ScopedCameraDevice

  1579.     {

  1580.     public:

  1581.         //==============================================================================

  1582.         class CaptureSession

  1583.         {

  1584.         public:

  1585.             struct ConfiguredCallback

  1586.             {

  1587.                 virtual ~ConfiguredCallback() {}

  1588. 

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

  1590.             };

  1591. 

  1592.             ~CaptureSession()

  1593.             {

  1594.                 bool calledClose = false;

  1595. 

  1596.                 auto* env = getEnv();

  1597. 

  1598.                 {

  1599.                     const ScopedLock lock (captureSessionLock);

  1600. 

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

  1602.                     {

  1603.                         calledClose = true;

  1604. 

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

  1606.                     }

  1607.                 }

  1608. 

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

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

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

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

  1613.                 {

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

  1615.                 }

  1616.                 else if (calledClose)

  1617.                 {

  1618.                     pendingClose.set (1);

  1619.                     closedEvent.wait (-1);

  1620.                 }

  1621.             }

  1622. 

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

  1624. 

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

  1626. 

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

  1628.             {

  1629.                 if (! openedOk())

  1630.                 {

  1631.                     jassertfalse;

  1632.                     return false;

  1633.                 }

  1634. 

  1635.                 auto* env = getEnv();

  1636. 

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

  1638. 

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

  1640.                 {

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

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

  1643.                 }

  1644. 

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

  1646. 

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

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

  1649. 

  1650.                 return true;

  1651.             }

  1652. 

  1653.             void takeStillPicture (jobject targetSurface)

  1654.             {

  1655.                 if (stillPictureTaker == nullptr)

  1656.                 {

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

  1658.                     jassertfalse;

  1659.                     return;

  1660.                 }

  1661. 

  1662.                 auto* env = getEnv();

  1663. 

  1664.                 static constexpr int templateStillCapture = 2;

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

  1666.                                                                          AndroidCameraDevice.createCaptureRequest,

  1667.                                                                          (jint) templateStillCapture));

  1668. 

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

  1670. 

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

  1672. 

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

  1674. 

  1675.                 stillPictureTaker->takePicture (stillPictureCaptureRequest);

  1676.             }

  1677. 

  1678.         private:

  1679.             //==============================================================================

  1680.             class StillPictureTaker   : private AndroidRunnable::Owner

  1681.             {

  1682.             public:

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

  1684.                                    GlobalRef& previewCaptureRequestToUse, GlobalRef& handlerToUse,

  1685.                                    int autoFocusModeToUse)

  1686.                     : captureSession (captureSessionToUse),

  1687.                       captureRequestBuilder (captureRequestBuilderToUse),

  1688.                       previewCaptureRequest (previewCaptureRequestToUse),

  1689.                       handler (handlerToUse),

  1690.                       runnable (*this),

  1691.                       captureSessionPreviewCaptureCallback (createCaptureSessionCallback (true)),

  1692.                       captureSessionStillPictureCaptureCallback (createCaptureSessionCallback (false)),

  1693.                       autoFocusMode (autoFocusModeToUse)

  1694.                 {

  1695.                 }

  1696. 

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

  1698.                 {

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

  1700. 

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

  1702. 

  1703.                     lockFocus();

  1704.                 }

  1705. 

  1706.             private:

  1707.                 GlobalRef& captureSession;

  1708.                 GlobalRef& captureRequestBuilder;

  1709.                 GlobalRef& previewCaptureRequest;

  1710.                 GlobalRef& handler;

  1711. 

  1712.                 AndroidRunnable runnable;

  1713.                 GlobalRef delayedCaptureRunnable;

  1714. 

  1715.                 GlobalRef captureSessionPreviewCaptureCallback;

  1716. 

  1717.                 GlobalRef stillPictureCaptureRequest;

  1718.                 GlobalRef captureSessionStillPictureCaptureCallback;

  1719. 

  1720.                 int autoFocusMode;

  1721. 

  1722.                 //==============================================================================

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

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

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

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

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

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

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

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

  1731. 

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

  1733.                 #undef JNI_CLASS_MEMBERS

  1734. 

  1735.                 LocalRef<jobject> createCaptureSessionCallback (bool createPreviewSession)

  1736.                 {

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

  1738.                                                                   CameraCaptureSessionCaptureCallback.constructor,

  1739.                                                                   reinterpret_cast<jlong> (this),

  1740.                                                                   createPreviewSession ? 1 : 0));

  1741.                 }

  1742. 

  1743.                 //==============================================================================

  1744. 

  1745.                 enum class State

  1746.                 {

  1747.                     idle = 0,

  1748.                     pendingFocusLock,

  1749.                     pendingExposurePrecapture,

  1750.                     pendingExposurePostPrecapture,

  1751.                     pictureTaken

  1752.                 };

  1753. 

  1754.                 State currentState = State::idle;

  1755. 

  1756.                 void lockFocus()

  1757.                 {

  1758.                     if (jniCheckHasExceptionOccurredAndClear())

  1759.                         return;

  1760. 

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

  1762. 

  1763.                     currentState = State::pendingFocusLock;

  1764. 

  1765.                     auto* env = getEnv();

  1766. 

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

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

  1769.                     static constexpr int controlAfTriggerStart = 1;

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

  1771.                                                                         CaptureRequest.CONTROL_AF_TRIGGER,

  1772.                                                                         controlAfTriggerStart);

  1773. 

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

  1775.                                                                                     CaptureRequestBuilder.build));

  1776. 

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

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

  1779.                 }

  1780. 

  1781.                 void updateState (jobject captureResult)

  1782.                 {

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

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

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

  1786.                     if (jniCheckHasExceptionOccurredAndClear())

  1787.                         return;

  1788. 

  1789.                     switch (currentState)

  1790.                     {

  1791.                         case State::pendingFocusLock:

  1792.                         {

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

  1794. 

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

  1796. 

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

  1798.                             {

  1799.                                 captureStillPictureDelayed();

  1800.                                 return;

  1801.                             }

  1802. 

  1803.                             auto autoToFocusNotAvailable = autoFocusMode == 0;

  1804. 

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

  1806.                             {

  1807.                                 auto controlAeStateIntValue = getControlAEState (captureResult);

  1808.                                 static constexpr int controlAeStateConverged = 2;

  1809. 

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

  1811.                                 {

  1812.                                     currentState = State::pictureTaken;

  1813.                                     captureStillPictureDelayed();

  1814.                                 }

  1815.                                 else

  1816.                                 {

  1817.                                     runPrecaptureSequence();

  1818.                                 }

  1819.                             }

  1820. 

  1821.                             break;

  1822.                         }

  1823. 

  1824.                         case State::pendingExposurePrecapture:

  1825.                         {

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

  1827. 

  1828.                             auto controlAeStateIntValue = getControlAEState (captureResult);

  1829.                             static constexpr int controlAeStateFlashRequired = 4;

  1830.                             static constexpr int controlAeStatePrecapture = 5;

  1831. 

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

  1833.                                                              || controlAeStateIntValue == controlAeStatePrecapture)

  1834.                             {

  1835.                                 currentState = State::pendingExposurePostPrecapture;

  1836.                             }

  1837. 

  1838.                             break;

  1839.                         }

  1840. 

  1841.                         case State::pendingExposurePostPrecapture:

  1842.                         {

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

  1844. 

  1845.                             auto controlAeStateIntValue = getControlAEState (captureResult);

  1846.                             static constexpr int controlAeStatePrecapture = 5;

  1847. 

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

  1849.                             {

  1850.                                 currentState = State::pictureTaken;

  1851.                                 captureStillPictureDelayed();

  1852.                             }

  1853. 

  1854.                             break;

  1855.                         }

  1856.                         case State::idle:

  1857.                         case State::pictureTaken:

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

  1859.                     };

  1860.                 }

  1861. 

  1862.                 static int getControlAEState (jobject captureResult)

  1863.                 {

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

  1865. 

  1866.                     return controlAeStateValue.get() != nullptr

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

  1868.                 }

  1869. 

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

  1871.                 {

  1872.                     static constexpr int controlAfStateFocusedLocked = 4;

  1873.                     static constexpr int controlAfStateNotFocusedLocked = 5;

  1874. 

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

  1876. 

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

  1878.                 }

  1879. 

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

  1881.                 {

  1882.                     auto* env = getEnv();

  1883. 

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

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

  1886.                 }

  1887. 

  1888.                 void captureStillPictureDelayed()

  1889.                 {

  1890.                     if (jniCheckHasExceptionOccurredAndClear())

  1891.                         return;

  1892. 

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

  1894. 

  1895.                     auto* env = getEnv();

  1896. 

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

  1898. 

  1899.                     if (jniCheckHasExceptionOccurredAndClear())

  1900.                         return;

  1901. 

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

  1903. 

  1904.                     if (jniCheckHasExceptionOccurredAndClear())

  1905.                         return;

  1906. 

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

  1908.                     // stopRepeating/abortCaptures calls.

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

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

  1911. 

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

  1913.                 }

  1914. 

  1915.                 void runPrecaptureSequence()

  1916.                 {

  1917.                     if (jniCheckHasExceptionOccurredAndClear())

  1918.                         return;

  1919. 

  1920.                     auto* env = getEnv();

  1921. 

  1922.                     static constexpr int controlAePrecaptureTriggerStart = 1;

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

  1924.                                                                         CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,

  1925.                                                                         controlAePrecaptureTriggerStart);

  1926. 

  1927.                     currentState = State::pendingExposurePrecapture;

  1928. 

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

  1930.                                                                                     CaptureRequestBuilder.build));

  1931. 

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

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

  1934.                 }

  1935. 

  1936.                 void unlockFocus()

  1937.                 {

  1938.                     if (jniCheckHasExceptionOccurredAndClear())

  1939.                         return;

  1940. 

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

  1942. 

  1943.                     currentState = State::idle;

  1944. 

  1945.                     auto* env = getEnv();

  1946. 

  1947.                     static constexpr int controlAfTriggerCancel = 2;

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

  1949.                                                                         CaptureRequest.CONTROL_AF_TRIGGER,

  1950.                                                                         controlAfTriggerCancel);

  1951. 

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

  1953.                                                                                            CaptureRequestBuilder.build));

  1954. 

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

  1956.                                         nullptr, handler.get());

  1957. 

  1958.                     if (jniCheckHasExceptionOccurredAndClear())

  1959.                         return;

  1960. 

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

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

  1963.                                         nullptr, handler.get());

  1964.                 }

  1965.                 //==============================================================================

  1966.                 void run() override

  1967.                 {

  1968.                     captureStillPicture();

  1969.                 }

  1970. 

  1971.                 void captureStillPicture()

  1972.                 {

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

  1974.                                              stillPictureCaptureRequest.get(), captureSessionStillPictureCaptureCallback.get(),

  1975.                                              nullptr);

  1976.                 }

  1977. 

  1978.                 //==============================================================================

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

  1980.                 {

  1981.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureCompleted()");

  1982. 

  1983.                     ignoreUnused (session, request);

  1984. 

  1985.                     if (isPreview)

  1986.                         updateState (result);

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

  1988.                         unlockFocus();

  1989.                 }

  1990. 

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

  1992.                 {

  1993.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureFailed()");

  1994. 

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

  1996.                 }

  1997. 

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

  1999.                 {

  2000.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureProgressed()");

  2001. 

  2002.                     ignoreUnused (session, request);

  2003. 

  2004.                     if (isPreview)

  2005.                         updateState (partialResult);

  2006.                 }

  2007. 

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

  2009.                 {

  2010.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureSequenceAborted()");

  2011. 

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

  2013.                 }

  2014. 

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

  2016.                 {

  2017.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureSequenceCompleted()");

  2018. 

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

  2020.                 }

  2021. 

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

  2023.                 {

  2024.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureStarted()");

  2025. 

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

  2027.                 }

  2028. 

  2029.                 //==============================================================================

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

  2031.                 {

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

  2033.                     {

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

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

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

  2037. 

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

  2039.                     }

  2040.                 }

  2041. 

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

  2043.                 {

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

  2045.                     {

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

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

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

  2049. 

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

  2051.                     }

  2052.                 }

  2053. 

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

  2055.                 {

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

  2057.                     {

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

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

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

  2061. 

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

  2063.                     }

  2064.                 }

  2065. 

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

  2067.                 {

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

  2069.                     {

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

  2071. 

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

  2073.                     }

  2074.                 }

  2075. 

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

  2077.                 {

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

  2079.                     {

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

  2081. 

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

  2083.                     }

  2084.                 }

  2085. 

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

  2087.                 {

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

  2089.                     {

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

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

  2092. 

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

  2094.                     }

  2095.                 }

  2096.             };

  2097. 

  2098.             //==============================================================================

  2099.             ScopedCameraDevice& scopedCameraDevice;

  2100.             ConfiguredCallback& configuredCallback;

  2101.             GlobalRef& handler;

  2102. 

  2103.             GlobalRef captureRequestBuilder;

  2104.             GlobalRef previewCaptureRequest;

  2105. 

  2106.             GlobalRef captureSessionStateCallback;

  2107.             int autoFocusMode;

  2108. 

  2109.             GlobalRef captureSession;

  2110.             CriticalSection captureSessionLock;

  2111. 

  2112.             Atomic<int> pendingClose { 0 };

  2113. 

  2114.             std::unique_ptr<StillPictureTaker> stillPictureTaker;

  2115. 

  2116.             WaitableEvent closedEvent;

  2117. 

  2118.             JUCE_DECLARE_WEAK_REFERENCEABLE (CaptureSession)

  2119. 

  2120.             //==============================================================================

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

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

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

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

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

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

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

  2128. 

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

  2130.             #undef JNI_CLASS_MEMBERS

  2131. 

  2132. 

  2133.             //==============================================================================

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

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

  2136.                             int captureSessionTemplate, int autoFocusModeToUse)

  2137.                 : scopedCameraDevice (scopedCameraDeviceToUse),

  2138.                   configuredCallback (configuredCallbackToUse),

  2139.                   handler (handlerToUse),

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

  2141.                                                                                         AndroidCameraDevice.createCaptureRequest,

  2142.                                                                                         (jint) captureSessionTemplate))),

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

  2144.                                                                                        CameraCaptureSessionStateCallback.constructor,

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

  2146.                   autoFocusMode (autoFocusModeToUse)

  2147.             {

  2148.                 auto* env = getEnv();

  2149. 

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

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

  2152. 

  2153.                 static constexpr int controlModeAuto = 1;

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

  2155. 

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

  2157.             }

  2158. 

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

  2160.             {

  2161.                 auto* env = getEnv();

  2162. 

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

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

  2165. 

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

  2167.             }

  2168. 

  2169.             void cameraCaptureSessionActive (jobject session)

  2170.             {

  2171.                 JUCE_CAMERA_LOG ("cameraCaptureSessionActive()");

  2172.                 ignoreUnused (session);

  2173.             }

  2174. 

  2175.             void cameraCaptureSessionClosed (jobject session)

  2176.             {

  2177.                 JUCE_CAMERA_LOG ("cameraCaptureSessionClosed()");

  2178.                 ignoreUnused (session);

  2179. 

  2180.                 closedEvent.signal();

  2181.             }

  2182. 

  2183.             void cameraCaptureSessionConfigureFailed (jobject session)

  2184.             {

  2185.                 JUCE_CAMERA_LOG ("cameraCaptureSessionConfigureFailed()");

  2186.                 ignoreUnused (session);

  2187. 

  2188.                 MessageManager::callAsync ([weakRef = WeakReference<CaptureSession> { this }]

  2189.                 {

  2190.                     if (weakRef != nullptr)

  2191.                         weakRef->configuredCallback.captureSessionConfigured (nullptr);

  2192.                 });

  2193.             }

  2194. 

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

  2196.             {

  2197.                 JUCE_CAMERA_LOG ("cameraCaptureSessionConfigured()");

  2198. 

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

  2200.                 {

  2201.                     // Already closing, bailout.

  2202.                     closedEvent.signal();

  2203. 

  2204.                     GlobalRef s (session);

  2205. 

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

  2207.                         {

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

  2209.                         });

  2210. 

  2211.                     return;

  2212.                 }

  2213. 

  2214.                 {

  2215.                     const ScopedLock lock (captureSessionLock);

  2216.                     captureSession = GlobalRef (session);

  2217.                 }

  2218. 

  2219.                 MessageManager::callAsync ([weakRef = WeakReference<CaptureSession> { this }]

  2220.                 {

  2221.                     if (weakRef == nullptr)

  2222.                         return;

  2223. 

  2224.                     weakRef->stillPictureTaker.reset (new StillPictureTaker (weakRef->captureSession,

  2225.                                                                              weakRef->captureRequestBuilder,

  2226.                                                                              weakRef->previewCaptureRequest,

  2227.                                                                              weakRef->handler,

  2228.                                                                              weakRef->autoFocusMode));

  2229. 

  2230.                     weakRef->configuredCallback.captureSessionConfigured (weakRef.get());

  2231.                 });

  2232.             }

  2233. 

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

  2235.             {

  2236.                 JUCE_CAMERA_LOG ("cameraCaptureSessionReady()");

  2237.                 ignoreUnused (session);

  2238.             }

  2239. 

  2240.             //==============================================================================

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

  2242.             {

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

  2244.                 {

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

  2246. 

  2247.                     myself->cameraCaptureSessionActive (session);

  2248.                 }

  2249.             }

  2250. 

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

  2252.             {

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

  2254.                 {

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

  2256. 

  2257.                     myself->cameraCaptureSessionClosed (session);

  2258.                 }

  2259.             }

  2260. 

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

  2262.             {

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

  2264.                 {

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

  2266. 

  2267.                     myself->cameraCaptureSessionConfigureFailed (session);

  2268.                 }

  2269.             }

  2270. 

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

  2272.             {

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

  2274.                 {

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

  2276. 

  2277.                     myself->cameraCaptureSessionConfigured (session);

  2278.                 }

  2279.             }

  2280. 

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

  2282.             {

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

  2284.                 {

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

  2286. 

  2287.                     myself->cameraCaptureSessionReady (session);

  2288.                 }

  2289.             }

  2290. 

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

  2292.             friend class ScopedCameraDevice;

  2293. 

  2294.             JUCE_DECLARE_NON_COPYABLE (CaptureSession)

  2295.         };

  2296. 

  2297.         //==============================================================================

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

  2299.                             GlobalRef& handlerToUse, int autoFocusModeToUse)

  2300.             : owner (ownerToUse),

  2301.               cameraId (cameraIdToUse),

  2302.               cameraManager (cameraManagerToUse),

  2303.               handler (handlerToUse),

  2304.               cameraStateCallback (createCameraStateCallbackObject()),

  2305.               autoFocusMode (autoFocusModeToUse)

  2306.         {

  2307.             open();

  2308.         }

  2309. 

  2310.         ~ScopedCameraDevice()

  2311.         {

  2312.             close();

  2313.         }

  2314. 

  2315.         void open()

  2316.         {

  2317.             pendingOpen.set (1);

  2318. 

  2319.             auto* env = getEnv();

  2320. 

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

  2322.                                  javaString (cameraId).get(),

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

  2324. 

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

  2326.             // callback, silence the redundant exception.

  2327.             jniCheckHasExceptionOccurredAndClear();

  2328.         }

  2329. 

  2330.         void close()

  2331.         {

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

  2333.             {

  2334.                 auto* env = getEnv();

  2335. 

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

  2337.                 {

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

  2339.                     closedEvent.wait (-1);

  2340.                 }

  2341. 

  2342.                 pendingClose.set (0);

  2343.                 pendingOpen .set (0);

  2344.                 cameraDevice.clear();

  2345.             }

  2346.         }

  2347. 

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

  2349. 

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

  2351. 

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

  2353.                                               const LocalRef<jobject>& surfacesList,

  2354.                                               GlobalRef& handlerToUse,

  2355.                                               int captureSessionTemplate)

  2356.         {

  2357.             if (! openedOk())

  2358.             {

  2359.                 jassertfalse;

  2360.                 return nullptr;

  2361.             }

  2362. 

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

  2364.         }

  2365. 

  2366.     private:

  2367.         Pimpl& owner;

  2368.         const String cameraId;

  2369.         GlobalRef& cameraManager;

  2370.         GlobalRef& handler;

  2371. 

  2372.         GlobalRef cameraStateCallback;

  2373.         int autoFocusMode;

  2374. 

  2375.         GlobalRef cameraDevice;

  2376.         Atomic<int> pendingOpen { 0 };

  2377.         Atomic<int> pendingClose { 0 };

  2378.         Atomic<int> fatalErrorOccurred { 0 };

  2379.         String openError;

  2380. 

  2381.         WaitableEvent closedEvent;

  2382. 

  2383.         //==============================================================================

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

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

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

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

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

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

  2390. 

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

  2392.         #undef JNI_CLASS_MEMBERS

  2393. 

  2394.         LocalRef<jobject> createCameraStateCallbackObject()

  2395.         {

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

  2397.                                                            CameraDeviceStateCallback.constructor,

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

  2399.         }

  2400. 

  2401.         //==============================================================================

  2402.         void cameraDeviceStateClosed()

  2403.         {

  2404.             JUCE_CAMERA_LOG ("cameraDeviceStateClosed()");

  2405. 

  2406.             closedEvent.signal();

  2407.         }

  2408. 

  2409.         void cameraDeviceStateDisconnected()

  2410.         {

  2411.             JUCE_CAMERA_LOG ("cameraDeviceStateDisconnected()");

  2412. 

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

  2414.             {

  2415.                 openError = "Device disconnected";

  2416. 

  2417.                 notifyOpenResult();

  2418.             }

  2419. 

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

  2421.         }

  2422. 

  2423.         void cameraDeviceStateError (int errorCode)

  2424.         {

  2425.             String error = cameraErrorCodeToString (errorCode);

  2426. 

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

  2428. 

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

  2430.             {

  2431.                 openError = error;

  2432. 

  2433.                 notifyOpenResult();

  2434.             }

  2435. 

  2436.             fatalErrorOccurred.set (1);

  2437. 

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

  2439.                                        {

  2440.                                            owner.cameraDeviceError (error);

  2441.                                            close();

  2442.                                        });

  2443.         }

  2444. 

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

  2446.         {

  2447.             JUCE_CAMERA_LOG ("cameraDeviceStateOpened()");

  2448. 

  2449.             pendingOpen.set (0);

  2450. 

  2451.             cameraDevice = GlobalRef (cameraDeviceToUse);

  2452. 

  2453.             notifyOpenResult();

  2454.         }

  2455. 

  2456.         void notifyOpenResult()

  2457.         {

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

  2459.         }

  2460. 

  2461.         //==============================================================================

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

  2463.         {

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

  2465.                 myself->cameraDeviceStateClosed();

  2466.         }

  2467. 

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

  2469.         {

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

  2471.                 myself->cameraDeviceStateDisconnected();

  2472.         }

  2473. 

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

  2475.         {

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

  2477.                 myself->cameraDeviceStateError (error);

  2478.         }

  2479. 

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

  2481.         {

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

  2483.             {

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

  2485. 

  2486.                 myself->cameraDeviceStateOpened (camera);

  2487.             }

  2488.         }

  2489.     };

  2490. 

  2491.     //==============================================================================

  2492.     struct CaptureSessionModeBase

  2493.     {

  2494.         virtual ~CaptureSessionModeBase() = default;

  2495. 

  2496.         virtual bool isVideoRecordSession() const = 0;

  2497. 

  2498.         virtual void triggerStillPictureCapture() = 0;

  2499.     };

  2500. 

  2501.     //==============================================================================

  2502.     template <typename Mode>

  2503.     struct CaptureSessionMode   : public CaptureSessionModeBase,

  2504.                                   private PreviewDisplay::Listener,

  2505.                                   private ScopedCameraDevice::CaptureSession::ConfiguredCallback

  2506.     {

  2507.         ~CaptureSessionMode() override

  2508.         {

  2509.             captureSession.reset();

  2510. 

  2511.             previewDisplay.removeListener (this);

  2512.         }

  2513. 

  2514.         bool isVideoRecordSession() const override

  2515.         {

  2516.             return Mode::isVideoRecord();

  2517.         }

  2518. 

  2519.         void triggerStillPictureCapture() override

  2520.         {

  2521.             if (captureSession == nullptr)

  2522.             {

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

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

  2525.                 jassertfalse;

  2526.                 return;

  2527.             }

  2528. 

  2529.             crtp().takeStillPicture();

  2530.         }

  2531. 

  2532.     protected:

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

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

  2535.                             int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

  2536.             : owner (ownerToUse),

  2537.               scopedCameraDevice (cameraDeviceToUse),

  2538.               handler (handlerToUse),

  2539.               previewDisplay (pd),

  2540.               cameraSensorOrientation (cameraSensorOrientationToUse),

  2541.               cameraLensFacing (cameraLensFacingToUse),

  2542.               streamConfigurationMap (streamConfigurationMapToUse)

  2543.         {

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

  2545.             MessageManager::callAsync ([weakRef = WeakReference<CaptureSessionMode<Mode>> { this }]

  2546.             {

  2547.                 if (weakRef != nullptr)

  2548.                     weakRef->previewDisplay.addListener (weakRef.get());

  2549.             });

  2550.         }

  2551. 

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

  2553. 

  2554.         void previewDisplayReady() override

  2555.         {

  2556.             jassert (previewDisplay.isReady());

  2557. 

  2558.             JUCE_CAMERA_LOG ("previewDisplayReady()");

  2559. 

  2560.             // close previous capture session first

  2561.             captureSession.reset();

  2562. 

  2563.             if (scopedCameraDevice.hasErrorOccurred())

  2564.             {

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

  2566.                 return;

  2567.             }

  2568. 

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

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

  2571.         }

  2572. 

  2573.         void previewDisplayAboutToBeDestroyed() override

  2574.         {

  2575.             JUCE_CAMERA_LOG ("previewDisplayAboutToBeDestroyed()");

  2576. 

  2577.             stopPreview();

  2578.         }

  2579. 

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

  2581.         {

  2582.             if (session == nullptr)

  2583.             {

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

  2585.                 return;

  2586.             }

  2587. 

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

  2589. 

  2590.             startSession();

  2591.         }

  2592. 

  2593.         void startSession()

  2594.         {

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

  2596.             {

  2597.                 jassertfalse;

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

  2599.             }

  2600. 

  2601.             crtp().sessionStarted();

  2602.         }

  2603. 

  2604.         void stopPreview()

  2605.         {

  2606.             if (captureSession != nullptr)

  2607.             {

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

  2609. 

  2610.                 auto* env = getEnv();

  2611. 

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

  2613. 

  2614.                 if (jniCheckHasExceptionOccurredAndClear())

  2615.                     return;

  2616. 

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

  2618. 

  2619.                 jniCheckHasExceptionOccurredAndClear();

  2620.             }

  2621.         }

  2622. 

  2623.         Pimpl& owner;

  2624.         ScopedCameraDevice& scopedCameraDevice;

  2625.         GlobalRef& handler;

  2626.         PreviewDisplay& previewDisplay;

  2627.         int cameraSensorOrientation;

  2628.         int cameraLensFacing;

  2629.         StreamConfigurationMap& streamConfigurationMap;

  2630. 

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

  2632. 

  2633.         JUCE_DECLARE_WEAK_REFERENCEABLE (CaptureSessionMode<Mode>)

  2634.     };

  2635. 

  2636.     //==============================================================================

  2637.     struct CaptureSessionPreviewMode : public CaptureSessionMode<CaptureSessionPreviewMode>

  2638.     {

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

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

  2641.                                    int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

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

  2643.                                                              sensorOrientation, cameraLensFacingToUse, streamConfigurationMapToUse),

  2644.               imageReader (ir)

  2645.         {

  2646.         }

  2647. 

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

  2649.         LocalRef<jobject> getCaptureSessionSurfaces() const

  2650.         {

  2651.             auto* env = getEnv();

  2652. 

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

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

  2655. 

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

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

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

  2659. 

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

  2661. 

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

  2663.             jassert (supported);

  2664. 

  2665.             return arrayList;

  2666.         }

  2667. 

  2668.         // Surfaces set as target during capture.

  2669.         LocalRef<jobject> getTargetSurfaces() const

  2670.         {

  2671.             auto* env = getEnv();

  2672. 

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

  2674. 

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

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

  2677. 

  2678.             return arrayList;

  2679.         }

  2680. 

  2681.         static int getTemplate()

  2682.         {

  2683.             static constexpr int templatePreview = 1;

  2684.             return templatePreview;

  2685.         }

  2686. 

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

  2688. 

  2689.         void sessionStarted() {}

  2690. 

  2691.         void takeStillPicture()

  2692.         {

  2693.             imageReader.resetNotificationFlag();

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

  2695.         }

  2696. 

  2697.     private:

  2698.         ImageReader& imageReader;

  2699.     };

  2700. 

  2701.     //==============================================================================

  2702.     struct CaptureSessionVideoRecordingMode : public CaptureSessionMode<CaptureSessionVideoRecordingMode>

  2703.     {

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

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

  2706.                                           int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

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

  2708.                                                                     sensorOrientation, cameraLensFacingToUse, streamConfigurationMapToUse),

  2709.               mediaRecorder (mr)

  2710.         {

  2711.         }

  2712. 

  2713.         ~CaptureSessionVideoRecordingMode()

  2714.         {

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

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

  2717.             stopPreview();

  2718. 

  2719.             mediaRecorder.stop();

  2720.         }

  2721. 

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

  2723.         LocalRef<jobject> getCaptureSessionSurfaces() const

  2724.         {

  2725.             auto* env = getEnv();

  2726. 

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

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

  2729. 

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

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

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

  2733. 

  2734.             return arrayList;

  2735.         }

  2736. 

  2737.         // Surfaces set as target during capture.

  2738.         LocalRef<jobject> getTargetSurfaces() const

  2739.         {

  2740.             // Same surfaces used.

  2741.             return getCaptureSessionSurfaces();

  2742.         }

  2743. 

  2744.         static int getTemplate()

  2745.         {

  2746.             static constexpr int templateRecord = 3;

  2747.             return templateRecord;

  2748.         }

  2749. 

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

  2751. 

  2752.         void sessionStarted()

  2753.         {

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

  2755.         }

  2756. 

  2757.         void takeStillPicture()

  2758.         {

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

  2760.             jassertfalse;

  2761.         }

  2762. 

  2763.     private:

  2764.         MediaRecorder& mediaRecorder;

  2765.     };

  2766. 

  2767.     //==============================================================================

  2768.     class DeviceOrientationChangeListener   : private Timer

  2769.     {

  2770.     public:

  2771.         DeviceOrientationChangeListener (PreviewDisplay& pd)

  2772.             : previewDisplay (pd),

  2773.               orientationEventListener (createOrientationEventListener()),

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

  2775.                                                             OrientationEventListener.canDetectOrientation) != 0),

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

  2777.               lastKnownScreenOrientation (deviceOrientation)

  2778.         {

  2779.             setEnabled (true);

  2780.         }

  2781. 

  2782.         ~DeviceOrientationChangeListener() override

  2783.         {

  2784.             setEnabled (false);

  2785.         }

  2786. 

  2787.         void setEnabled (bool shouldBeEnabled)

  2788.         {

  2789.             if (shouldBeEnabled && ! canDetectChange)

  2790.             {

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

  2792.                 jassertfalse;

  2793.                 return;

  2794.             }

  2795. 

  2796.             if (shouldBeEnabled)

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

  2798.             else

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

  2800.         }

  2801. 

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

  2803. 

  2804.         Desktop::DisplayOrientation getDeviceOrientation() const noexcept

  2805.         {

  2806.             return deviceOrientation;

  2807.         }

  2808. 

  2809.     private:

  2810.         PreviewDisplay& previewDisplay;

  2811. 

  2812.         GlobalRef orientationEventListener;

  2813.         static constexpr jint sensorDelayUI = 2;

  2814. 

  2815.         bool canDetectChange;

  2816.         Desktop::DisplayOrientation deviceOrientation;

  2817. 

  2818.         Desktop::DisplayOrientation lastKnownScreenOrientation;

  2819.         int numChecksForOrientationChange = 10;

  2820. 

  2821.         //==============================================================================

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

  2823.             METHOD (canDetectOrientation, "canDetectOrientation", "()Z") \

  2824.             METHOD (constructor,          "<init>",               "(JLandroid/content/Context;I)V") \

  2825.             METHOD (disable,              "disable",              "()V") \

  2826.             METHOD (enable,               "enable",               "()V") \

  2827.             CALLBACK (deviceOrientationChanged, "deviceOrientationChanged", "(JI)V")

  2828. 

  2829.         DECLARE_JNI_CLASS_WITH_MIN_SDK (OrientationEventListener, "com/rmsl/juce/JuceOrientationEventListener", 21)

  2830.         #undef JNI_CLASS_MEMBERS

  2831. 

  2832.         LocalRef<jobject> createOrientationEventListener()

  2833.         {

  2834.             return LocalRef<jobject> (getEnv()->NewObject (OrientationEventListener,

  2835.                                                            OrientationEventListener.constructor,

  2836.                                                            reinterpret_cast<jlong> (this),

  2837.                                                            getAppContext().get(),

  2838.                                                            sensorDelayUI));

  2839.         }

  2840. 

  2841.         //==============================================================================

  2842.         void orientationChanged (int orientation)

  2843.         {

  2844.             jassert (orientation < 360);

  2845. 

  2846.             // -1 == unknown

  2847.             if (orientation < 0)

  2848.                 return;

  2849. 

  2850.             auto oldOrientation = deviceOrientation;

  2851. 

  2852.             // NB: this assumes natural position to be portrait always, but some devices may be landscape...

  2853.             if (orientation > (360 - 45) || orientation < 45)

  2854.                 deviceOrientation = Desktop::upright;

  2855.             else if (orientation < 135)

  2856.                 deviceOrientation = Desktop::rotatedClockwise;

  2857.             else if (orientation < 225)

  2858.                 deviceOrientation = Desktop::upsideDown;

  2859.             else

  2860.                 deviceOrientation = Desktop::rotatedAntiClockwise;

  2861. 

  2862.             if (oldOrientation != deviceOrientation)

  2863.             {

  2864.                 lastKnownScreenOrientation = Desktop::getInstance().getCurrentOrientation();

  2865. 

  2866.                 // Need to update preview transform, but screen orientation will change slightly

  2867.                 // later than sensor orientation.

  2868.                 startTimer (500);

  2869.             }

  2870.         }

  2871. 

  2872.         void timerCallback() override

  2873.         {

  2874.             auto currentOrientation = Desktop::getInstance().getCurrentOrientation();

  2875. 

  2876.             if (lastKnownScreenOrientation != currentOrientation)

  2877.             {

  2878.                 lastKnownScreenOrientation = currentOrientation;

  2879. 

  2880.                 stopTimer();

  2881.                 numChecksForOrientationChange = 10;

  2882.                 previewDisplay.updateSurfaceTransform();

  2883. 

  2884.                 return;

  2885.             }

  2886. 

  2887.             if (--numChecksForOrientationChange == 0)

  2888.             {

  2889.                 stopTimer();

  2890.                 numChecksForOrientationChange = 10;

  2891.             }

  2892.         }

  2893. 

  2894.         static void deviceOrientationChanged (JNIEnv*, jobject /*obj*/, jlong host, jint orientation)

  2895.         {

  2896.             if (auto* myself = reinterpret_cast<DeviceOrientationChangeListener*> (host))

  2897.                 myself->orientationChanged (orientation);

  2898.         }

  2899.     };

  2900. 

  2901.     //==============================================================================

  2902.     CameraDevice& owner;

  2903.     int minWidth, minHeight, maxWidth, maxHeight;

  2904. 

  2905.     String cameraId;

  2906.     InternalOpenCameraResultCallback cameraOpenCallback;

  2907. 

  2908.     GlobalRef activityLifeListener;

  2909. 

  2910.     GlobalRef cameraManager;

  2911.     GlobalRef cameraCharacteristics;

  2912.     GlobalRef handlerThread;

  2913.     GlobalRef handler;

  2914. 

  2915.     StreamConfigurationMap streamConfigurationMap;

  2916.     PreviewDisplay previewDisplay;

  2917.     DeviceOrientationChangeListener deviceOrientationChangeListener;

  2918.     std::unique_ptr<ImageReader> imageReader;

  2919.     std::unique_ptr<MediaRecorder> mediaRecorder;

  2920. 

  2921.     std::unique_ptr<CaptureSessionModeBase> currentCaptureSessionMode;

  2922. 

  2923.     std::unique_ptr<ScopedCameraDevice> scopedCameraDevice;

  2924. 

  2925.     CriticalSection listenerLock;

  2926.     ListenerList<Listener> listeners;

  2927. 

  2928.     std::function<void (const Image&)> pictureTakenCallback;

  2929. 

  2930.     Time firstRecordedFrameTimeMs;

  2931.     bool notifiedOfCameraOpening = false;

  2932. 

  2933.     bool appWasPaused = false;

  2934. 

  2935.     //==============================================================================

  2936.     int getCameraSensorOrientation() const

  2937.     {

  2938.         return getCameraCharacteristicsIntegerKeyValue (CameraCharacteristics.SENSOR_ORIENTATION);

  2939.     }

  2940. 

  2941.     int getAutoFocusModeToUse() const

  2942.     {

  2943.         auto supportedModes = getSupportedAutoFocusModes();

  2944. 

  2945.         enum

  2946.         {

  2947.             CONTROL_AF_MODE_OFF = 0,

  2948.             CONTROL_AF_MODE_AUTO = 1,

  2949.             CONTROL_AF_MODE_CONTINUOUS_PICTURE = 4

  2950.         };

  2951. 

  2952.         if (supportedModes.contains (CONTROL_AF_MODE_CONTINUOUS_PICTURE))

  2953.             return CONTROL_AF_MODE_CONTINUOUS_PICTURE;

  2954. 

  2955.         if (supportedModes.contains (CONTROL_AF_MODE_AUTO))

  2956.             return CONTROL_AF_MODE_AUTO;

  2957. 

  2958.         return CONTROL_AF_MODE_OFF;

  2959.     }

  2960. 

  2961.     Array<int> getSupportedAutoFocusModes() const

  2962.     {

  2963.         auto* env = getEnv();

  2964. 

  2965.         auto jKey = LocalRef<jobject> (env->GetStaticObjectField (CameraCharacteristics, CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES));

  2966. 

  2967.         auto supportedModes = LocalRef<jintArray> ((jintArray) env->CallObjectMethod (cameraCharacteristics,

  2968.                                                                                       CameraCharacteristics.get,

  2969.                                                                                       jKey.get()));

  2970. 

  2971.         return jintArrayToJuceArray (supportedModes);

  2972.     }

  2973. 

  2974.     static Array<int> jintArrayToJuceArray (const LocalRef<jintArray>& jArray)

  2975.     {

  2976.         auto* env = getEnv();

  2977. 

  2978.         auto* jArrayElems = env->GetIntArrayElements (jArray, nullptr);

  2979.         auto numElems = env->GetArrayLength (jArray);

  2980. 

  2981.         Array<int> juceArray;

  2982. 

  2983.         for (int s = 0; s < numElems; ++s)

  2984.             juceArray.add (jArrayElems[s]);

  2985. 

  2986.         env->ReleaseIntArrayElements (jArray, jArrayElems, 0);

  2987.         return juceArray;

  2988.     }

  2989. 

  2990.     int getCameraCharacteristicsIntegerKeyValue (jfieldID key) const

  2991.     {

  2992.         auto* env = getEnv();

  2993. 

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

  2995. 

  2996.         auto jValue = LocalRef<jobject> (env->CallObjectMethod (cameraCharacteristics,

  2997.                                                                 CameraCharacteristics.get,

  2998.                                                                 jKey.get()));

  2999. 

  3000.         return env->CallIntMethod (jValue, JavaInteger.intValue);

  3001.     }

  3002. 

  3003.     int getCameraLensFacing() const

  3004.     {

  3005.         return getCameraCharacteristicsIntegerKeyValue (CameraCharacteristics.LENS_FACING);

  3006.     }

  3007. 

  3008.     //==============================================================================

  3009.     void cameraOpenFinished (const String& error)

  3010.     {

  3011.         JUCE_CAMERA_LOG ("cameraOpenFinished(), error = " + error);

  3012. 

  3013.         if (error.isEmpty())

  3014.         {

  3015.             setupStillImageSize();

  3016.             startPreviewMode (*imageReader);

  3017.         }

  3018. 

  3019.         // Do not notify about camera being reopened on app resume.

  3020.         if (! notifiedOfCameraOpening)

  3021.         {

  3022.             notifiedOfCameraOpening = true;

  3023. 

  3024.             invokeCameraOpenCallback (error);

  3025.         }

  3026.     }

  3027. 

  3028.     void cameraDeviceError (const String& error)

  3029.     {

  3030.         if (owner.onErrorOccurred != nullptr)

  3031.             owner.onErrorOccurred (error);

  3032.     }

  3033. 

  3034.     void invokeCameraOpenCallback (const String& error)

  3035.     {

  3036.         JUCE_CAMERA_LOG ("invokeCameraOpenCallback(), error = " + error);

  3037. 

  3038.         if (cameraOpenCallback != nullptr)

  3039.             cameraOpenCallback (cameraId, error);

  3040.     }

  3041. 

  3042.     //==============================================================================

  3043.     void callListeners (const Image& image)

  3044.     {

  3045.         const ScopedLock sl (listenerLock);

  3046.         listeners.call ([=] (Listener& l) { l.imageReceived (image); });

  3047.     }

  3048. 

  3049.     void notifyPictureTaken (const Image& image)

  3050.     {

  3051.         JUCE_CAMERA_LOG ("notifyPictureTaken()");

  3052. 

  3053.         if (pictureTakenCallback != nullptr)

  3054.             pictureTakenCallback (image);

  3055.     }

  3056. 

  3057.     void triggerStillPictureCapture()

  3058.     {

  3059.         currentCaptureSessionMode->triggerStillPictureCapture();

  3060.     }

  3061. 

  3062.     //==============================================================================

  3063.     void setupStillImageSize()

  3064.     {

  3065.         imageReader.reset();

  3066. 

  3067.         auto imageSize = chooseBestSize (minWidth, minHeight, maxWidth, maxHeight,

  3068.                                          streamConfigurationMap.getSupportedStillImageOutputSizes());

  3069. 

  3070.         imageReader.reset (new ImageReader (*this, handler, imageSize.getWidth(), imageSize.getHeight(),

  3071.                                             getCameraSensorOrientation()));

  3072.     }

  3073. 

  3074.     static Rectangle<int> chooseBestSize (int minWidth, int minHeight, int maxWidth, int maxHeight,

  3075.                                           Array<Rectangle<int>> supportedSizes)

  3076.     {

  3077.         Rectangle<int> result;

  3078. 

  3079.         for (auto& size : supportedSizes)

  3080.         {

  3081.             auto width  = size.getWidth();

  3082.             auto height = size.getHeight();

  3083. 

  3084.             if (width < minWidth || width > maxWidth || height < minHeight || height > maxHeight)

  3085.                 continue;

  3086. 

  3087.             if (size.contains (result))

  3088.                 result = size;

  3089.         }

  3090. 

  3091.         // None of the supported sizes matches required width & height limitations, picking

  3092.         // the first one available...

  3093.         jassert (! result.isEmpty());

  3094. 

  3095.         if (result.isEmpty())

  3096.             result = supportedSizes[0];

  3097. 

  3098.         return result;

  3099.     }

  3100. 

  3101.     //==============================================================================

  3102.     void startPreviewMode (ImageReader& ir)

  3103.     {

  3104.         if (currentCaptureSessionMode != nullptr && ! currentCaptureSessionMode->isVideoRecordSession())

  3105.             return;

  3106. 

  3107.         // previous mode has to be stopped first

  3108.         jassert (currentCaptureSessionMode.get() == nullptr);

  3109. 

  3110.         if (scopedCameraDevice == nullptr || ! scopedCameraDevice->openedOk())

  3111.             return;

  3112. 

  3113.         currentCaptureSessionMode.reset (new CaptureSessionPreviewMode (*this, *scopedCameraDevice, handler,

  3114.                                                                         previewDisplay, ir,

  3115.                                                                         getCameraSensorOrientation(),

  3116.                                                                         getCameraLensFacing(),

  3117.                                                                         streamConfigurationMap));

  3118.     }

  3119. 

  3120.     void startVideoRecordingMode (MediaRecorder& mr)

  3121.     {

  3122.         if (currentCaptureSessionMode != nullptr && currentCaptureSessionMode->isVideoRecordSession())

  3123.             return;

  3124. 

  3125.         // previous mode has to be stopped first

  3126.         jassert (currentCaptureSessionMode.get() == nullptr);

  3127. 

  3128.         jassert (scopedCameraDevice != nullptr && scopedCameraDevice->openedOk());

  3129. 

  3130.         if (scopedCameraDevice == nullptr || ! scopedCameraDevice->openedOk())

  3131.             return;

  3132. 

  3133.         currentCaptureSessionMode.reset (new CaptureSessionVideoRecordingMode (*this, *scopedCameraDevice, handler,

  3134.                                                                                previewDisplay, mr,

  3135.                                                                                getCameraSensorOrientation(),

  3136.                                                                                getCameraLensFacing(),

  3137.                                                                                streamConfigurationMap));

  3138.     }

  3139. 

  3140.     //==============================================================================

  3141.     void onActivityPaused (jobject) override

  3142.     {

  3143.         JUCE_CAMERA_LOG ("appPaused, closing camera...");

  3144. 

  3145.         appWasPaused = true;

  3146. 

  3147.         deviceOrientationChangeListener.setEnabled (false);

  3148. 

  3149.         // We need to restart the whole session mode when the app gets resumed.

  3150.         currentCaptureSessionMode.reset();

  3151. 

  3152.         if (scopedCameraDevice != nullptr)

  3153.             scopedCameraDevice->close();

  3154. 

  3155.         stopBackgroundThread();

  3156.     }

  3157. 

  3158.     void onActivityResumed (jobject) override

  3159.     {

  3160.         // Only care about resumed event when paused event was called first.

  3161.         if (! appWasPaused)

  3162.             return;

  3163. 

  3164.         JUCE_CAMERA_LOG ("appResumed, opening camera...");

  3165. 

  3166.         deviceOrientationChangeListener.setEnabled (true);

  3167. 

  3168.         startBackgroundThread();

  3169. 

  3170.         if (scopedCameraDevice != nullptr)

  3171.             scopedCameraDevice->open();

  3172.     }

  3173. 

  3174.     void startBackgroundThread()

  3175.     {

  3176.         auto* env = getEnv();

  3177. 

  3178.         handlerThread = GlobalRef (LocalRef<jobject> (env->NewObject (AndroidHandlerThread,

  3179.                                                                       AndroidHandlerThread.constructor,

  3180.                                                                       javaString ("JuceCameraDeviceBackgroundThread").get())));

  3181.         // handler thread has to be started before its looper can be fetched

  3182.         env->CallVoidMethod (handlerThread, AndroidHandlerThread.start);

  3183.         handler = GlobalRef (LocalRef<jobject> (env->NewObject (AndroidHandler,

  3184.                                                                 AndroidHandler.constructorWithLooper,

  3185.                                                                 env->CallObjectMethod (handlerThread, AndroidHandlerThread.getLooper))));

  3186.     }

  3187. 

  3188.     void stopBackgroundThread()

  3189.     {

  3190.         auto* env = getEnv();

  3191. 

  3192.         auto quitSafelyMethod = env->GetMethodID(AndroidHandlerThread, "quitSafely", "()Z");

  3193. 

  3194.         // this code will only run on SDK >= 21

  3195.         jassert(quitSafelyMethod != nullptr);

  3196. 

  3197.         env->CallBooleanMethod (handlerThread, quitSafelyMethod);

  3198.         env->CallVoidMethod (handlerThread, AndroidHandlerThread.join);

  3199. 

  3200.         jniCheckHasExceptionOccurredAndClear();

  3201. 

  3202.         handlerThread.clear();

  3203.         handler.clear();

  3204.     }

  3205. 

  3206.     friend struct CameraDevice::ViewerComponent;

  3207. 

  3208.     JUCE_DECLARE_NON_COPYABLE (Pimpl)

  3209. };

  3210. 

  3211. //==============================================================================

  3212. struct CameraDevice::ViewerComponent  : public Component,

  3213.                                         private ComponentMovementWatcher

  3214. {

  3215.     ViewerComponent (CameraDevice& device) : ComponentMovementWatcher (this)

  3216.     {

  3217.         auto previewSize = device.pimpl->streamConfigurationMap.getDefaultPreviewSize();

  3218. 

  3219.         targetAspectRatio = (float) previewSize.getWidth() / (float) previewSize.getHeight();

  3220. 

  3221.         if (isOrientationLandscape())

  3222.             setBounds (previewSize);

  3223.         else

  3224.             setBounds (0, 0, previewSize.getHeight(), previewSize.getWidth());

  3225. 

  3226.         addAndMakeVisible (viewerComponent);

  3227.         viewerComponent.setView (device.pimpl->previewDisplay.getNativeView());

  3228.     }

  3229. 

  3230. private:

  3231.     AndroidViewComponent viewerComponent;

  3232. 

  3233.     float targetAspectRatio = 1.0f;

  3234. 

  3235.     void componentMovedOrResized (bool, bool) override

  3236.     {

  3237.         auto b = getLocalBounds().toFloat();

  3238. 

  3239.         auto targetWidth  = b.getWidth();

  3240.         auto targetHeight = b.getHeight();

  3241. 

  3242.         if (isOrientationLandscape())

  3243.         {

  3244.             auto currentAspectRatio = b.getWidth() / b.getHeight();

  3245. 

  3246.             if (currentAspectRatio > targetAspectRatio)

  3247.                 targetWidth = targetWidth * targetAspectRatio / currentAspectRatio;

  3248.             else

  3249.                 targetHeight = targetHeight * currentAspectRatio / targetAspectRatio;

  3250.         }

  3251.         else

  3252.         {

  3253.             auto currentAspectRatio = b.getHeight() / b.getWidth();

  3254. 

  3255.             if (currentAspectRatio > targetAspectRatio)

  3256.                 targetHeight = targetHeight * targetAspectRatio / currentAspectRatio;

  3257.             else

  3258.                 targetWidth = targetWidth * currentAspectRatio / targetAspectRatio;

  3259.         }

  3260. 

  3261.         viewerComponent.setBounds (Rectangle<float> (targetWidth, targetHeight).withCentre (b.getCentre()).toNearestInt());

  3262.     }

  3263. 

  3264.     bool isOrientationLandscape() const

  3265.     {

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

  3267.         return o == Desktop::rotatedClockwise || o == Desktop::rotatedAntiClockwise;

  3268.     }

  3269. 

  3270.     void componentPeerChanged() override {}

  3271.     void componentVisibilityChanged() override {}

  3272. 

  3273.     JUCE_DECLARE_NON_COPYABLE (ViewerComponent)

  3274. };

  3275. 

  3276. String CameraDevice::getFileExtension()

  3277. {

  3278.     return ".mp4";

  3279. }

  3280. 

  3281. //==============================================================================

  3282. CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::StillPictureTaker::CameraCaptureSessionCaptureCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::StillPictureTaker::CameraCaptureSessionCaptureCallback;

  3283. CameraDevice::Pimpl::ScopedCameraDevice::CameraDeviceStateCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CameraDeviceStateCallback;

  3284. CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::CameraCaptureSessionStateCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::CameraCaptureSessionStateCallback;

  3285. CameraDevice::Pimpl::DeviceOrientationChangeListener::OrientationEventListener_Class CameraDevice::Pimpl::DeviceOrientationChangeListener::OrientationEventListener;