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.
10948 Commits
11 Branches
356MB
Tree: b5aa3fbf3e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b5aa3fbf3e'
${ noResults }
JUCE/modules/juce_video/native/juce_android_CameraDevice.h

3289 lines
146KB
Raw Blame History 

  1. /*

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

  3. 

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

  5.    Copyright (c) 2017 - ROLI Ltd.

  6. 

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

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

  9. 

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

  11. 

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

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

  14.    DISCLAIMED.

  15. 

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

  17. */

  18. 

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

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

  21. //

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

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

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

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

  26. //

  27. // files with min sdk version 21

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

  29. static const uint8 CameraSupportByteCode[] = {

  30. 31,139,8,8,45,45,227,91,0,3,67,97,109,101,114,97,83,117,112,112,111,114,116,46,100,101,120,0,149,152,93,108,28,213,21,

  31. 199,207,157,157,221,89,239,174,215,227,181,243,73,18,236,124,216,14,196,108,190,140,162,174,227,196,56,9,216,93,197,169,

  32. 215,118,35,3,45,147,221,73,60,116,189,179,204,174,151,84,173,74,136,168,8,47,85,80,105,1,9,33,16,1,209,7,36,183,4,194,3,

  33. 15,169,138,10,85,133,148,34,170,246,33,149,120,40,60,180,84,138,80,133,242,192,67,255,247,99,236,217,245,218,53,150,126,

  34. 251,63,51,231,220,115,239,61,247,206,120,102,10,246,249,216,222,3,3,244,159,203,87,222,62,245,197,223,255,124,233,193,91,

  35. 39,95,59,122,248,179,137,191,189,250,253,83,157,191,127,189,47,69,84,38,162,243,211,7,97,201,191,75,237,68,167,73,158,

  36. 239,0,55,24,209,38,232,22,141,40,12,125,32,68,212,199,253,80,29,186,128,159,219,9,162,189,112,190,23,37,186,14,254,5,82,

  37. 45,68,251,193,0,56,4,30,4,53,112,13,124,13,122,99,68,63,0,79,131,223,129,127,0,35,78,116,47,248,33,120,14,124,8,190,2,93,

  38. 200,191,3,244,130,187,121,95,96,0,100,192,81,112,63,24,7,167,193,35,160,0,28,224,130,26,248,41,120,2,60,13,94,3,127,2,95,

  39. 130,142,86,162,35,96,14,60,11,222,2,159,128,175,64,107,146,168,7,28,7,15,131,26,120,2,188,8,94,1,191,1,239,130,247,193,

  40. 135,224,47,224,115,240,53,136,183,17,237,2,195,32,7,30,6,101,240,51,240,11,240,60,120,21,92,3,215,193,199,224,38,248,28,

  41. 252,27,252,23,124,3,162,38,81,59,216,14,250,76,89,111,190,6,6,64,137,9,101,36,148,141,80,34,194,116,8,195,38,116,79,104,

  42. 74,8,39,44,37,165,212,58,118,130,117,96,61,232,81,218,174,214,124,131,178,23,144,120,163,178,223,51,228,186,115,251,58,

  43. 236,59,148,253,17,236,205,202,254,52,96,223,12,196,252,19,246,22,101,223,130,189,85,217,183,97,111,83,182,142,9,220,169,

  44. 236,78,216,93,202,222,25,176,15,6,236,99,176,183,43,123,18,118,183,178,31,10,156,47,192,222,161,236,34,236,157,202,62,15,

  45. 123,151,178,159,10,216,151,3,246,75,129,156,111,6,114,46,68,121,93,25,13,138,250,166,104,92,212,88,30,183,41,53,149,134,

  46. 84,61,117,165,17,165,9,177,34,188,125,84,105,146,118,11,77,208,93,66,91,233,110,161,45,180,71,104,140,250,133,198,233,30,

  47. 161,235,233,136,208,78,58,42,116,29,13,11,109,167,251,212,184,70,132,118,208,49,49,62,77,244,147,196,110,233,83,154,86,

  48. 186,87,233,62,165,251,133,154,52,164,244,184,210,19,74,239,87,154,21,243,149,121,219,48,179,3,74,15,10,53,104,64,29,223,

  49. 43,116,131,200,195,245,1,161,27,105,84,29,143,137,122,201,10,153,168,216,33,85,191,239,146,220,191,44,80,71,166,244,83,

  50. 147,212,124,228,57,191,190,154,210,148,218,200,109,202,239,215,221,207,115,66,249,77,229,79,52,172,143,167,252,97,100,

  51. 230,254,3,166,188,190,202,38,143,159,193,37,244,80,39,67,239,9,248,249,181,119,216,148,57,114,23,137,166,158,98,100,60,

  52. 105,252,202,120,195,184,86,51,194,20,140,59,177,98,92,164,46,110,124,197,56,67,196,197,48,19,62,214,211,166,188,214,115,

  53. 30,226,170,136,123,204,248,57,251,117,45,18,21,81,114,61,249,184,31,241,243,61,139,184,95,34,238,178,113,133,189,163,255,

  54. 177,22,109,17,81,41,244,202,239,27,142,41,107,154,251,45,226,222,70,220,130,241,129,241,87,253,139,48,110,60,181,88,76,

  55. 196,234,232,155,215,164,98,202,122,149,77,38,106,162,9,159,38,214,226,39,202,151,235,210,168,124,52,69,218,190,37,223,

  56. 197,58,95,71,157,239,153,58,95,103,157,239,114,157,111,93,157,239,249,58,223,122,229,147,227,124,121,113,156,154,24,103,

  57. 40,48,206,55,22,219,133,208,110,107,93,206,183,234,124,219,132,47,140,156,252,126,123,53,232,155,188,179,174,221,251,117,

  58. 237,186,132,47,34,90,18,253,193,31,203,222,16,13,135,103,82,122,96,44,31,47,182,211,209,174,71,180,243,247,59,83,104,129,

  59. 235,129,169,221,46,207,133,149,26,202,103,4,124,41,145,159,107,152,228,255,11,223,246,175,13,121,220,66,76,100,90,58,142,

  60. 214,197,183,136,61,18,60,142,171,62,252,113,133,149,29,86,99,244,251,144,255,167,100,254,144,178,163,139,49,50,175,111,

  61. 199,85,27,67,229,226,26,25,116,74,78,117,136,250,70,172,57,219,179,70,172,114,117,222,179,115,118,165,226,184,37,117,52,

  62. 98,21,139,103,172,252,143,238,121,212,170,89,212,211,44,50,87,181,170,13,113,219,100,220,49,187,230,228,237,38,126,54,74,

  63. 108,140,186,199,230,243,246,184,231,216,37,68,32,209,241,26,172,172,83,169,218,37,219,147,129,155,178,86,169,224,185,78,

  64. 33,157,119,75,56,95,77,143,112,61,95,205,208,145,69,215,172,229,21,30,183,60,59,157,23,189,238,79,55,27,229,206,134,9,

  65. 101,232,240,183,76,80,55,143,12,165,191,93,243,12,13,252,191,6,178,92,141,253,244,174,173,89,134,118,175,22,40,134,114,

  66. 194,114,138,144,181,132,78,216,143,205,219,21,148,185,111,13,161,149,249,34,34,251,87,142,156,116,171,86,177,33,124,105,

  67. 94,53,199,126,60,189,210,62,200,208,129,108,222,157,75,123,110,209,73,63,138,13,211,180,186,203,22,119,223,26,26,53,20,

  68. 122,119,211,38,77,246,112,134,246,52,132,174,182,145,51,196,166,73,155,30,5,99,20,154,30,27,229,63,89,210,241,35,204,25,

  69. 10,227,7,118,68,200,24,25,92,179,99,99,242,68,54,139,134,89,4,34,66,159,230,254,240,180,240,226,0,62,54,67,17,89,101,218,

  70. 156,111,50,199,225,124,213,169,217,180,179,153,207,47,154,59,87,46,218,85,187,64,221,171,68,241,189,131,144,93,171,132,

  71. 156,242,220,115,30,206,32,236,174,85,194,114,124,107,149,242,246,240,25,215,227,189,238,89,67,236,210,24,183,175,22,93,

  72. 181,68,198,166,149,24,41,186,124,100,59,154,250,220,210,89,231,220,210,44,183,173,26,84,160,77,205,252,19,182,85,248,49,

  73. 109,200,47,219,54,178,227,173,203,28,199,156,10,238,106,37,59,207,199,188,126,153,251,184,231,185,94,147,124,227,101,108,

  74. 171,2,25,121,121,39,164,141,5,225,11,236,191,145,89,171,116,14,33,97,91,164,48,206,202,235,158,226,103,61,36,59,57,63,

  75. 119,198,246,72,159,117,43,85,106,225,191,147,238,84,197,166,232,226,110,73,53,217,27,109,141,59,161,163,217,186,111,92,

  76. 113,149,55,175,178,166,230,178,21,140,46,174,87,251,242,213,73,212,173,69,210,45,213,21,210,192,245,39,166,141,28,170,84,

  77. 157,176,150,87,199,240,151,44,238,46,57,169,181,140,17,56,86,81,222,166,200,40,123,54,191,63,145,238,161,244,100,120,242,

  78. 190,72,17,79,250,99,21,53,155,81,36,172,200,141,64,109,149,89,119,190,88,184,15,149,81,141,171,179,78,133,90,170,206,28,

  79. 218,90,115,101,234,208,134,166,141,228,96,127,63,109,9,77,77,228,140,228,85,218,14,35,195,141,221,48,198,185,145,214,166,

  80. 38,141,228,235,52,16,154,154,28,228,39,6,245,169,137,211,176,62,161,36,27,226,205,105,29,155,50,146,51,116,135,148,110,

  81. 41,189,82,250,165,180,170,208,78,214,199,15,55,75,233,210,250,190,195,181,71,30,38,66,67,135,190,103,36,15,243,176,147,

  82. 252,4,105,120,120,214,152,166,95,184,160,47,196,216,69,60,229,53,33,206,110,196,24,187,13,94,137,51,246,17,184,5,94,72,

  83. 16,139,132,53,173,29,109,63,72,52,107,183,129,125,150,96,236,27,240,66,43,99,87,193,13,188,252,133,245,144,182,5,109,190,

  84. 108,109,140,239,102,151,146,140,93,1,215,193,77,60,194,105,76,215,118,61,121,65,191,157,228,254,94,246,92,155,124,175,

  85. 241,159,235,124,245,191,177,240,103,30,255,59,11,127,38,242,191,181,248,239,250,252,123,11,87,255,155,75,132,150,190,187,

  86. 176,46,249,94,207,191,189,48,83,190,187,243,119,120,173,75,230,231,223,99,66,42,134,191,211,240,151,105,222,86,188,79,

  87. 153,114,28,252,123,207,255,0,68,14,12,167,40,18,0,0};

  88. 

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

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

  91. 

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

  93. #undef JNI_CLASS_MEMBERS

  94. 

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

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

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

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

  99. 

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

  101. #undef JNI_CLASS_MEMBERS

  102. 

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

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

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

  106. 

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

  108. #undef JNI_CLASS_MEMBERS

  109. 

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

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

  112. 

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

  114. #undef JNI_CLASS_MEMBERS

  115. 

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

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

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

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

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

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

  122. 

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

  124. #undef JNI_CLASS_MEMBERS

  125. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  145. 

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

  147. #undef JNI_CLASS_MEMBERS

  148. 

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

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

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

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

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

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

  155. 

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

  157. #undef JNI_CLASS_MEMBERS

  158. 

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

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

  161. 

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

  163. #undef JNI_CLASS_MEMBERS

  164. 

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

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

  167. 

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

  169. #undef JNI_CLASS_MEMBERS

  170. 

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

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

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

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

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

  176. 

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

  178. #undef JNI_CLASS_MEMBERS

  179. 

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

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

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

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

  184. 

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

  186. #undef JNI_CLASS_MEMBERS

  187. 

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

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

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

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

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

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

  194. 

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

  196. #undef JNI_CLASS_MEMBERS

  197. 

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

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

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

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

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

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

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

  205. 

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

  207. #undef JNI_CLASS_MEMBERS

  208. 

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

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

  211. 

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

  213. #undef JNI_CLASS_MEMBERS

  214. 

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

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

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

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

  219. 

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

  221. #undef JNI_CLASS_MEMBERS

  222. 

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

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

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

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

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

  228. 

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

  230. #undef JNI_CLASS_MEMBERS

  231. 

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

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

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

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

  236. 

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

  238. #undef JNI_CLASS_MEMBERS

  239. 

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

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

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

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

  244. 

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

  246. #undef JNI_CLASS_MEMBERS

  247. 

  248. //==============================================================================

  249. class AndroidRunnable  : public juce::AndroidInterfaceImplementer

  250. {

  251. public:

  252.     struct Owner

  253.     {

  254.         virtual ~Owner() {}

  255. 

  256.         virtual void run() = 0;

  257.     };

  258. 

  259.     AndroidRunnable (Owner& ownerToUse)

  260.         : owner (ownerToUse)

  261.     {}

  262. 

  263. private:

  264.     Owner& owner;

  265. 

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

  267.     {

  268.         auto* env = getEnv();

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

  270. 

  271.         if (methodName == "run")

  272.         {

  273.             owner.run();

  274.             return nullptr;

  275.         }

  276. 

  277.         // invoke base class

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

  279.     }

  280. };

  281. 

  282. //==============================================================================

  283. class TextureViewSurfaceTextureListener     : public AndroidInterfaceImplementer

  284. {

  285. public:

  286.     struct Owner

  287.     {

  288.         virtual ~Owner() {}

  289. 

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

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

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

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

  294.     };

  295. 

  296.     TextureViewSurfaceTextureListener (Owner& ownerToUse)

  297.         : owner (ownerToUse)

  298.     {}

  299. 

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

  301.     {

  302.         auto* env = getEnv();

  303. 

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

  305. 

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

  307. 

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

  309.         {

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

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

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

  313. 

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

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

  316. 

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

  318.             return nullptr;

  319.         }

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

  321.         {

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

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

  324. 

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

  326.         }

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

  328.         {

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

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

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

  332. 

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

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

  335. 

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

  337.             return nullptr;

  338.         }

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

  340.         {

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

  342. 

  343.             owner.onSurfaceTextureUpdated (surface);

  344.             return nullptr;

  345.         }

  346. 

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

  348.     }

  349. 

  350. private:

  351.     Owner& owner;

  352. };

  353. 

  354. //==============================================================================

  355. class ImageReaderOnImageAvailableListener     : public AndroidInterfaceImplementer

  356. {

  357. public:

  358.     struct Owner

  359.     {

  360.         virtual ~Owner() {}

  361. 

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

  363.     };

  364. 

  365.     ImageReaderOnImageAvailableListener (Owner& ownerToUse)

  366.         : owner (ownerToUse)

  367.     {}

  368. 

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

  370.     {

  371.         auto* env = getEnv();

  372. 

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

  374. 

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

  376. 

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

  378.         {

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

  380. 

  381.             owner.onImageAvailable (imageReader);

  382.             return nullptr;

  383.         }

  384. 

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

  386.     }

  387. 

  388. private:

  389.     Owner& owner;

  390. };

  391. 

  392. //==============================================================================

  393. class MediaRecorderOnInfoListener     : public AndroidInterfaceImplementer

  394. {

  395. public:

  396.     struct Owner

  397.     {

  398.         virtual ~Owner() {}

  399. 

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

  401.     };

  402. 

  403.     MediaRecorderOnInfoListener (Owner& ownerToUse)

  404.         : owner (ownerToUse)

  405.     {}

  406. 

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

  408.     {

  409.         auto* env = getEnv();

  410. 

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

  412. 

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

  414. 

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

  416.         {

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

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

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

  420. 

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

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

  423. 

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

  425.             return nullptr;

  426.         }

  427. 

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

  429.     }

  430. 

  431. private:

  432.     Owner& owner;

  433. };

  434. 

  435. //==============================================================================

  436. class MediaRecorderOnErrorListener     : public AndroidInterfaceImplementer

  437. {

  438. public:

  439.     struct Owner

  440.     {

  441.         virtual ~Owner() {}

  442. 

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

  444.     };

  445. 

  446.     MediaRecorderOnErrorListener (Owner& ownerToUse)

  447.         : owner (ownerToUse)

  448.     {}

  449. 

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

  451.     {

  452.         auto* env = getEnv();

  453. 

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

  455. 

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

  457. 

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

  459.         {

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

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

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

  463. 

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

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

  466. 

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

  468.             return nullptr;

  469.         }

  470. 

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

  472.     }

  473. 

  474. private:

  475.     Owner& owner;

  476. };

  477. 

  478. //==============================================================================

  479. struct CameraDevice::Pimpl

  480.     : private ActivityLifecycleCallbacks

  481. {

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

  483. 

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

  485.            int minWidthToUse, int minHeightToUse, int maxWidthToUse, int maxHeightToUse,

  486.            bool /*useHighQuality*/)

  487.         : owner (ownerToUse),

  488.           minWidth (minWidthToUse),

  489.           minHeight (minHeightToUse),

  490.           maxWidth (maxWidthToUse),

  491.           maxHeight (maxHeightToUse),

  492.           cameraId (cameraIdToUse),

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

  494.           cameraManager (initialiseCameraManager()),

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

  496.           streamConfigurationMap (cameraCharacteristics),

  497.           previewDisplay (streamConfigurationMap.getPreviewBufferSize()),

  498.           deviceOrientationChangeListener (previewDisplay)

  499.     {

  500.         startBackgroundThread();

  501.     }

  502. 

  503.     ~Pimpl() override

  504.     {

  505.         auto* env = getEnv();

  506. 

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

  508.         activityLifeListener.clear();

  509.     }

  510. 

  511.     JUCE_DECLARE_WEAK_REFERENCEABLE (Pimpl)

  512. 

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

  514. 

  515.     void open (InternalOpenCameraResultCallback cameraOpenCallbackToUse)

  516.     {

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

  518. 

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

  520.         jassert (cameraOpenCallback != nullptr);

  521. 

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

  523.         jassert (scopedCameraDevice == nullptr);

  524. 

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

  526.             return;

  527. 

  528.         WeakReference<Pimpl> safeThis (this);

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

  530.                                      {

  531.                                          if (safeThis != nullptr)

  532.                                              safeThis->continueOpenRequest (granted);

  533.                                      });

  534.     }

  535. 

  536.     void continueOpenRequest (bool granted)

  537.     {

  538.         if (getAndroidSDKVersion() >= 21)

  539.         {

  540.             if (granted)

  541.             {

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

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

  544.             }

  545.             else

  546.             {

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

  548.             }

  549.         }

  550.         else

  551.         {

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

  553.         }

  554.     }

  555. 

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

  557. 

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

  559.     {

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

  561.         {

  562.             jassertfalse;

  563.             return;

  564.         }

  565. 

  566.         if (currentCaptureSessionMode->isVideoRecordSession())

  567.         {

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

  569.             jassertfalse;

  570.             return;

  571.         }

  572. 

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

  574. 

  575.         triggerStillPictureCapture();

  576.     }

  577. 

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

  579.     {

  580.         if (! openedOk())

  581.         {

  582.             jassertfalse;

  583.             return;

  584.         }

  585. 

  586.         if (! previewDisplay.isReady())

  587.         {

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

  589.             jassertfalse;

  590.             return;

  591.         }

  592. 

  593.         file.deleteFile();

  594.         file.create();

  595.         jassert (file.existsAsFile());

  596. 

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

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

  599.                                          streamConfigurationMap.getSupportedVideoRecordingOutputSizes());

  600. 

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

  602.                                                 getCameraSensorOrientation(), getCameraLensFacing()));

  603. 

  604.         firstRecordedFrameTimeMs = Time::getCurrentTime();

  605. 

  606.         currentCaptureSessionMode.reset();

  607.         startVideoRecordingMode (*mediaRecorder);

  608.     }

  609. 

  610.     void stopRecording()

  611.     {

  612.         currentCaptureSessionMode.reset();

  613.         mediaRecorder.reset();

  614. 

  615.         startPreviewMode (*imageReader);

  616.     }

  617. 

  618.     Time getTimeOfFirstRecordedFrame() const

  619.     {

  620.         return firstRecordedFrameTimeMs;

  621.     }

  622. 

  623.     static StringArray getAvailableDevices()

  624.     {

  625.         if (getAndroidSDKVersion() < 21)

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

  627. 

  628.         StringArray results;

  629. 

  630.         auto* env = getEnv();

  631. 

  632.         auto cameraManagerToUse = initialiseCameraManager();

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

  634.                                                                                            CameraManager.getCameraIdList));

  635. 

  636.         results = javaStringArrayToJuce (cameraIdArray);

  637. 

  638.         for (auto& result : results)

  639.             printDebugCameraInfo (cameraManagerToUse, result);

  640. 

  641.         return results;

  642.     }

  643. 

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

  645.     {

  646.         const ScopedLock sl (listenerLock);

  647.         listeners.add (listenerToAdd);

  648. 

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

  650.             triggerStillPictureCapture();

  651.     }

  652. 

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

  654.     {

  655.         const ScopedLock sl (listenerLock);

  656.         listeners.remove (listenerToRemove);

  657.     }

  658. 

  659. private:

  660.     enum

  661.     {

  662.         ERROR_CAMERA_IN_USE = 1,

  663.         ERROR_MAX_CAMERAS_IN_USE = 2,

  664.         ERROR_CAMERA_DISABLED = 3,

  665.         ERROR_CAMERA_DEVICE = 4,

  666.         ERROR_CAMERA_SERVICE = 5

  667.     };

  668. 

  669.     static String cameraErrorCodeToString (int errorCode)

  670.     {

  671.         switch (errorCode)

  672.         {

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

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

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

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

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

  678.             default:                       return "Unknown error.";

  679.         }

  680.     }

  681. 

  682.     static LocalRef<jobject> initialiseCameraManager()

  683.     {

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

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

  686.     }

  687. 

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

  689.     {

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

  691.                                                               CameraManager.getCameraCharacteristics,

  692.                                                               javaString (cameraId).get()));

  693.     }

  694. 

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

  696.     {

  697.         auto* env = getEnv();

  698. 

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

  700.                                                                          CameraManager.getCameraCharacteristics,

  701.                                                                          javaString (cameraId).get()));

  702. 

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

  704. 

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

  706. 

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

  708. 

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

  710.         {

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

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

  713.             auto keyName = juceString (jKeyName);

  714. 

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

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

  717.             auto keyValueString = juceString (jKeyValueString);

  718. 

  719.             auto &kvs = keyValueString;

  720. 

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

  722.             {

  723.                 printPrimitiveArrayElements (keyValue, keyName, keyValueString);

  724.             }

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

  726.             {

  727.                 printRangeArrayElements (keyValue, keyName);

  728.             }

  729.             else

  730.             {

  731.                 int chunkSize = 256;

  732. 

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

  734.                 {

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

  736. 

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

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

  739.                 }

  740.                 else

  741.                 {

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

  743.                 }

  744.             }

  745. 

  746.             ignoreUnused (keyName);

  747.         }

  748.     }

  749. 

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

  751.                                              const String& keyValueString)

  752.     {

  753.         ignoreUnused (keyName);

  754. 

  755.         String result = "[";

  756. 

  757.         auto* env = getEnv();

  758. 

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

  760.         {                                                                                                           \

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

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

  763.                                                                                                                     \

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

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

  766.                                                                                                                     \

  767.             if (size > 0)                                                                                           \

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

  769.                                                                                                                     \

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

  771.         }

  772. 

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

  774.             PRINT_ELEMENTS (jint, jintArray, Int)

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

  776.             PRINT_ELEMENTS (float, jfloatArray, Float)

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

  778.             PRINT_ELEMENTS (jboolean, jbooleanArray, Boolean)

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

  780.             PRINT_ELEMENTS (jbyte, jbyteArray, Byte);

  781. 

  782.         #undef PRINT_ELEMENTS

  783. 

  784.         result << "]";

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

  786.     }

  787. 

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

  789.     {

  790.         auto* env = getEnv();

  791. 

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

  793. 

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

  795. 

  796.         String result;

  797. 

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

  799.         {

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

  801. 

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

  803. 

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

  805.         }

  806. 

  807.         ignoreUnused (keyName);

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

  809.     }

  810. 

  811.     //==============================================================================

  812.     class StreamConfigurationMap

  813.     {

  814.     public:

  815.         StreamConfigurationMap (const GlobalRef& cameraCharacteristicsToUse)

  816.             : scalerStreamConfigurationMap (getStreamConfigurationMap (cameraCharacteristicsToUse)),

  817.               supportedPreviewOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

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

  819.                                                                 -1)),

  820.               supportedStillImageOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

  821.                                                                    LocalRef<jobject>(),

  822.                                                                    jpegImageFormat)),

  823.               supportedVideoRecordingOutputSizes (retrieveOutputSizes (scalerStreamConfigurationMap,

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

  825.                                                                        -1)),

  826.               defaultPreviewSize (getSmallestSize (supportedPreviewOutputSizes)),

  827.               previewBufferSize (getLargestSize (supportedPreviewOutputSizes))

  828.         {

  829.             printSizesLog (supportedPreviewOutputSizes, "SurfaceTexture");

  830.             printSizesLog (supportedStillImageOutputSizes, "JPEG");

  831.             printSizesLog (supportedVideoRecordingOutputSizes, "MediaRecorder");

  832.         }

  833. 

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

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

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

  837. 

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

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

  840. 

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

  842.         {

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

  844.         }

  845. 

  846.         static constexpr int jpegImageFormat = 256;

  847. 

  848.     private:

  849.         GlobalRef scalerStreamConfigurationMap;

  850. 

  851.         Array<Rectangle<int>> supportedPreviewOutputSizes;

  852.         Array<Rectangle<int>> supportedStillImageOutputSizes;

  853.         Array<Rectangle<int>> supportedVideoRecordingOutputSizes;

  854.         Rectangle<int> defaultPreviewSize, previewBufferSize;

  855. 

  856.         GlobalRef getStreamConfigurationMap (const GlobalRef& cameraCharacteristicsToUse)

  857.         {

  858.             auto* env = getEnv();

  859. 

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

  861.                                                                                                  CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP));

  862. 

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

  864.                                                                         CameraCharacteristics.get,

  865.                                                                         scalerStreamConfigurationMapKey.get())));

  866.         }

  867. 

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

  869.                                                           const LocalRef<jobject>& outputClass,

  870.                                                           int format)

  871.         {

  872.             Array<Rectangle<int>> result;

  873. 

  874.             auto* env = getEnv();

  875. 

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

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

  878.                                                                                              AndroidStreamConfigurationMap.getOutputSizesForClass,

  879.                                                                                              outputClass.get()))

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

  881.                                                                                              AndroidStreamConfigurationMap.getOutputSizesForFormat,

  882.                                                                                              (jint) format));

  883. 

  884.             if (format != -1)

  885.             {

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

  887. 

  888.                 if (! supported)

  889.                 {

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

  891.                     jassertfalse;

  892.                     return {};

  893.                 }

  894.             }

  895. 

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

  897. 

  898.             jassert (numSizes > 0);

  899. 

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

  901.             {

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

  903. 

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

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

  906. 

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

  908.             }

  909. 

  910.             return result;

  911.         }

  912. 

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

  914.         {

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

  916.                                                                         javaString (name).get()));

  917.         }

  918. 

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

  920.         {

  921.             ignoreUnused (sizes, className);

  922. 

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

  924. 

  925.           #if JUCE_CAMERA_LOG_ENABLED

  926.             for (auto& s : sizes)

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

  928.           #endif

  929.         }

  930. 

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

  932.         {

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

  934.                 return {};

  935. 

  936.             auto smallestSize = sizes[0];

  937. 

  938.             for (auto& size : sizes)

  939.             {

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

  941.                     smallestSize = size;

  942.             }

  943. 

  944.             return smallestSize;

  945.         }

  946. 

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

  948.         {

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

  950.                 return {};

  951. 

  952.             auto largestSize = sizes[0];

  953. 

  954.             for (auto& size : sizes)

  955.             {

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

  957.                     largestSize = size;

  958.             }

  959. 

  960.             return largestSize;

  961.         }

  962.     };

  963. 

  964.     //==============================================================================

  965.     class PreviewDisplay    : private TextureViewSurfaceTextureListener::Owner

  966.     {

  967.     public:

  968.         struct Listener

  969.         {

  970.             virtual ~Listener() {}

  971. 

  972.             virtual void previewDisplayReady() = 0;

  973.             virtual void previewDisplayAboutToBeDestroyed() = 0;

  974.         };

  975. 

  976.         PreviewDisplay (Rectangle<int> bufferSize)

  977.             : textureViewSurfaceTextureListener (*this),

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

  979.                                                                    getAppContext().get()))),

  980.               bufferWidth (bufferSize.getWidth()),

  981.               bufferHeight (bufferSize.getHeight())

  982.         {

  983.             auto* env = getEnv();

  984. 

  985.             if (! isReady())

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

  987.                                      CreateJavaInterface (&textureViewSurfaceTextureListener,

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

  989.         }

  990. 

  991.         ~PreviewDisplay() override

  992.         {

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

  994.         }

  995. 

  996.         void addListener (Listener* l)

  997.         {

  998.             if (l == nullptr)

  999.             {

  1000.                 jassertfalse;

  1001.                 return;

  1002.             }

  1003. 

  1004.             listeners.add (l);

  1005. 

  1006.             if (isReady())

  1007.                 l->previewDisplayReady();

  1008.         }

  1009. 

  1010.         void removeListener (Listener* l)

  1011.         {

  1012.             if (l == nullptr)

  1013.             {

  1014.                 jassertfalse;

  1015.                 return;

  1016.             }

  1017. 

  1018.             listeners.remove (l);

  1019.         }

  1020. 

  1021.         bool isReady() const

  1022.         {

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

  1024.                     && width > 0 && height > 0;

  1025.         }

  1026. 

  1027.         LocalRef<jobject> createSurface()

  1028.         {

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

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

  1031.             if (! isReady())

  1032.                 return LocalRef<jobject> (nullptr);

  1033. 

  1034.             auto* env = getEnv();

  1035. 

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

  1037.                                                                             AndroidTextureView.getSurfaceTexture));

  1038. 

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

  1040.             //     can result in a cropped preview.

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

  1042. 

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

  1044. 

  1045.             return surface;

  1046.         }

  1047. 

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

  1049. 

  1050.         void updateSurfaceTransform()

  1051.         {

  1052.             auto* env = getEnv();

  1053. 

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

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

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

  1057. 

  1058.             static constexpr int rotation90 = 1;

  1059.             static constexpr int rotation270 = 3;

  1060. 

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

  1062. 

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

  1064.             {

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

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

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

  1068.             }

  1069. 

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

  1071.         }

  1072. 

  1073.     private:

  1074.         ListenerList<Listener> listeners;

  1075. 

  1076.         TextureViewSurfaceTextureListener textureViewSurfaceTextureListener;

  1077.         GlobalRef textureView;

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

  1079.         int bufferWidth, bufferHeight;

  1080. 

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

  1082.         {

  1083.             JUCE_CAMERA_LOG ("onSurfaceTextureAvailable()");

  1084. 

  1085.             width = widthToUse;

  1086.             height = heightToUse;

  1087. 

  1088.             updateSurfaceTransform();

  1089. 

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

  1091.         }

  1092. 

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

  1094.         {

  1095.             JUCE_CAMERA_LOG ("onSurfaceTextureDestroyed()");

  1096. 

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

  1098. 

  1099.             return true;

  1100.         }

  1101. 

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

  1103.         {

  1104.             JUCE_CAMERA_LOG ("onSurfaceTextureSizeChanged()");

  1105. 

  1106.             width = widthToUse;

  1107.             height = heightToUse;

  1108. 

  1109.             updateSurfaceTransform();

  1110.         }

  1111. 

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

  1113.         {

  1114.             JUCE_CAMERA_LOG ("onSurfaceTextureUpdated()");

  1115.         }

  1116. 

  1117.         JUCE_DECLARE_NON_COPYABLE (PreviewDisplay)

  1118.     };

  1119. 

  1120.     //==============================================================================

  1121.     class ImageReader   : private ImageReaderOnImageAvailableListener::Owner

  1122.     {

  1123.     public:

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

  1125.                      int imageWidth, int imageHeight, int cameraSensorOrientationToUse)

  1126.             : owner (ownerToUse),

  1127.               cameraSensorOrientation (cameraSensorOrientationToUse),

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

  1129.                                                                                 imageWidth, imageHeight, StreamConfigurationMap::jpegImageFormat,

  1130.                                                                                 numImagesToKeep))),

  1131.               onImageAvailableListener (*this)

  1132.         {

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

  1134.                                       CreateJavaInterface (&onImageAvailableListener,

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

  1136.                                       handlerToUse.get());

  1137.         }

  1138. 

  1139.         ~ImageReader() override

  1140.         {

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

  1142.         }

  1143. 

  1144.         LocalRef<jobject> getSurface() const

  1145.         {

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

  1147.         }

  1148. 

  1149.         void resetNotificationFlag()

  1150.         {

  1151.             hasNotifiedListeners.set (0);

  1152.         }

  1153. 

  1154.     private:

  1155.         Pimpl& owner;

  1156.         int cameraSensorOrientation;

  1157. 

  1158.         GlobalRef imageReader;

  1159.         ImageReaderOnImageAvailableListener onImageAvailableListener;

  1160.         static constexpr int numImagesToKeep = 2;

  1161.         Atomic<int> hasNotifiedListeners { 0 };

  1162. 

  1163.         JUCE_DECLARE_WEAK_REFERENCEABLE (ImageReader)

  1164. 

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

  1166.         {

  1167.             JUCE_CAMERA_LOG ("onImageAvailable()");

  1168. 

  1169.             auto* env = getEnv();

  1170. 

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

  1172. 

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

  1174.                 return;

  1175. 

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

  1177. 

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

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

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

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

  1182.                                                                  cameraLensFrontFacing,

  1183.                                                                  cameraSensorOrientation);

  1184. 

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

  1186. 

  1187.             WeakReference<ImageReader> safeThis (this);

  1188. 

  1189.             owner.callListeners (image);

  1190. 

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

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

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

  1194.         }

  1195. 

  1196.         struct ImageBuffer

  1197.         {

  1198.             LocalRef<jbyteArray> byteArray;

  1199.             int size;

  1200.         };

  1201. 

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

  1203.                                                              Desktop::DisplayOrientation deviceOrientationFromAccelerometerSensor,

  1204.                                                              Desktop::DisplayOrientation targetOrientation,

  1205.                                                              bool cameraLensFrontFacing,

  1206.                                                              int cameraSensorOrientation)

  1207.         {

  1208.             auto* env = getEnv();

  1209. 

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

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

  1212. 

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

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

  1215. 

  1216.             ImageBuffer correctedBuffer = getImageBufferWithCorrectedOrientationFrom (byteBuffer, deviceOrientationFromAccelerometerSensor,

  1217.                                                                                       targetOrientation, cameraLensFrontFacing, cameraSensorOrientation);

  1218. 

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

  1220. 

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

  1222. 

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

  1224. 

  1225.             return result;

  1226.         }

  1227. 

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

  1229.                                                                        Desktop::DisplayOrientation deviceOrientationFromAccelerometerSensor,

  1230.                                                                        Desktop::DisplayOrientation targetOrientation,

  1231.                                                                        bool cameraLensFrontFacing,

  1232.                                                                        int cameraSensorOrientation)

  1233.         {

  1234.             auto* env = getEnv();

  1235. 

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

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

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

  1239. 

  1240.             auto rotationAngle = getRotationAngle (deviceOrientationFromAccelerometerSensor, targetOrientation,

  1241.                                                   cameraLensFrontFacing, cameraSensorOrientation);

  1242. 

  1243.             if (rotationAngle == 0)

  1244.             {

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

  1246.                 return { byteArray, bufferSize };

  1247.             }

  1248. 

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

  1250.                                                                               AndroidBitmapFactory.decodeByteArray,

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

  1252. 

  1253.             if (origBitmap == nullptr)

  1254.             {

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

  1256.                 return { byteArray, bufferSize };

  1257.             }

  1258. 

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

  1260. 

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

  1262.                                                                             ByteArrayOutputStream.constructor));

  1263. 

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

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

  1266.                                                                                   AndroidBitmapCompressFormat.valueOf,

  1267.                                                                                   jCompressFormatString.get()));

  1268. 

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

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

  1271.             {

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

  1273.                                                                                                     ByteArrayOutputStream.toByteArray));

  1274. 

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

  1276. 

  1277.                 return { correctedByteArray, correctedByteArraySize };

  1278.             }

  1279. 

  1280.             jassertfalse;

  1281.             // fallback, return original bitmap

  1282.             return { byteArray, bufferSize };

  1283.         }

  1284. 

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

  1286.                                      Desktop::DisplayOrientation targetOrientation,

  1287.                                      bool cameraLensFrontFacing,

  1288.                                      int cameraSensorOrientation)

  1289.         {

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

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

  1292. 

  1293.             if (cameraLensFrontFacing && isSensorOrientationHorizontal)

  1294.             {

  1295.                 // flip angles for front camera

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

  1297.             }

  1298. 

  1299.             switch (targetOrientation)

  1300.             {

  1301.                 case Desktop::rotatedAntiClockwise:

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

  1303.                 case Desktop::rotatedClockwise:

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

  1305.                 case Desktop::upright:

  1306.                 case Desktop::upsideDown:

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

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

  1309.                     {

  1310.                         return cameraSensorOrientation;

  1311.                     }

  1312.                     else

  1313.                     {

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

  1315.                             return cameraSensorOrientation;

  1316.                         else

  1317.                             return (cameraSensorOrientation + 180) % 360;

  1318.                     }

  1319.                     break;

  1320.                 case Desktop::allOrientations:

  1321.                 default:

  1322.                     return 0;

  1323.             }

  1324.         }

  1325. 

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

  1327.         {

  1328.             auto* env = getEnv();

  1329. 

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

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

  1332. 

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

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

  1335. 

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

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

  1338.                                                                                  (jint) origBitmapWidth, (jint) origBitmapHeight,

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

  1340. 

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

  1342. 

  1343.             return rotatedBitmap;

  1344.         }

  1345.     };

  1346. 

  1347.     //==============================================================================

  1348.     class MediaRecorder : private MediaRecorderOnInfoListener::Owner,

  1349.                           private MediaRecorderOnErrorListener::Owner

  1350.     {

  1351.     public:

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

  1353.                        int sensorOrientation, int cameraLensFacing)

  1354.             : onInfoListener (*this),

  1355.               onErrorListener (*this),

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

  1357.                                                                      AndroidMediaRecorder.constructor)))

  1358.         {

  1359.             auto* env = getEnv();

  1360. 

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

  1362.                                  CreateJavaInterface (&onInfoListener,

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

  1364. 

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

  1366.                                  CreateJavaInterface (&onErrorListener,

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

  1368. 

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

  1370.             //     the order is changed.

  1371.             static constexpr int audioSourceMic = 1;

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

  1373. 

  1374.             static constexpr int videoSourceSurface = 2;

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

  1376. 

  1377.             static constexpr int outputFormatMPEG4 = 2;

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

  1379. 

  1380.             static constexpr int audioEncoderAAC = 3;

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

  1382. 

  1383.             static constexpr int videoEncoderH264 = 2;

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

  1385. 

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

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

  1388. 

  1389.             auto frontFacing = cameraLensFacing == 0;

  1390. 

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

  1392. 

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

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

  1395. 

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

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

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

  1399.         }

  1400. 

  1401.         ~MediaRecorder() override

  1402.         {

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

  1404.         }

  1405. 

  1406.         LocalRef<jobject> getSurface()

  1407.         {

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

  1409.         }

  1410. 

  1411.         void start()

  1412.         {

  1413.             lockScreenOrientation();

  1414. 

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

  1416. 

  1417.             hasStartedRecording = true;

  1418.         }

  1419. 

  1420.         void stop()

  1421.         {

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

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

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

  1425.             if (! hasStartedRecording)

  1426.                 return;

  1427. 

  1428.             hasStartedRecording = false;

  1429. 

  1430.             auto* env = getEnv();

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

  1432. 

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

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

  1435.             jniCheckHasExceptionOccurredAndClear();

  1436. 

  1437.             unlockScreenOrientation();

  1438.         }

  1439. 

  1440.     private:

  1441.         MediaRecorderOnInfoListener onInfoListener;

  1442.         MediaRecorderOnErrorListener onErrorListener;

  1443.         GlobalRef mediaRecorder;

  1444.         bool hasStartedRecording = false;

  1445.         int orientationsEnabled = -1;

  1446. 

  1447.         void lockScreenOrientation()

  1448.         {

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

  1450. 

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

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

  1453.         }

  1454. 

  1455.         static jint juceOrientationToNativeOrientation (int orientations) noexcept

  1456.         {

  1457.             enum

  1458.             {

  1459.                 SCREEN_ORIENTATION_LANDSCAPE          = 0,

  1460.                 SCREEN_ORIENTATION_PORTRAIT           = 1,

  1461.                 SCREEN_ORIENTATION_USER               = 2,

  1462.                 SCREEN_ORIENTATION_REVERSE_LANDSCAPE  = 8,

  1463.                 SCREEN_ORIENTATION_REVERSE_PORTRAIT   = 9,

  1464.                 SCREEN_ORIENTATION_USER_LANDSCAPE     = 11,

  1465.                 SCREEN_ORIENTATION_USER_PORTRAIT      = 12,

  1466.             };

  1467. 

  1468.             switch (orientations)

  1469.             {

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

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

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

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

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

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

  1476.                 default:                                                        return (jint) SCREEN_ORIENTATION_USER;

  1477.             }

  1478.         }

  1479. 

  1480.         void unlockScreenOrientation()

  1481.         {

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

  1483.         }

  1484. 

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

  1486.         {

  1487.             ignoreUnused (recorder, what, extra);

  1488. 

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

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

  1491.         }

  1492. 

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

  1494.         {

  1495.             ignoreUnused (recorder, what, extra);

  1496. 

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

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

  1499.         }

  1500. 

  1501.         static String getInfoStringFromCode (int what)

  1502.         {

  1503.             enum

  1504.             {

  1505.                 MEDIA_RECORDER_INFO_UNKNOWN = 1,

  1506.                 MEDIA_RECORDER_INFO_MAX_DURATION_REACHED = 800,

  1507.                 MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED = 801,

  1508.                 MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING = 802,

  1509.                 MEDIA_RECORDER_INFO_NEXT_OUTPUT_FILE_STARTED = 803

  1510.             };

  1511. 

  1512.             switch (what)

  1513.             {

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

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

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

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

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

  1519.                 default: return String (what);

  1520.             };

  1521.         }

  1522. 

  1523.         static String getErrorStringFromCode (int what)

  1524.         {

  1525.             enum

  1526.             {

  1527.                 MEDIA_RECORDER_ERROR_UNKNOWN = 1,

  1528.                 MEDIA_ERROR_SERVER_DIED = 100

  1529.             };

  1530. 

  1531.             switch (what)

  1532.             {

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

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

  1535.                 default: return String (what);

  1536.             };

  1537.         }

  1538. 

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

  1540.         {

  1541.             auto* env = getEnv();

  1542. 

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

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

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

  1546. 

  1547.             enum

  1548.             {

  1549.                 ROTATION_0 = 0,

  1550.                 ROTATION_90,

  1551.                 ROTATION_180,

  1552.                 ROTATION_270

  1553.             };

  1554. 

  1555.             int hint = 0;

  1556. 

  1557.             switch (rotation)

  1558.             {

  1559.                 case ROTATION_0:   hint = cameraSensorOrientation;       break;

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

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

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

  1563.                 default: jassertfalse;

  1564.             }

  1565. 

  1566.             return (hint + 360) % 360;

  1567.         }

  1568.     };

  1569. 

  1570.     //==============================================================================

  1571.     class ScopedCameraDevice

  1572.     {

  1573.     public:

  1574.         //==============================================================================

  1575.         class CaptureSession

  1576.         {

  1577.         public:

  1578.             struct ConfiguredCallback

  1579.             {

  1580.                 virtual ~ConfiguredCallback() {}

  1581. 

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

  1583.             };

  1584. 

  1585.             ~CaptureSession()

  1586.             {

  1587.                 bool calledClose = false;

  1588. 

  1589.                 auto* env = getEnv();

  1590. 

  1591.                 {

  1592.                     const ScopedLock lock (captureSessionLock);

  1593. 

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

  1595.                     {

  1596.                         calledClose = true;

  1597. 

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

  1599.                     }

  1600.                 }

  1601. 

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

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

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

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

  1606.                 {

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

  1608.                 }

  1609.                 else if (calledClose)

  1610.                 {

  1611.                     pendingClose.set (1);

  1612.                     closedEvent.wait (-1);

  1613.                 }

  1614.             }

  1615. 

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

  1617. 

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

  1619. 

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

  1621.             {

  1622.                 if (! openedOk())

  1623.                 {

  1624.                     jassertfalse;

  1625.                     return false;

  1626.                 }

  1627. 

  1628.                 auto* env = getEnv();

  1629. 

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

  1631. 

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

  1633.                 {

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

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

  1636.                 }

  1637. 

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

  1639. 

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

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

  1642. 

  1643.                 return true;

  1644.             }

  1645. 

  1646.             void takeStillPicture (jobject targetSurface)

  1647.             {

  1648.                 if (stillPictureTaker == nullptr)

  1649.                 {

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

  1651.                     jassertfalse;

  1652.                     return;

  1653.                 }

  1654. 

  1655.                 auto* env = getEnv();

  1656. 

  1657.                 static constexpr int templateStillCapture = 2;

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

  1659.                                                                          AndroidCameraDevice.createCaptureRequest,

  1660.                                                                          (jint) templateStillCapture));

  1661. 

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

  1663. 

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

  1665. 

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

  1667. 

  1668.                 stillPictureTaker->takePicture (stillPictureCaptureRequest);

  1669.             }

  1670. 

  1671.         private:

  1672.             //==============================================================================

  1673.             class StillPictureTaker   : private AndroidRunnable::Owner

  1674.             {

  1675.             public:

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

  1677.                                    GlobalRef& previewCaptureRequestToUse, GlobalRef& handlerToUse,

  1678.                                    int autoFocusModeToUse)

  1679.                     : captureSession (captureSessionToUse),

  1680.                       captureRequestBuilder (captureRequestBuilderToUse),

  1681.                       previewCaptureRequest (previewCaptureRequestToUse),

  1682.                       handler (handlerToUse),

  1683.                       runnable (*this),

  1684.                       captureSessionPreviewCaptureCallback (createCaptureSessionCallback (true)),

  1685.                       captureSessionStillPictureCaptureCallback (createCaptureSessionCallback (false)),

  1686.                       autoFocusMode (autoFocusModeToUse)

  1687.                 {

  1688.                 }

  1689. 

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

  1691.                 {

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

  1693. 

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

  1695. 

  1696.                     lockFocus();

  1697.                 }

  1698. 

  1699.             private:

  1700.                 GlobalRef& captureSession;

  1701.                 GlobalRef& captureRequestBuilder;

  1702.                 GlobalRef& previewCaptureRequest;

  1703.                 GlobalRef& handler;

  1704. 

  1705.                 AndroidRunnable runnable;

  1706.                 GlobalRef delayedCaptureRunnable;

  1707. 

  1708.                 GlobalRef captureSessionPreviewCaptureCallback;

  1709. 

  1710.                 GlobalRef stillPictureCaptureRequest;

  1711.                 GlobalRef captureSessionStillPictureCaptureCallback;

  1712. 

  1713.                 int autoFocusMode;

  1714. 

  1715.                 //==============================================================================

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

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

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

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

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

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

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

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

  1724. 

  1725.                 DECLARE_JNI_CLASS_WITH_BYTECODE (CameraCaptureSessionCaptureCallback, "com/roli/juce/CameraCaptureSessionCaptureCallback", 21, CameraSupportByteCode, sizeof(CameraSupportByteCode))

  1726.                 #undef JNI_CLASS_MEMBERS

  1727. 

  1728.                 LocalRef<jobject> createCaptureSessionCallback (bool createPreviewSession)

  1729.                 {

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

  1731.                                                                   CameraCaptureSessionCaptureCallback.constructor,

  1732.                                                                   reinterpret_cast<jlong> (this),

  1733.                                                                   createPreviewSession ? 1 : 0));

  1734.                 }

  1735. 

  1736.                 //==============================================================================

  1737. 

  1738.                 enum class State

  1739.                 {

  1740.                     idle = 0,

  1741.                     pendingFocusLock,

  1742.                     pendingExposurePrecapture,

  1743.                     pendingExposurePostPrecapture,

  1744.                     pictureTaken

  1745.                 };

  1746. 

  1747.                 State currentState = State::idle;

  1748. 

  1749.                 void lockFocus()

  1750.                 {

  1751.                     if (jniCheckHasExceptionOccurredAndClear())

  1752.                         return;

  1753. 

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

  1755. 

  1756.                     currentState = State::pendingFocusLock;

  1757. 

  1758.                     auto* env = getEnv();

  1759. 

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

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

  1762.                     static constexpr int controlAfTriggerStart = 1;

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

  1764.                                                                         CaptureRequest.CONTROL_AF_TRIGGER,

  1765.                                                                         controlAfTriggerStart);

  1766. 

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

  1768.                                                                                     CaptureRequestBuilder.build));

  1769. 

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

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

  1772.                 }

  1773. 

  1774.                 void updateState (jobject captureResult)

  1775.                 {

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

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

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

  1779.                     if (jniCheckHasExceptionOccurredAndClear())

  1780.                         return;

  1781. 

  1782.                     switch (currentState)

  1783.                     {

  1784.                         case State::pendingFocusLock:

  1785.                         {

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

  1787. 

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

  1789. 

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

  1791.                             {

  1792.                                 captureStillPictureDelayed();

  1793.                                 return;

  1794.                             }

  1795. 

  1796.                             auto autoToFocusNotAvailable = autoFocusMode == 0;

  1797. 

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

  1799.                             {

  1800.                                 auto controlAeStateIntValue = getControlAEState (captureResult);

  1801.                                 static constexpr int controlAeStateConverged = 2;

  1802. 

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

  1804.                                 {

  1805.                                     currentState = State::pictureTaken;

  1806.                                     captureStillPictureDelayed();

  1807.                                 }

  1808.                                 else

  1809.                                 {

  1810.                                     runPrecaptureSequence();

  1811.                                 }

  1812.                             }

  1813. 

  1814.                             break;

  1815.                         }

  1816. 

  1817.                         case State::pendingExposurePrecapture:

  1818.                         {

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

  1820. 

  1821.                             auto controlAeStateIntValue = getControlAEState (captureResult);

  1822.                             static constexpr int controlAeStateFlashRequired = 4;

  1823.                             static constexpr int controlAeStatePrecapture = 5;

  1824. 

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

  1826.                                                              || controlAeStateIntValue == controlAeStatePrecapture)

  1827.                             {

  1828.                                 currentState = State::pendingExposurePostPrecapture;

  1829.                             }

  1830. 

  1831.                             break;

  1832.                         }

  1833. 

  1834.                         case State::pendingExposurePostPrecapture:

  1835.                         {

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

  1837. 

  1838.                             auto controlAeStateIntValue = getControlAEState (captureResult);

  1839.                             static constexpr int controlAeStatePrecapture = 5;

  1840. 

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

  1842.                             {

  1843.                                 currentState = State::pictureTaken;

  1844.                                 captureStillPictureDelayed();

  1845.                             }

  1846. 

  1847.                             break;

  1848.                         }

  1849.                         case State::idle:

  1850.                         case State::pictureTaken:

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

  1852.                     };

  1853.                 }

  1854. 

  1855.                 static int getControlAEState (jobject captureResult)

  1856.                 {

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

  1858. 

  1859.                     return controlAeStateValue.get() != nullptr

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

  1861.                 }

  1862. 

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

  1864.                 {

  1865.                     static constexpr int controlAfStateFocusedLocked = 4;

  1866.                     static constexpr int controlAfStateNotFocusedLocked = 5;

  1867. 

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

  1869. 

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

  1871.                 }

  1872. 

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

  1874.                 {

  1875.                     auto* env = getEnv();

  1876. 

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

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

  1879.                 }

  1880. 

  1881.                 void captureStillPictureDelayed()

  1882.                 {

  1883.                     if (jniCheckHasExceptionOccurredAndClear())

  1884.                         return;

  1885. 

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

  1887. 

  1888.                     auto* env = getEnv();

  1889. 

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

  1891. 

  1892.                     if (jniCheckHasExceptionOccurredAndClear())

  1893.                         return;

  1894. 

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

  1896. 

  1897.                     if (jniCheckHasExceptionOccurredAndClear())

  1898.                         return;

  1899. 

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

  1901.                     // stopRepeating/abortCaptures calls.

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

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

  1904. 

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

  1906.                 }

  1907. 

  1908.                 void runPrecaptureSequence()

  1909.                 {

  1910.                     if (jniCheckHasExceptionOccurredAndClear())

  1911.                         return;

  1912. 

  1913.                     auto* env = getEnv();

  1914. 

  1915.                     static constexpr int controlAePrecaptureTriggerStart = 1;

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

  1917.                                                                         CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,

  1918.                                                                         controlAePrecaptureTriggerStart);

  1919. 

  1920.                     currentState = State::pendingExposurePrecapture;

  1921. 

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

  1923.                                                                                     CaptureRequestBuilder.build));

  1924. 

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

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

  1927.                 }

  1928. 

  1929.                 void unlockFocus()

  1930.                 {

  1931.                     if (jniCheckHasExceptionOccurredAndClear())

  1932.                         return;

  1933. 

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

  1935. 

  1936.                     currentState = State::idle;

  1937. 

  1938.                     auto* env = getEnv();

  1939. 

  1940.                     static constexpr int controlAfTriggerCancel = 2;

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

  1942.                                                                         CaptureRequest.CONTROL_AF_TRIGGER,

  1943.                                                                         controlAfTriggerCancel);

  1944. 

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

  1946.                                                                                            CaptureRequestBuilder.build));

  1947. 

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

  1949.                                         nullptr, handler.get());

  1950. 

  1951.                     if (jniCheckHasExceptionOccurredAndClear())

  1952.                         return;

  1953. 

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

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

  1956.                                         nullptr, handler.get());

  1957.                 }

  1958.                 //==============================================================================

  1959.                 void run() override

  1960.                 {

  1961.                     captureStillPicture();

  1962.                 }

  1963. 

  1964.                 void captureStillPicture()

  1965.                 {

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

  1967.                                              stillPictureCaptureRequest.get(), captureSessionStillPictureCaptureCallback.get(),

  1968.                                              nullptr);

  1969.                 }

  1970. 

  1971.                 //==============================================================================

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

  1973.                 {

  1974.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureCompleted()");

  1975. 

  1976.                     ignoreUnused (session, request);

  1977. 

  1978.                     if (isPreview)

  1979.                         updateState (result);

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

  1981.                         unlockFocus();

  1982.                 }

  1983. 

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

  1985.                 {

  1986.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureFailed()");

  1987. 

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

  1989.                 }

  1990. 

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

  1992.                 {

  1993.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureProgressed()");

  1994. 

  1995.                     ignoreUnused (session, request);

  1996. 

  1997.                     if (isPreview)

  1998.                         updateState (partialResult);

  1999.                 }

  2000. 

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

  2002.                 {

  2003.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureSequenceAborted()");

  2004. 

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

  2006.                 }

  2007. 

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

  2009.                 {

  2010.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureSequenceCompleted()");

  2011. 

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

  2013.                 }

  2014. 

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

  2016.                 {

  2017.                     JUCE_CAMERA_LOG ("cameraCaptureSessionCaptureStarted()");

  2018. 

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

  2020.                 }

  2021. 

  2022.                 //==============================================================================

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

  2024.                 {

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

  2026.                     {

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

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

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

  2030. 

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

  2032.                     }

  2033.                 }

  2034. 

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

  2036.                 {

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

  2038.                     {

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

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

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

  2042. 

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

  2044.                     }

  2045.                 }

  2046. 

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

  2048.                 {

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

  2050.                     {

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

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

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

  2054. 

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

  2056.                     }

  2057.                 }

  2058. 

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

  2060.                 {

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

  2062.                     {

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

  2064. 

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

  2066.                     }

  2067.                 }

  2068. 

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

  2070.                 {

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

  2072.                     {

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

  2074. 

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

  2076.                     }

  2077.                 }

  2078. 

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

  2080.                 {

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

  2082.                     {

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

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

  2085. 

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

  2087.                     }

  2088.                 }

  2089.             };

  2090. 

  2091.             //==============================================================================

  2092.             ScopedCameraDevice& scopedCameraDevice;

  2093.             ConfiguredCallback& configuredCallback;

  2094.             GlobalRef& handler;

  2095. 

  2096.             GlobalRef captureRequestBuilder;

  2097.             GlobalRef previewCaptureRequest;

  2098. 

  2099.             GlobalRef captureSessionStateCallback;

  2100.             int autoFocusMode;

  2101. 

  2102.             GlobalRef captureSession;

  2103.             CriticalSection captureSessionLock;

  2104. 

  2105.             Atomic<int> pendingClose { 0 };

  2106. 

  2107.             std::unique_ptr<StillPictureTaker> stillPictureTaker;

  2108. 

  2109.             WaitableEvent closedEvent;

  2110. 

  2111.             JUCE_DECLARE_WEAK_REFERENCEABLE (CaptureSession)

  2112. 

  2113.             //==============================================================================

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

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

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

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

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

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

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

  2121. 

  2122.             DECLARE_JNI_CLASS_WITH_MIN_SDK (CameraCaptureSessionStateCallback, "com/roli/juce/CameraCaptureSessionStateCallback", 21)

  2123.             #undef JNI_CLASS_MEMBERS

  2124. 

  2125. 

  2126.             //==============================================================================

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

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

  2129.                             int captureSessionTemplate, int autoFocusModeToUse)

  2130.                 : scopedCameraDevice (scopedCameraDeviceToUse),

  2131.                   configuredCallback (configuredCallbackToUse),

  2132.                   handler (handlerToUse),

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

  2134.                                                                                         AndroidCameraDevice.createCaptureRequest,

  2135.                                                                                         (jint) captureSessionTemplate))),

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

  2137.                                                                                        CameraCaptureSessionStateCallback.constructor,

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

  2139.                   autoFocusMode (autoFocusModeToUse)

  2140.             {

  2141.                 auto* env = getEnv();

  2142. 

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

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

  2145. 

  2146.                 static constexpr int controlModeAuto = 1;

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

  2148. 

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

  2150.             }

  2151. 

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

  2153.             {

  2154.                 auto* env = getEnv();

  2155. 

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

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

  2158. 

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

  2160.             }

  2161. 

  2162.             void cameraCaptureSessionActive (jobject session)

  2163.             {

  2164.                 JUCE_CAMERA_LOG ("cameraCaptureSessionActive()");

  2165.                 ignoreUnused (session);

  2166.             }

  2167. 

  2168.             void cameraCaptureSessionClosed (jobject session)

  2169.             {

  2170.                 JUCE_CAMERA_LOG ("cameraCaptureSessionClosed()");

  2171.                 ignoreUnused (session);

  2172. 

  2173.                 closedEvent.signal();

  2174.             }

  2175. 

  2176.             void cameraCaptureSessionConfigureFailed (jobject session)

  2177.             {

  2178.                 JUCE_CAMERA_LOG ("cameraCaptureSessionConfigureFailed()");

  2179.                 ignoreUnused (session);

  2180. 

  2181.                 WeakReference<CaptureSession> weakRef (this);

  2182. 

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

  2184.                 {

  2185.                     if (weakRef == nullptr)

  2186.                         return;

  2187. 

  2188.                     configuredCallback.captureSessionConfigured (nullptr);

  2189.                 });

  2190.             }

  2191. 

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

  2193.             {

  2194.                 JUCE_CAMERA_LOG ("cameraCaptureSessionConfigured()");

  2195. 

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

  2197.                 {

  2198.                     // Already closing, bailout.

  2199.                     closedEvent.signal();

  2200. 

  2201.                     GlobalRef s (session);

  2202. 

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

  2204.                         {

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

  2206.                         });

  2207. 

  2208.                     return;

  2209.                 }

  2210. 

  2211.                 {

  2212.                     const ScopedLock lock (captureSessionLock);

  2213.                     captureSession = GlobalRef (session);

  2214.                 }

  2215. 

  2216.                 WeakReference<CaptureSession> weakRef (this);

  2217. 

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

  2219.                 {

  2220.                     if (weakRef == nullptr)

  2221.                         return;

  2222. 

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

  2224.                                                                     previewCaptureRequest, handler, autoFocusMode));

  2225. 

  2226.                     configuredCallback.captureSessionConfigured (this);

  2227.                 });

  2228.             }

  2229. 

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

  2231.             {

  2232.                 JUCE_CAMERA_LOG ("cameraCaptureSessionReady()");

  2233.                 ignoreUnused (session);

  2234.             }

  2235. 

  2236.             //==============================================================================

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

  2238.             {

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

  2240.                 {

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

  2242. 

  2243.                     myself->cameraCaptureSessionActive (session);

  2244.                 }

  2245.             }

  2246. 

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

  2248.             {

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

  2250.                 {

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

  2252. 

  2253.                     myself->cameraCaptureSessionClosed (session);

  2254.                 }

  2255.             }

  2256. 

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

  2258.             {

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

  2260.                 {

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

  2262. 

  2263.                     myself->cameraCaptureSessionConfigureFailed (session);

  2264.                 }

  2265.             }

  2266. 

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

  2268.             {

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

  2270.                 {

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

  2272. 

  2273.                     myself->cameraCaptureSessionConfigured (session);

  2274.                 }

  2275.             }

  2276. 

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

  2278.             {

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

  2280.                 {

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

  2282. 

  2283.                     myself->cameraCaptureSessionReady (session);

  2284.                 }

  2285.             }

  2286. 

  2287.             //==============================================================================

  2288.             friend class ScopedCameraDevice;

  2289. 

  2290.             JUCE_DECLARE_NON_COPYABLE (CaptureSession)

  2291.         };

  2292. 

  2293.         //==============================================================================

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

  2295.                             GlobalRef& handlerToUse, int autoFocusModeToUse)

  2296.             : owner (ownerToUse),

  2297.               cameraId (cameraIdToUse),

  2298.               cameraManager (cameraManagerToUse),

  2299.               handler (handlerToUse),

  2300.               cameraStateCallback (createCameraStateCallbackObject()),

  2301.               autoFocusMode (autoFocusModeToUse)

  2302.         {

  2303.             open();

  2304.         }

  2305. 

  2306.         ~ScopedCameraDevice()

  2307.         {

  2308.             close();

  2309.         }

  2310. 

  2311.         void open()

  2312.         {

  2313.             pendingOpen.set (1);

  2314. 

  2315.             auto* env = getEnv();

  2316. 

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

  2318.                                  javaString (cameraId).get(),

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

  2320. 

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

  2322.             // callback, silence the redundant exception.

  2323.             jniCheckHasExceptionOccurredAndClear();

  2324.         }

  2325. 

  2326.         void close()

  2327.         {

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

  2329.             {

  2330.                 auto* env = getEnv();

  2331. 

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

  2333.                 {

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

  2335.                     closedEvent.wait (-1);

  2336.                 }

  2337. 

  2338.                 pendingClose.set (0);

  2339.                 pendingOpen .set (0);

  2340.                 cameraDevice.clear();

  2341.             }

  2342.         }

  2343. 

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

  2345. 

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

  2347. 

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

  2349.                                               const LocalRef<jobject>& surfacesList,

  2350.                                               GlobalRef& handlerToUse,

  2351.                                               int captureSessionTemplate)

  2352.         {

  2353.             if (! openedOk())

  2354.             {

  2355.                 jassertfalse;

  2356.                 return nullptr;

  2357.             }

  2358. 

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

  2360.         }

  2361. 

  2362.     private:

  2363.         Pimpl& owner;

  2364.         const String cameraId;

  2365.         GlobalRef& cameraManager;

  2366.         GlobalRef& handler;

  2367. 

  2368.         GlobalRef cameraStateCallback;

  2369.         int autoFocusMode;

  2370. 

  2371.         GlobalRef cameraDevice;

  2372.         Atomic<int> pendingOpen { 0 };

  2373.         Atomic<int> pendingClose { 0 };

  2374.         Atomic<int> fatalErrorOccurred { 0 };

  2375.         String openError;

  2376. 

  2377.         WaitableEvent closedEvent;

  2378. 

  2379.         //==============================================================================

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

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

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

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

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

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

  2386. 

  2387.         DECLARE_JNI_CLASS_WITH_MIN_SDK (CameraDeviceStateCallback, "com/roli/juce/CameraDeviceStateCallback", 21)

  2388.         #undef JNI_CLASS_MEMBERS

  2389. 

  2390.         LocalRef<jobject> createCameraStateCallbackObject()

  2391.         {

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

  2393.                                                            CameraDeviceStateCallback.constructor,

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

  2395.         }

  2396. 

  2397.         //==============================================================================

  2398.         void cameraDeviceStateClosed()

  2399.         {

  2400.             JUCE_CAMERA_LOG ("cameraDeviceStateClosed()");

  2401. 

  2402.             closedEvent.signal();

  2403.         }

  2404. 

  2405.         void cameraDeviceStateDisconnected()

  2406.         {

  2407.             JUCE_CAMERA_LOG ("cameraDeviceStateDisconnected()");

  2408. 

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

  2410.             {

  2411.                 openError = "Device disconnected";

  2412. 

  2413.                 notifyOpenResult();

  2414.             }

  2415. 

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

  2417.         }

  2418. 

  2419.         void cameraDeviceStateError (int errorCode)

  2420.         {

  2421.             String error = cameraErrorCodeToString (errorCode);

  2422. 

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

  2424. 

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

  2426.             {

  2427.                 openError = error;

  2428. 

  2429.                 notifyOpenResult();

  2430.             }

  2431. 

  2432.             fatalErrorOccurred.set (1);

  2433. 

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

  2435.                                        {

  2436.                                            owner.cameraDeviceError (error);

  2437.                                            close();

  2438.                                        });

  2439.         }

  2440. 

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

  2442.         {

  2443.             JUCE_CAMERA_LOG ("cameraDeviceStateOpened()");

  2444. 

  2445.             pendingOpen.set (0);

  2446. 

  2447.             cameraDevice = GlobalRef (cameraDeviceToUse);

  2448. 

  2449.             notifyOpenResult();

  2450.         }

  2451. 

  2452.         void notifyOpenResult()

  2453.         {

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

  2455.         }

  2456. 

  2457.         //==============================================================================

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

  2459.         {

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

  2461.                 myself->cameraDeviceStateClosed();

  2462.         }

  2463. 

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

  2465.         {

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

  2467.                 myself->cameraDeviceStateDisconnected();

  2468.         }

  2469. 

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

  2471.         {

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

  2473.                 myself->cameraDeviceStateError (error);

  2474.         }

  2475. 

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

  2477.         {

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

  2479.             {

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

  2481. 

  2482.                 myself->cameraDeviceStateOpened (camera);

  2483.             }

  2484.         }

  2485.     };

  2486. 

  2487.     //==============================================================================

  2488.     struct CaptureSessionModeBase

  2489.     {

  2490.         virtual ~CaptureSessionModeBase() = default;

  2491. 

  2492.         virtual bool isVideoRecordSession() const = 0;

  2493. 

  2494.         virtual void triggerStillPictureCapture() = 0;

  2495.     };

  2496. 

  2497.     //==============================================================================

  2498.     template <typename Mode>

  2499.     struct CaptureSessionMode   : public CaptureSessionModeBase,

  2500.                                   private PreviewDisplay::Listener,

  2501.                                   private ScopedCameraDevice::CaptureSession::ConfiguredCallback

  2502.     {

  2503.         ~CaptureSessionMode() override

  2504.         {

  2505.             captureSession.reset();

  2506. 

  2507.             previewDisplay.removeListener (this);

  2508.         }

  2509. 

  2510.         bool isVideoRecordSession() const override

  2511.         {

  2512.             return Mode::isVideoRecord();

  2513.         }

  2514. 

  2515.         void triggerStillPictureCapture() override

  2516.         {

  2517.             if (captureSession == nullptr)

  2518.             {

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

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

  2521.                 jassertfalse;

  2522.                 return;

  2523.             }

  2524. 

  2525.             crtp().takeStillPicture();

  2526.         }

  2527. 

  2528.     protected:

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

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

  2531.                             int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

  2532.             : owner (ownerToUse),

  2533.               scopedCameraDevice (cameraDeviceToUse),

  2534.               handler (handlerToUse),

  2535.               previewDisplay (pd),

  2536.               cameraSensorOrientation (cameraSensorOrientationToUse),

  2537.               cameraLensFacing (cameraLensFacingToUse),

  2538.               streamConfigurationMap (streamConfigurationMapToUse)

  2539.         {

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

  2541. 

  2542.             if (weakRef == nullptr)

  2543.                 return;

  2544. 

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

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

  2547.             {

  2548.                 if (weakRef == nullptr)

  2549.                     return;

  2550. 

  2551.                 previewDisplay.addListener (this);

  2552.             });

  2553.         }

  2554. 

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

  2556. 

  2557.         void previewDisplayReady() override

  2558.         {

  2559.             jassert (previewDisplay.isReady());

  2560. 

  2561.             JUCE_CAMERA_LOG ("previewDisplayReady()");

  2562. 

  2563.             // close previous capture session first

  2564.             captureSession.reset();

  2565. 

  2566.             if (scopedCameraDevice.hasErrorOccurred())

  2567.             {

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

  2569.                 return;

  2570.             }

  2571. 

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

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

  2574.         }

  2575. 

  2576.         void previewDisplayAboutToBeDestroyed() override

  2577.         {

  2578.             JUCE_CAMERA_LOG ("previewDisplayAboutToBeDestroyed()");

  2579. 

  2580.             stopPreview();

  2581.         }

  2582. 

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

  2584.         {

  2585.             if (session == nullptr)

  2586.             {

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

  2588.                 return;

  2589.             }

  2590. 

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

  2592. 

  2593.             startSession();

  2594.         }

  2595. 

  2596.         void startSession()

  2597.         {

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

  2599.             {

  2600.                 jassertfalse;

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

  2602.             }

  2603. 

  2604.             crtp().sessionStarted();

  2605.         }

  2606. 

  2607.         void stopPreview()

  2608.         {

  2609.             if (captureSession != nullptr)

  2610.             {

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

  2612. 

  2613.                 auto* env = getEnv();

  2614. 

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

  2616. 

  2617.                 if (jniCheckHasExceptionOccurredAndClear())

  2618.                     return;

  2619. 

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

  2621. 

  2622.                 jniCheckHasExceptionOccurredAndClear();

  2623.             }

  2624.         }

  2625. 

  2626.         Pimpl& owner;

  2627.         ScopedCameraDevice& scopedCameraDevice;

  2628.         GlobalRef& handler;

  2629.         PreviewDisplay& previewDisplay;

  2630.         int cameraSensorOrientation;

  2631.         int cameraLensFacing;

  2632.         StreamConfigurationMap& streamConfigurationMap;

  2633. 

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

  2635. 

  2636.         JUCE_DECLARE_WEAK_REFERENCEABLE (CaptureSessionMode<Mode>)

  2637.     };

  2638. 

  2639.     //==============================================================================

  2640.     struct CaptureSessionPreviewMode : public CaptureSessionMode<CaptureSessionPreviewMode>

  2641.     {

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

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

  2644.                                    int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

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

  2646.                                                              sensorOrientation, cameraLensFacingToUse, streamConfigurationMapToUse),

  2647.               imageReader (ir)

  2648.         {

  2649.         }

  2650. 

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

  2652.         LocalRef<jobject> getCaptureSessionSurfaces() const

  2653.         {

  2654.             auto* env = getEnv();

  2655. 

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

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

  2658. 

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

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

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

  2662. 

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

  2664. 

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

  2666.             jassert (supported);

  2667. 

  2668.             return arrayList;

  2669.         }

  2670. 

  2671.         // Surfaces set as target during capture.

  2672.         LocalRef<jobject> getTargetSurfaces() const

  2673.         {

  2674.             auto* env = getEnv();

  2675. 

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

  2677. 

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

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

  2680. 

  2681.             return arrayList;

  2682.         }

  2683. 

  2684.         static int getTemplate()

  2685.         {

  2686.             static constexpr int templatePreview = 1;

  2687.             return templatePreview;

  2688.         }

  2689. 

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

  2691. 

  2692.         void sessionStarted() {}

  2693. 

  2694.         void takeStillPicture()

  2695.         {

  2696.             imageReader.resetNotificationFlag();

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

  2698.         }

  2699. 

  2700.     private:

  2701.         ImageReader& imageReader;

  2702.     };

  2703. 

  2704.     //==============================================================================

  2705.     struct CaptureSessionVideoRecordingMode : public CaptureSessionMode<CaptureSessionVideoRecordingMode>

  2706.     {

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

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

  2709.                                           int cameraLensFacingToUse, StreamConfigurationMap& streamConfigurationMapToUse)

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

  2711.                                                                     sensorOrientation, cameraLensFacingToUse, streamConfigurationMapToUse),

  2712.               mediaRecorder (mr)

  2713.         {

  2714.         }

  2715. 

  2716.         ~CaptureSessionVideoRecordingMode()

  2717.         {

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

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

  2720.             stopPreview();

  2721. 

  2722.             mediaRecorder.stop();

  2723.         }

  2724. 

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

  2726.         LocalRef<jobject> getCaptureSessionSurfaces() const

  2727.         {

  2728.             auto* env = getEnv();

  2729. 

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

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

  2732. 

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

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

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

  2736. 

  2737.             return arrayList;

  2738.         }

  2739. 

  2740.         // Surfaces set as target during capture.

  2741.         LocalRef<jobject> getTargetSurfaces() const

  2742.         {

  2743.             // Same surfaces used.

  2744.             return getCaptureSessionSurfaces();

  2745.         }

  2746. 

  2747.         static int getTemplate()

  2748.         {

  2749.             static constexpr int templateRecord = 3;

  2750.             return templateRecord;

  2751.         }

  2752. 

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

  2754. 

  2755.         void sessionStarted()

  2756.         {

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

  2758.         }

  2759. 

  2760.         void takeStillPicture()

  2761.         {

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

  2763.             jassertfalse;

  2764.         }

  2765. 

  2766.     private:

  2767.         MediaRecorder& mediaRecorder;

  2768.     };

  2769. 

  2770.     //==============================================================================

  2771.     class DeviceOrientationChangeListener   : private Timer

  2772.     {

  2773.     public:

  2774.         DeviceOrientationChangeListener (PreviewDisplay& pd)

  2775.             : previewDisplay (pd),

  2776.               orientationEventListener (createOrientationEventListener()),

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

  2778.                                                             OrientationEventListener.canDetectOrientation) != 0),

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

  2780.               lastKnownScreenOrientation (deviceOrientation)

  2781.         {

  2782.             setEnabled (true);

  2783.         }

  2784. 

  2785.         ~DeviceOrientationChangeListener() override

  2786.         {

  2787.             setEnabled (false);

  2788.         }

  2789. 

  2790.         void setEnabled (bool shouldBeEnabled)

  2791.         {

  2792.             if (shouldBeEnabled && ! canDetectChange)

  2793.             {

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

  2795.                 jassertfalse;

  2796.                 return;

  2797.             }

  2798. 

  2799.             if (shouldBeEnabled)

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

  2801.             else

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

  2803.         }

  2804. 

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

  2806. 

  2807.         Desktop::DisplayOrientation getDeviceOrientation() const noexcept

  2808.         {

  2809.             return deviceOrientation;

  2810.         }

  2811. 

  2812.     private:

  2813.         PreviewDisplay& previewDisplay;

  2814. 

  2815.         GlobalRef orientationEventListener;

  2816.         static constexpr jint sensorDelayUI = 2;

  2817. 

  2818.         bool canDetectChange;

  2819.         Desktop::DisplayOrientation deviceOrientation;

  2820. 

  2821.         Desktop::DisplayOrientation lastKnownScreenOrientation;

  2822.         int numChecksForOrientationChange = 10;

  2823. 

  2824.         //==============================================================================

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

  2826.             METHOD (canDetectOrientation, "canDetectOrientation", "()Z") \

  2827.             METHOD (constructor,          "<init>",               "(JLandroid/content/Context;I)V") \

  2828.             METHOD (disable,              "disable",              "()V") \

  2829.             METHOD (enable,               "enable",               "()V") \

  2830.             CALLBACK (deviceOrientationChanged, "deviceOrientationChanged", "(JI)V")

  2831. 

  2832.         DECLARE_JNI_CLASS_WITH_MIN_SDK (OrientationEventListener, "com/roli/juce/JuceOrientationEventListener", 21)

  2833.         #undef JNI_CLASS_MEMBERS

  2834. 

  2835.         LocalRef<jobject> createOrientationEventListener()

  2836.         {

  2837.             return LocalRef<jobject> (getEnv()->NewObject (OrientationEventListener,

  2838.                                                            OrientationEventListener.constructor,

  2839.                                                            reinterpret_cast<jlong> (this),

  2840.                                                            getAppContext().get(),

  2841.                                                            sensorDelayUI));

  2842.         }

  2843. 

  2844.         //==============================================================================

  2845.         void orientationChanged (int orientation)

  2846.         {

  2847.             jassert (orientation < 360);

  2848. 

  2849.             // -1 == unknown

  2850.             if (orientation < 0)

  2851.                 return;

  2852. 

  2853.             auto oldOrientation = deviceOrientation;

  2854. 

  2855.             // NB: this assumes natural position to be portrait always, but some devices may be landscape...

  2856.             if (orientation > (360 - 45) || orientation < 45)

  2857.                 deviceOrientation = Desktop::upright;

  2858.             else if (orientation < 135)

  2859.                 deviceOrientation = Desktop::rotatedClockwise;

  2860.             else if (orientation < 225)

  2861.                 deviceOrientation = Desktop::upsideDown;

  2862.             else

  2863.                 deviceOrientation = Desktop::rotatedAntiClockwise;

  2864. 

  2865.             if (oldOrientation != deviceOrientation)

  2866.             {

  2867.                 lastKnownScreenOrientation = Desktop::getInstance().getCurrentOrientation();

  2868. 

  2869.                 // Need to update preview transform, but screen orientation will change slightly

  2870.                 // later than sensor orientation.

  2871.                 startTimer (500);

  2872.             }

  2873.         }

  2874. 

  2875.         void timerCallback() override

  2876.         {

  2877.             auto currentOrientation = Desktop::getInstance().getCurrentOrientation();

  2878. 

  2879.             if (lastKnownScreenOrientation != currentOrientation)

  2880.             {

  2881.                 lastKnownScreenOrientation = currentOrientation;

  2882. 

  2883.                 stopTimer();

  2884.                 numChecksForOrientationChange = 10;

  2885.                 previewDisplay.updateSurfaceTransform();

  2886. 

  2887.                 return;

  2888.             }

  2889. 

  2890.             if (--numChecksForOrientationChange == 0)

  2891.             {

  2892.                 stopTimer();

  2893.                 numChecksForOrientationChange = 10;

  2894.             }

  2895.         }

  2896. 

  2897.         static void deviceOrientationChanged (JNIEnv*, jobject /*obj*/, jlong host, jint orientation)

  2898.         {

  2899.             if (auto* myself = reinterpret_cast<DeviceOrientationChangeListener*> (host))

  2900.                 myself->orientationChanged (orientation);

  2901.         }

  2902.     };

  2903. 

  2904.     //==============================================================================

  2905.     CameraDevice& owner;

  2906.     int minWidth, minHeight, maxWidth, maxHeight;

  2907. 

  2908.     String cameraId;

  2909.     InternalOpenCameraResultCallback cameraOpenCallback;

  2910. 

  2911.     GlobalRef activityLifeListener;

  2912. 

  2913.     GlobalRef cameraManager;

  2914.     GlobalRef cameraCharacteristics;

  2915.     GlobalRef handlerThread;

  2916.     GlobalRef handler;

  2917. 

  2918.     StreamConfigurationMap streamConfigurationMap;

  2919.     PreviewDisplay previewDisplay;

  2920.     DeviceOrientationChangeListener deviceOrientationChangeListener;

  2921.     std::unique_ptr<ImageReader> imageReader;

  2922.     std::unique_ptr<MediaRecorder> mediaRecorder;

  2923. 

  2924.     std::unique_ptr<CaptureSessionModeBase> currentCaptureSessionMode;

  2925. 

  2926.     std::unique_ptr<ScopedCameraDevice> scopedCameraDevice;

  2927. 

  2928.     CriticalSection listenerLock;

  2929.     ListenerList<Listener> listeners;

  2930. 

  2931.     std::function<void(const Image&)> pictureTakenCallback;

  2932. 

  2933.     Time firstRecordedFrameTimeMs;

  2934.     bool notifiedOfCameraOpening = false;

  2935. 

  2936.     bool appWasPaused = false;

  2937. 

  2938.     //==============================================================================

  2939.     int getCameraSensorOrientation() const

  2940.     {

  2941.         return getCameraCharacteristicsIntegerKeyValue (CameraCharacteristics.SENSOR_ORIENTATION);

  2942.     }

  2943. 

  2944.     int getAutoFocusModeToUse() const

  2945.     {

  2946.         auto supportedModes = getSupportedAutoFocusModes();

  2947. 

  2948.         enum

  2949.         {

  2950.             CONTROL_AF_MODE_OFF = 0,

  2951.             CONTROL_AF_MODE_AUTO = 1,

  2952.             CONTROL_AF_MODE_CONTINUOUS_PICTURE = 4

  2953.         };

  2954. 

  2955.         if (supportedModes.contains (CONTROL_AF_MODE_CONTINUOUS_PICTURE))

  2956.             return CONTROL_AF_MODE_CONTINUOUS_PICTURE;

  2957. 

  2958.         if (supportedModes.contains (CONTROL_AF_MODE_AUTO))

  2959.             return CONTROL_AF_MODE_AUTO;

  2960. 

  2961.         return CONTROL_AF_MODE_OFF;

  2962.     }

  2963. 

  2964.     Array<int> getSupportedAutoFocusModes() const

  2965.     {

  2966.         auto* env = getEnv();

  2967. 

  2968.         auto jKey = LocalRef<jobject> (env->GetStaticObjectField (CameraCharacteristics, CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES));

  2969. 

  2970.         auto supportedModes = LocalRef<jintArray> ((jintArray) env->CallObjectMethod (cameraCharacteristics,

  2971.                                                                                       CameraCharacteristics.get,

  2972.                                                                                       jKey.get()));

  2973. 

  2974.         return jintArrayToJuceArray (supportedModes);

  2975.     }

  2976. 

  2977.     static Array<int> jintArrayToJuceArray (const LocalRef<jintArray>& jArray)

  2978.     {

  2979.         auto* env = getEnv();

  2980. 

  2981.         auto* jArrayElems = env->GetIntArrayElements (jArray, nullptr);

  2982.         auto numElems = env->GetArrayLength (jArray);

  2983. 

  2984.         Array<int> juceArray;

  2985. 

  2986.         for (int s = 0; s < numElems; ++s)

  2987.             juceArray.add (jArrayElems[s]);

  2988. 

  2989.         env->ReleaseIntArrayElements (jArray, jArrayElems, 0);

  2990.         return juceArray;

  2991.     }

  2992. 

  2993.     int getCameraCharacteristicsIntegerKeyValue (jfieldID key) const

  2994.     {

  2995.         auto* env = getEnv();

  2996. 

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

  2998. 

  2999.         auto jValue = LocalRef<jobject> (env->CallObjectMethod (cameraCharacteristics,

  3000.                                                                 CameraCharacteristics.get,

  3001.                                                                 jKey.get()));

  3002. 

  3003.         return env->CallIntMethod (jValue, JavaInteger.intValue);

  3004.     }

  3005. 

  3006.     int getCameraLensFacing() const

  3007.     {

  3008.         return getCameraCharacteristicsIntegerKeyValue (CameraCharacteristics.LENS_FACING);

  3009.     }

  3010. 

  3011.     //==============================================================================

  3012.     void cameraOpenFinished (const String& error)

  3013.     {

  3014.         JUCE_CAMERA_LOG ("cameraOpenFinished(), error = " + error);

  3015. 

  3016.         if (error.isEmpty())

  3017.         {

  3018.             setupStillImageSize();

  3019.             startPreviewMode (*imageReader);

  3020.         }

  3021. 

  3022.         // Do not notify about camera being reopened on app resume.

  3023.         if (! notifiedOfCameraOpening)

  3024.         {

  3025.             notifiedOfCameraOpening = true;

  3026. 

  3027.             invokeCameraOpenCallback (error);

  3028.         }

  3029.     }

  3030. 

  3031.     void cameraDeviceError (const String& error)

  3032.     {

  3033.         if (owner.onErrorOccurred != nullptr)

  3034.             owner.onErrorOccurred (error);

  3035.     }

  3036. 

  3037.     void invokeCameraOpenCallback (const String& error)

  3038.     {

  3039.         JUCE_CAMERA_LOG ("invokeCameraOpenCallback(), error = " + error);

  3040. 

  3041.         if (cameraOpenCallback != nullptr)

  3042.             cameraOpenCallback (cameraId, error);

  3043.     }

  3044. 

  3045.     //==============================================================================

  3046.     void callListeners (const Image& image)

  3047.     {

  3048.         const ScopedLock sl (listenerLock);

  3049.         listeners.call ([=] (Listener& l) { l.imageReceived (image); });

  3050.     }

  3051. 

  3052.     void notifyPictureTaken (const Image& image)

  3053.     {

  3054.         JUCE_CAMERA_LOG ("notifyPictureTaken()");

  3055. 

  3056.         if (pictureTakenCallback != nullptr)

  3057.             pictureTakenCallback (image);

  3058.     }

  3059. 

  3060.     void triggerStillPictureCapture()

  3061.     {

  3062.         currentCaptureSessionMode->triggerStillPictureCapture();

  3063.     }

  3064. 

  3065.     //==============================================================================

  3066.     void setupStillImageSize()

  3067.     {

  3068.         imageReader.reset();

  3069. 

  3070.         auto imageSize = chooseBestSize (minWidth, minHeight, maxWidth, maxHeight,

  3071.                                          streamConfigurationMap.getSupportedStillImageOutputSizes());

  3072. 

  3073.         imageReader.reset (new ImageReader (*this, handler, imageSize.getWidth(), imageSize.getHeight(),

  3074.                                             getCameraSensorOrientation()));

  3075.     }

  3076. 

  3077.     static Rectangle<int> chooseBestSize (int minWidth, int minHeight, int maxWidth, int maxHeight,

  3078.                                           Array<Rectangle<int>> supportedSizes)

  3079.     {

  3080.         Rectangle<int> result;

  3081. 

  3082.         for (auto& size : supportedSizes)

  3083.         {

  3084.             auto width  = size.getWidth();

  3085.             auto height = size.getHeight();

  3086. 

  3087.             if (width < minWidth || width > maxWidth || height < minHeight || height > maxHeight)

  3088.                 continue;

  3089. 

  3090.             if (size.contains (result))

  3091.                 result = size;

  3092.         }

  3093. 

  3094.         // None of the supported sizes matches required width & height limitations, picking

  3095.         // the first one available...

  3096.         jassert (! result.isEmpty());

  3097. 

  3098.         if (result.isEmpty())

  3099.             result = supportedSizes[0];

  3100. 

  3101.         return result;

  3102.     }

  3103. 

  3104.     //==============================================================================

  3105.     void startPreviewMode (ImageReader& ir)

  3106.     {

  3107.         if (currentCaptureSessionMode != nullptr && ! currentCaptureSessionMode->isVideoRecordSession())

  3108.             return;

  3109. 

  3110.         // previous mode has to be stopped first

  3111.         jassert (currentCaptureSessionMode.get() == nullptr);

  3112. 

  3113.         if (scopedCameraDevice == nullptr || ! scopedCameraDevice->openedOk())

  3114.             return;

  3115. 

  3116.         currentCaptureSessionMode.reset (new CaptureSessionPreviewMode (*this, *scopedCameraDevice, handler,

  3117.                                                                         previewDisplay, ir,

  3118.                                                                         getCameraSensorOrientation(),

  3119.                                                                         getCameraLensFacing(),

  3120.                                                                         streamConfigurationMap));

  3121.     }

  3122. 

  3123.     void startVideoRecordingMode (MediaRecorder& mr)

  3124.     {

  3125.         if (currentCaptureSessionMode != nullptr && currentCaptureSessionMode->isVideoRecordSession())

  3126.             return;

  3127. 

  3128.         // previous mode has to be stopped first

  3129.         jassert (currentCaptureSessionMode.get() == nullptr);

  3130. 

  3131.         jassert (scopedCameraDevice != nullptr && scopedCameraDevice->openedOk());

  3132. 

  3133.         if (scopedCameraDevice == nullptr || ! scopedCameraDevice->openedOk())

  3134.             return;

  3135. 

  3136.         currentCaptureSessionMode.reset (new CaptureSessionVideoRecordingMode (*this, *scopedCameraDevice, handler,

  3137.                                                                                previewDisplay, mr,

  3138.                                                                                getCameraSensorOrientation(),

  3139.                                                                                getCameraLensFacing(),

  3140.                                                                                streamConfigurationMap));

  3141.     }

  3142. 

  3143.     //==============================================================================

  3144.     void onActivityPaused (jobject) override

  3145.     {

  3146.         JUCE_CAMERA_LOG ("appPaused, closing camera...");

  3147. 

  3148.         appWasPaused = true;

  3149. 

  3150.         deviceOrientationChangeListener.setEnabled (false);

  3151. 

  3152.         // We need to restart the whole session mode when the app gets resumed.

  3153.         currentCaptureSessionMode.reset();

  3154. 

  3155.         if (scopedCameraDevice != nullptr)

  3156.             scopedCameraDevice->close();

  3157. 

  3158.         stopBackgroundThread();

  3159.     }

  3160. 

  3161.     void onActivityResumed (jobject) override

  3162.     {

  3163.         // Only care about resumed event when paused event was called first.

  3164.         if (! appWasPaused)

  3165.             return;

  3166. 

  3167.         JUCE_CAMERA_LOG ("appResumed, opening camera...");

  3168. 

  3169.         deviceOrientationChangeListener.setEnabled (true);

  3170. 

  3171.         startBackgroundThread();

  3172. 

  3173.         if (scopedCameraDevice != nullptr)

  3174.             scopedCameraDevice->open();

  3175.     }

  3176. 

  3177.     void startBackgroundThread()

  3178.     {

  3179.         auto* env = getEnv();

  3180. 

  3181.         handlerThread = GlobalRef (LocalRef<jobject> (env->NewObject (AndroidHandlerThread,

  3182.                                                                       AndroidHandlerThread.constructor,

  3183.                                                                       javaString ("JuceCameraDeviceBackgroundThread").get())));

  3184.         // handler thread has to be started before its looper can be fetched

  3185.         env->CallVoidMethod (handlerThread, AndroidHandlerThread.start);

  3186.         handler = GlobalRef (LocalRef<jobject> (env->NewObject (AndroidHandler,

  3187.                                                                 AndroidHandler.constructorWithLooper,

  3188.                                                                 env->CallObjectMethod (handlerThread, AndroidHandlerThread.getLooper))));

  3189.     }

  3190. 

  3191.     void stopBackgroundThread()

  3192.     {

  3193.         auto* env = getEnv();

  3194. 

  3195.         auto quitSafelyMethod = env->GetMethodID(AndroidHandlerThread, "quitSafely", "()Z");

  3196. 

  3197.         // this code will only run on SDK >= 21

  3198.         jassert(quitSafelyMethod != nullptr);

  3199. 

  3200.         env->CallBooleanMethod (handlerThread, quitSafelyMethod);

  3201.         env->CallVoidMethod (handlerThread, AndroidHandlerThread.join);

  3202. 

  3203.         jniCheckHasExceptionOccurredAndClear();

  3204. 

  3205.         handlerThread.clear();

  3206.         handler.clear();

  3207.     }

  3208. 

  3209.     friend struct CameraDevice::ViewerComponent;

  3210. 

  3211.     JUCE_DECLARE_NON_COPYABLE (Pimpl)

  3212. };

  3213. 

  3214. //==============================================================================

  3215. struct CameraDevice::ViewerComponent  : public Component,

  3216.                                         private ComponentMovementWatcher

  3217. {

  3218.     ViewerComponent (CameraDevice& device) : ComponentMovementWatcher (this)

  3219.     {

  3220.         auto previewSize = device.pimpl->streamConfigurationMap.getDefaultPreviewSize();

  3221. 

  3222.         targetAspectRatio = previewSize.getWidth() / (float) previewSize.getHeight();

  3223. 

  3224.         if (isOrientationLandscape())

  3225.             setBounds (previewSize);

  3226.         else

  3227.             setBounds (0, 0, previewSize.getHeight(), previewSize.getWidth());

  3228. 

  3229.         addAndMakeVisible (viewerComponent);

  3230.         viewerComponent.setView (device.pimpl->previewDisplay.getNativeView());

  3231.     }

  3232. 

  3233. private:

  3234.     AndroidViewComponent viewerComponent;

  3235. 

  3236.     float targetAspectRatio = 1.0f;

  3237. 

  3238.     void componentMovedOrResized (bool, bool) override

  3239.     {

  3240.         auto b = getLocalBounds();

  3241. 

  3242.         auto targetWidth  = b.getWidth();

  3243.         auto targetHeight = b.getHeight();

  3244. 

  3245.         if (isOrientationLandscape())

  3246.         {

  3247.             auto currentAspectRatio = b.getWidth() / (float) b.getHeight();

  3248. 

  3249.             if (currentAspectRatio > targetAspectRatio)

  3250.                 targetWidth = static_cast<int> (targetWidth * targetAspectRatio / currentAspectRatio);

  3251.             else

  3252.                 targetHeight = static_cast<int> (targetHeight * currentAspectRatio / targetAspectRatio);

  3253.         }

  3254.         else

  3255.         {

  3256.             auto currentAspectRatio = b.getHeight() / (float) b.getWidth();

  3257. 

  3258.             if (currentAspectRatio > targetAspectRatio)

  3259.                 targetHeight = static_cast<int> (targetHeight * targetAspectRatio / currentAspectRatio);

  3260.             else

  3261.                 targetWidth = static_cast<int> (targetWidth * currentAspectRatio / targetAspectRatio);

  3262.         }

  3263. 

  3264.         viewerComponent.setBounds (Rectangle<int> (0, 0, targetWidth, targetHeight).withCentre (b.getCentre()));

  3265.     }

  3266. 

  3267.     bool isOrientationLandscape() const

  3268.     {

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

  3270.         return o == Desktop::rotatedClockwise || o == Desktop::rotatedAntiClockwise;

  3271.     }

  3272. 

  3273.     void componentPeerChanged() override {}

  3274.     void componentVisibilityChanged() override {}

  3275. 

  3276.     JUCE_DECLARE_NON_COPYABLE (ViewerComponent)

  3277. };

  3278. 

  3279. String CameraDevice::getFileExtension()

  3280. {

  3281.     return ".mp4";

  3282. }

  3283. 

  3284. //==============================================================================

  3285. CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::StillPictureTaker::CameraCaptureSessionCaptureCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::StillPictureTaker::CameraCaptureSessionCaptureCallback;

  3286. CameraDevice::Pimpl::ScopedCameraDevice::CameraDeviceStateCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CameraDeviceStateCallback;

  3287. CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::CameraCaptureSessionStateCallback_Class CameraDevice::Pimpl::ScopedCameraDevice::CaptureSession::CameraCaptureSessionStateCallback;

  3288. CameraDevice::Pimpl::DeviceOrientationChangeListener::OrientationEventListener_Class CameraDevice::Pimpl::DeviceOrientationChangeListener::OrientationEventListener;