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.
13753 Commits
11 Branches
2.1GB
Tree: 77458fb4f9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '77458fb4f9'
${ noResults }
JUCE/modules/juce_video/native/juce_Video_android.h

1801 lines
82KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

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

  6. 

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

  8.    licensing.

  9. 

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

  11.    Agreement and JUCE Privacy Policy.

  12. 

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

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

  15. 

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

  17.    www.gnu.org/licenses).

  18. 

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

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

  21.    DISCLAIMED.

  22. 

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

  24. */

  25. 

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

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

  28. //

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

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

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

  32. //

  33. // files with min sdk version 21

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

  35. static const uint8 MediaSessionByteCode[] =

  36. { 31,139,8,8,247,108,161,94,0,3,77,101,100,105,97,83,101,115,115,105,111,110,66,121,116,101,67,111,100,101,46,100,101,120,0,149,

  37. 152,127,108,28,71,21,199,223,236,253,180,207,190,95,254,221,186,169,211,56,137,19,234,220,145,26,226,228,28,99,199,216,196,233,

  38. 249,71,125,182,107,76,168,187,246,109,236,77,238,118,143,221,189,171,45,132,168,170,32,21,209,63,144,74,165,170,82,81,144,64,

  39. 128,20,36,74,37,132,80,69,35,126,75,32,160,82,36,130,64,80,16,8,138,42,126,41,17,21,164,130,239,204,206,158,239,46,14,42,151,

  40. 124,246,189,121,239,205,236,155,55,51,231,219,205,107,219,205,233,135,222,67,219,115,149,223,125,253,83,63,120,252,139,71,187,

  41. 47,68,78,252,118,237,250,194,183,191,251,151,175,254,243,214,229,4,81,137,136,182,151,135,146,36,63,215,226,68,27,228,218,187,

  42. 192,109,230,202,21,133,40,0,89,240,17,13,64,126,6,18,255,233,186,159,104,190,133,104,8,206,199,194,68,42,200,131,2,176,192,199,

  43. 193,83,224,19,224,69,112,13,252,18,220,2,61,77,68,195,224,34,184,2,126,10,254,3,14,53,19,157,4,179,32,15,158,6,47,129,159,131,

  44. 183,65,111,132,40,13,198,65,14,60,7,94,6,63,1,111,128,55,193,223,192,45,240,47,64,200,207,15,154,64,20,180,131,110,112,31,232,

  45. 3,253,224,24,56,13,52,80,4,151,193,243,224,179,224,203,224,43,224,101,240,125,240,71,16,106,37,122,16,204,128,101,160,131,143,

  46. 130,231,193,85,240,45,240,27,240,6,120,27,132,162,68,157,224,40,56,13,166,192,44,80,193,14,248,36,120,22,188,8,94,2,175,130,

  47. 215,192,239,193,155,224,239,224,45,144,136,33,111,112,4,156,2,83,96,6,228,192,135,193,54,248,88,204,93,171,16,64,153,9,37,37,148,

  48. 141,100,41,8,233,16,134,34,132,17,182,0,241,197,111,3,237,160,3,116,202,181,239,6,61,224,30,208,11,246,131,7,65,16,40,114,191,

  49. 112,221,87,163,183,73,125,191,28,139,127,30,144,250,53,36,116,64,234,63,132,222,47,245,159,213,232,55,106,244,215,161,31,148,

  50. 250,159,160,31,150,250,77,232,135,164,126,187,70,247,135,119,245,150,26,189,29,250,17,169,247,214,216,7,194,238,94,230,122,186,

  51. 198,62,12,253,168,212,199,160,191,75,234,103,161,15,202,250,204,215,232,43,97,94,207,8,249,101,77,135,64,92,202,4,49,58,38,

  52. 235,204,219,12,255,142,139,250,197,104,69,200,8,61,46,107,248,16,241,117,139,139,218,134,96,81,196,218,185,50,130,235,154,24,

  53. 223,47,218,49,68,156,20,50,72,167,132,12,83,70,250,71,132,108,165,73,33,91,104,90,200,40,205,8,153,164,89,33,125,244,136,200,

  54. 211,29,143,203,81,41,223,39,100,19,141,9,25,160,113,105,63,35,164,143,62,32,100,7,157,149,237,115,82,62,44,100,130,178,178,61,

  55. 39,251,205,203,246,130,148,57,105,95,148,237,37,81,159,102,145,71,2,246,9,33,219,105,74,200,54,90,21,251,170,147,206,203,250,

  56. 50,114,247,54,255,236,3,95,66,227,72,220,109,199,165,191,73,250,239,151,242,131,210,159,144,254,128,180,247,73,249,5,233,231,

  57. 190,30,232,126,228,197,245,203,49,119,95,151,226,1,180,87,147,12,117,228,21,227,107,253,140,244,229,250,24,149,198,154,72,121,

  58. 247,174,239,217,58,95,115,157,239,133,58,95,68,248,20,121,162,62,23,115,115,136,138,61,193,196,190,184,90,27,159,110,33,133,69,

  59. 171,249,125,173,154,95,80,228,167,160,39,19,30,162,111,214,141,229,142,255,106,204,61,187,201,120,172,58,254,247,170,227,43,

  60. 24,191,77,140,239,249,126,84,231,107,23,190,0,60,188,126,175,213,250,22,59,196,60,188,123,255,162,230,222,65,25,255,107,47,62,

  61. 141,248,165,78,242,141,239,198,255,161,38,222,179,253,185,46,127,247,91,230,175,123,212,231,86,93,142,93,34,199,160,220,215,

  62. 255,142,185,123,33,73,165,62,110,249,208,1,31,173,246,251,69,255,128,28,53,16,119,191,3,141,120,8,189,90,232,30,150,38,163,239,

  63. 48,246,82,51,13,99,167,229,208,179,148,238,151,115,119,215,48,26,119,191,227,134,253,109,180,152,246,161,47,207,174,5,210,39,

  64. 228,58,146,76,38,141,49,70,241,227,209,61,35,12,100,155,166,129,127,80,245,195,104,119,15,243,191,167,94,91,169,147,65,41,195,

  65. 82,54,203,202,180,137,239,118,69,142,227,237,113,70,110,109,24,185,127,11,24,185,127,11,120,159,8,206,148,23,211,42,251,242,

  66. 81,120,187,93,218,59,165,189,19,209,188,237,151,246,54,98,3,196,70,40,56,162,27,186,51,74,254,209,204,145,101,138,76,204,205,

  67. 46,78,206,46,174,45,45,76,19,59,71,44,75,157,89,213,200,91,166,158,79,169,165,82,106,124,195,209,43,186,179,147,161,253,85,251,

  68. 134,105,56,154,225,164,38,92,185,160,217,102,161,162,89,25,234,217,59,100,219,201,80,247,29,174,105,33,50,244,64,213,147,87,29,

  69. 117,93,181,53,111,224,185,117,91,179,196,192,247,85,99,138,90,94,87,83,51,252,58,163,57,42,239,146,161,116,131,219,214,108,

  70. 91,55,13,55,140,15,102,153,133,130,102,245,79,168,133,194,186,186,113,41,67,67,239,176,199,124,65,221,225,61,166,141,11,102,

  71. 134,6,255,87,175,156,219,168,185,201,177,119,18,254,72,89,43,107,211,142,86,204,208,193,187,196,123,73,228,28,213,209,50,148,168,

  72. 134,25,154,147,90,178,244,12,181,85,77,166,157,58,83,54,242,5,196,181,215,26,207,170,220,104,213,150,187,100,153,21,61,175,89,

  73. 169,156,230,56,186,177,105,247,231,118,108,145,200,225,236,134,89,76,89,69,187,144,186,88,222,208,26,171,178,59,195,254,189,

  74. 2,229,204,238,30,229,222,102,217,44,148,139,90,237,26,231,213,66,69,191,148,82,13,195,196,76,249,204,115,250,166,161,58,101,

  75. 11,179,73,102,47,170,21,53,85,80,141,205,84,206,177,144,111,134,98,174,173,236,232,133,84,86,183,29,138,55,24,50,52,214,96,25,

  76. 249,255,214,100,52,67,189,119,153,253,49,62,48,245,236,53,101,233,218,107,158,174,139,45,147,178,124,142,124,203,231,196,37,75,

  77. 126,92,178,176,101,209,204,114,91,150,219,178,171,220,182,138,38,20,182,74,10,68,88,149,39,146,90,61,109,209,92,178,53,58,36,

  78. 15,214,169,20,38,229,46,104,202,22,25,164,42,34,133,181,98,217,214,55,40,136,243,104,169,54,117,108,106,206,120,169,84,208,55,

  79. 68,173,229,73,165,36,204,13,7,155,252,91,38,138,219,196,175,238,189,20,61,79,126,29,103,130,18,162,140,103,202,142,99,26,238,

  80. 137,166,251,139,245,5,27,47,231,117,147,31,160,137,45,44,158,150,167,125,13,1,222,65,246,252,7,26,252,117,251,223,11,106,188,

  81. 139,92,130,247,107,54,12,59,8,8,137,128,233,188,76,81,250,231,213,50,242,143,215,153,48,60,221,219,104,153,178,204,226,140,28,

  82. 33,89,235,204,105,218,165,69,179,126,136,156,99,150,100,70,158,165,102,237,189,148,195,69,57,81,74,154,198,29,85,9,99,13,132,

  83. 74,173,166,49,165,218,206,148,105,61,161,90,121,30,60,179,91,228,201,10,175,113,130,219,234,171,22,242,38,23,148,83,74,220,57,

  84. 145,78,215,116,71,49,163,166,33,246,124,77,46,11,218,19,186,33,52,57,225,36,215,26,106,220,2,219,37,189,180,104,206,242,173,19,

  85. 247,90,243,150,86,209,205,178,205,83,112,45,213,19,197,179,19,213,242,149,76,155,2,31,225,118,234,178,180,77,156,77,156,173,

  86. 250,47,126,106,182,181,194,5,89,21,232,206,164,161,174,23,112,223,152,189,101,150,11,249,51,154,103,104,182,29,213,114,236,71,

  87. 117,103,139,2,54,159,26,249,157,45,221,166,176,99,186,223,22,212,83,54,238,118,27,95,217,210,41,80,81,11,200,101,144,189,55,

  88. 20,29,25,164,33,54,28,138,174,210,41,54,201,197,24,123,140,139,41,70,126,182,210,177,15,15,135,15,19,55,164,101,116,142,63,47,

  89. 174,176,147,184,158,16,142,211,226,58,161,140,30,231,242,60,119,79,179,71,185,190,198,245,117,126,209,216,9,92,231,68,228,128,

  90. 146,198,72,217,193,65,58,169,172,174,135,162,223,225,99,159,15,69,7,89,60,209,75,74,146,173,247,6,186,168,235,222,46,214,21,239,

  91. 194,239,168,64,128,41,225,39,159,244,191,210,204,158,82,168,150,86,118,163,153,177,155,224,211,17,198,174,130,107,248,37,16,

  92. 140,40,74,18,241,191,138,52,198,115,186,217,91,136,123,166,133,177,43,224,21,112,3,220,4,79,183,50,246,121,240,13,240,99,240,

  93. 122,43,41,138,226,83,152,114,0,163,221,110,229,189,15,178,43,81,70,215,163,20,111,248,93,196,165,247,110,130,255,38,241,222,79,

  94. 248,104,247,29,133,159,118,223,83,112,233,189,171,240,158,83,249,251,10,95,220,29,75,252,198,234,115,159,237,70,160,7,251,92,59,

  95. 127,158,96,113,247,89,150,63,179,42,125,238,125,249,251,13,159,140,231,207,5,254,190,221,231,5,254,32,193,199,23,207,33,114,

  96. 124,254,46,229,191,60,5,16,96,132,17,0,0,0,0 };

  97. 

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

  99.  METHOD (getPlaybackInfo,      "getPlaybackInfo",      "()Landroid/media/session/MediaController$PlaybackInfo;") \

  100.  METHOD (getPlaybackState,     "getPlaybackState",     "()Landroid/media/session/PlaybackState;") \

  101.  METHOD (getTransportControls, "getTransportControls", "()Landroid/media/session/MediaController$TransportControls;") \

  102.  METHOD (registerCallback,     "registerCallback",     "(Landroid/media/session/MediaController$Callback;)V") \

  103.  METHOD (setVolumeTo,          "setVolumeTo",          "(II)V") \

  104.  METHOD (unregisterCallback,   "unregisterCallback",   "(Landroid/media/session/MediaController$Callback;)V")

  105. 

  106. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidMediaController, "android/media/session/MediaController", 21)

  107. #undef JNI_CLASS_MEMBERS

  108. 

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

  110.  METHOD (getAudioAttributes, "getAudioAttributes", "()Landroid/media/AudioAttributes;") \

  111.  METHOD (getCurrentVolume,   "getCurrentVolume",   "()I") \

  112.  METHOD (getMaxVolume,       "getMaxVolume",       "()I")

  113. 

  114. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidMediaControllerPlaybackInfo, "android/media/session/MediaController$PlaybackInfo", 21)

  115. #undef JNI_CLASS_MEMBERS

  116. 

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

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

  119.  METHOD (play,            "play",            "()V") \

  120.  METHOD (playFromMediaId, "playFromMediaId", "(Ljava/lang/String;Landroid/os/Bundle;)V") \

  121.  METHOD (seekTo,          "seekTo",          "(J)V") \

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

  123. 

  124. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidMediaControllerTransportControls, "android/media/session/MediaController$TransportControls", 21)

  125. #undef JNI_CLASS_MEMBERS

  126. 

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

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

  129.  METHOD (getCurrentPosition,           "getCurrentPosition",           "()I") \

  130.  METHOD (getDuration,                  "getDuration",                  "()I") \

  131.  METHOD (getPlaybackParams,            "getPlaybackParams",            "()Landroid/media/PlaybackParams;") \

  132.  METHOD (getVideoHeight,               "getVideoHeight",               "()I") \

  133.  METHOD (getVideoWidth,                "getVideoWidth",                "()I") \

  134.  METHOD (isPlaying,                    "isPlaying",                    "()Z") \

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

  136.  METHOD (prepareAsync,                 "prepareAsync",                 "()V") \

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

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

  139.  METHOD (setAudioAttributes,           "setAudioAttributes",           "(Landroid/media/AudioAttributes;)V") \

  140.  METHOD (setDataSource,                "setDataSource",                "(Landroid/content/Context;Landroid/net/Uri;)V") \

  141.  METHOD (setDisplay,                   "setDisplay",                   "(Landroid/view/SurfaceHolder;)V") \

  142.  METHOD (setOnBufferingUpdateListener, "setOnBufferingUpdateListener", "(Landroid/media/MediaPlayer$OnBufferingUpdateListener;)V") \

  143.  METHOD (setOnCompletionListener,      "setOnCompletionListener",      "(Landroid/media/MediaPlayer$OnCompletionListener;)V") \

  144.  METHOD (setOnErrorListener,           "setOnErrorListener",           "(Landroid/media/MediaPlayer$OnErrorListener;)V") \

  145.  METHOD (setOnInfoListener,            "setOnInfoListener",            "(Landroid/media/MediaPlayer$OnInfoListener;)V") \

  146.  METHOD (setOnPreparedListener,        "setOnPreparedListener",        "(Landroid/media/MediaPlayer$OnPreparedListener;)V") \

  147.  METHOD (setOnSeekCompleteListener,    "setOnSeekCompleteListener",    "(Landroid/media/MediaPlayer$OnSeekCompleteListener;)V") \

  148.  METHOD (setPlaybackParams,            "setPlaybackParams",            "(Landroid/media/PlaybackParams;)V") \

  149.  METHOD (setVolume,                    "setVolume",                    "(FF)V") \

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

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

  152. 

  153. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidMediaPlayer, "android/media/MediaPlayer", 21)

  154. #undef JNI_CLASS_MEMBERS

  155. 

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

  157.  METHOD (constructor,            "<init>",                 "(Landroid/content/Context;Ljava/lang/String;)V") \

  158.  METHOD (getController,          "getController",          "()Landroid/media/session/MediaController;") \

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

  160.  METHOD (setActive,              "setActive",              "(Z)V") \

  161.  METHOD (setCallback,            "setCallback",            "(Landroid/media/session/MediaSession$Callback;)V") \

  162.  METHOD (setFlags,               "setFlags",               "(I)V") \

  163.  METHOD (setMediaButtonReceiver, "setMediaButtonReceiver", "(Landroid/app/PendingIntent;)V") \

  164.  METHOD (setMetadata,            "setMetadata",            "(Landroid/media/MediaMetadata;)V") \

  165.  METHOD (setPlaybackState,       "setPlaybackState",       "(Landroid/media/session/PlaybackState;)V") \

  166.  METHOD (setPlaybackToLocal,     "setPlaybackToLocal",     "(Landroid/media/AudioAttributes;)V")

  167. 

  168. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidMediaSession, "android/media/session/MediaSession", 21)

  169. #undef JNI_CLASS_MEMBERS

  170. 

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

  172.  METHOD (build,       "build",   "()Landroid/media/MediaMetadata;") \

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

  174.  METHOD (putLong,     "putLong", "(Ljava/lang/String;J)Landroid/media/MediaMetadata$Builder;")

  175. 

  176. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidMediaMetadataBuilder, "android/media/MediaMetadata$Builder", 21)

  177. #undef JNI_CLASS_MEMBERS

  178. 

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

  180.  METHOD (getSpeed, "getSpeed", "()F") \

  181.  METHOD (setSpeed, "setSpeed", "(F)Landroid/media/PlaybackParams;")

  182. 

  183. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidPlaybackParams, "android/media/PlaybackParams", 21)

  184. #undef JNI_CLASS_MEMBERS

  185. 

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

  187.  METHOD (getActions,       "getActions",       "()J") \

  188.  METHOD (getErrorMessage,  "getErrorMessage",  "()Ljava/lang/CharSequence;") \

  189.  METHOD (getPlaybackSpeed, "getPlaybackSpeed", "()F") \

  190.  METHOD (getPosition,      "getPosition",      "()J") \

  191.  METHOD (getState,         "getState",         "()I")

  192. 

  193. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidPlaybackState, "android/media/session/PlaybackState", 21)

  194. #undef JNI_CLASS_MEMBERS

  195. 

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

  197.  METHOD (build,           "build",           "()Landroid/media/session/PlaybackState;") \

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

  199.  METHOD (setActions,      "setActions",      "(J)Landroid/media/session/PlaybackState$Builder;") \

  200.  METHOD (setErrorMessage, "setErrorMessage", "(Ljava/lang/CharSequence;)Landroid/media/session/PlaybackState$Builder;") \

  201.  METHOD (setState,        "setState",        "(IJF)Landroid/media/session/PlaybackState$Builder;")

  202. 

  203. DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidPlaybackStateBuilder, "android/media/session/PlaybackState$Builder", 21)

  204. #undef JNI_CLASS_MEMBERS

  205. 

  206. //==============================================================================

  207. class MediaPlayerListener  : public AndroidInterfaceImplementer

  208. {

  209. public:

  210.     struct Owner

  211.     {

  212.         virtual ~Owner() {}

  213. 

  214.         virtual void onPrepared (LocalRef<jobject>& mediaPlayer) = 0;

  215.         virtual void onBufferingUpdate (LocalRef<jobject>& mediaPlayer, int progress) = 0;

  216.         virtual void onSeekComplete (LocalRef<jobject>& mediaPlayer) = 0;

  217.         virtual void onCompletion (LocalRef<jobject>& mediaPlayer) = 0;

  218.         virtual bool onInfo (LocalRef<jobject>& mediaPlayer, int what, int extra) = 0;

  219.         virtual bool onError (LocalRef<jobject>& mediaPlayer, int what, int extra) = 0;

  220.     };

  221. 

  222.     MediaPlayerListener (Owner& ownerToUse) : owner (ownerToUse) {}

  223. 

  224. private:

  225.     Owner& owner;

  226. 

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

  228.     {

  229.         auto* env = getEnv();

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

  231. 

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

  233. 

  234.         if (methodName == "onPrepared" && numArgs == 1)

  235.         {

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

  237. 

  238.             owner.onPrepared (mediaPlayer);

  239.             return nullptr;

  240.         }

  241. 

  242.         if (methodName == "onCompletion" && numArgs == 1)

  243.         {

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

  245. 

  246.             owner.onCompletion (mediaPlayer);

  247.             return nullptr;

  248.         }

  249. 

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

  251.         {

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

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

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

  255. 

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

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

  258. 

  259.             auto res = owner.onInfo (mediaPlayer, whatInt, extraInt);

  260.             return env->CallStaticObjectMethod (JavaBoolean, JavaBoolean.valueOf, (jboolean) res);

  261.         }

  262. 

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

  264.         {

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

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

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

  268. 

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

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

  271. 

  272.             auto res = owner.onError (mediaPlayer, whatInt, extraInt);

  273.             return env->CallStaticObjectMethod (JavaBoolean, JavaBoolean.valueOf, (jboolean) res);

  274.         }

  275. 

  276.         if (methodName == "onSeekComplete" && numArgs == 1)

  277.         {

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

  279. 

  280.             owner.onSeekComplete (mediaPlayer);

  281.             return nullptr;

  282.         }

  283. 

  284.         if (methodName == "onBufferingUpdate" && numArgs == 2)

  285.         {

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

  287. 

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

  289.             auto progressInt = (int) env->CallIntMethod (progress, JavaInteger.intValue);

  290. 

  291.             owner.onBufferingUpdate (mediaPlayer, progressInt);

  292. 

  293.             return nullptr;

  294.         }

  295. 

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

  297.     }

  298. };

  299. 

  300. //==============================================================================

  301. class AudioManagerOnAudioFocusChangeListener  : public AndroidInterfaceImplementer

  302. {

  303. public:

  304.     struct Owner

  305.     {

  306.         virtual ~Owner() {}

  307. 

  308.         virtual void onAudioFocusChange (int changeType) = 0;

  309.     };

  310. 

  311.     AudioManagerOnAudioFocusChangeListener (Owner& ownerToUse) : owner (ownerToUse) {}

  312. 

  313. private:

  314.     Owner& owner;

  315. 

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

  317.     {

  318.         auto* env = getEnv();

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

  320. 

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

  322. 

  323.         if (methodName == "onAudioFocusChange" && numArgs == 1)

  324.         {

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

  326. 

  327.             auto changeTypeInt = (int) env->CallIntMethod (changeType, JavaInteger.intValue);

  328. 

  329.             owner.onAudioFocusChange (changeTypeInt);

  330.             return nullptr;

  331.         }

  332. 

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

  334.     }

  335. };

  336. 

  337. //==============================================================================

  338. struct VideoComponent::Pimpl

  339.     : public AndroidViewComponent, private ActivityLifecycleCallbacks, private SurfaceHolderCallback

  340. {

  341.     Pimpl (VideoComponent& ownerToUse, bool)

  342.         : owner (ownerToUse),

  343.           mediaSession (*this)

  344.        #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  345.         , systemVolumeListener (*this)

  346.        #endif

  347.     {

  348.         // Video requires SDK version 21 or higher

  349.         jassert (getAndroidSDKVersion() >= 21);

  350. 

  351.         setVisible (true);

  352. 

  353.         auto* env = getEnv();

  354. 

  355.         LocalRef<jobject> appContext (getAppContext());

  356. 

  357.         if (appContext != nullptr)

  358.         {

  359.             ActivityLifecycleCallbacks* callbacks = dynamic_cast<ActivityLifecycleCallbacks*> (this);

  360. 

  361.             activityLifeListener = GlobalRef (CreateJavaInterface (callbacks, "android/app/Application$ActivityLifecycleCallbacks"));

  362.             env->CallVoidMethod (appContext.get(), AndroidApplication.registerActivityLifecycleCallbacks, activityLifeListener.get());

  363.         }

  364. 

  365.         {

  366.             LocalRef<jobject> surfaceView (env->NewObject (AndroidSurfaceView, AndroidSurfaceView.constructor, getAppContext().get()));

  367.             LocalRef<jobject> holder (env->CallObjectMethod (surfaceView.get(), AndroidSurfaceView.getHolder));

  368. 

  369.             SurfaceHolderCallback* callbacks = dynamic_cast<SurfaceHolderCallback*> (this);

  370.             surfaceHolderCallback = GlobalRef (CreateJavaInterface (callbacks, "android/view/SurfaceHolder$Callback"));

  371.             env->CallVoidMethod (holder, AndroidSurfaceHolder.addCallback, surfaceHolderCallback.get());

  372. 

  373.             setView (surfaceView.get());

  374.         }

  375.     }

  376. 

  377.     ~Pimpl() override

  378.     {

  379.         auto* env = getEnv();

  380. 

  381.         if (surfaceHolderCallback != nullptr)

  382.         {

  383.             jobject view = reinterpret_cast<jobject> (getView());

  384. 

  385.             if (view != nullptr)

  386.             {

  387.                 LocalRef <jobject> holder (env->CallObjectMethod (view, AndroidSurfaceView.getHolder));

  388. 

  389.                 env->CallVoidMethod (holder, AndroidSurfaceHolder.removeCallback, surfaceHolderCallback.get());

  390.                 SurfaceHolderCallback::clear();

  391.                 surfaceHolderCallback.clear();

  392.             }

  393.         }

  394. 

  395.         if (activityLifeListener != nullptr)

  396.         {

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

  398.             ActivityLifecycleCallbacks::clear();

  399.             activityLifeListener.clear();

  400.         }

  401.     }

  402. 

  403.     void loadAsync (const URL& url, std::function<void (const URL&, Result)> callback)

  404.     {

  405.         close();

  406.         wasOpen = false;

  407. 

  408.         if (url.isEmpty())

  409.         {

  410.             jassertfalse;

  411.             return;

  412.         }

  413. 

  414.         if (! url.isLocalFile())

  415.         {

  416.             if (! isPermissionDeclaredInManifest ("android.permission.INTERNET"))

  417.             {

  418.                 // In order to access videos from the Internet, the Internet permission has to be specified in

  419.                 // Android Manifest.

  420.                 jassertfalse;

  421.                 return;

  422.             }

  423.         }

  424. 

  425.         currentURL = url;

  426. 

  427.         jassert (callback != nullptr);

  428. 

  429.         loadFinishedCallback = std::move (callback);

  430. 

  431.         static constexpr jint visible = 0;

  432.         getEnv()->CallVoidMethod ((jobject) getView(), AndroidView.setVisibility, visible);

  433. 

  434.         mediaSession.load (url);

  435.     }

  436. 

  437.     void close()

  438.     {

  439.         if (! isOpen())

  440.             return;

  441. 

  442.         mediaSession.closeVideo();

  443. 

  444.         static constexpr jint invisible = 4;

  445.         getEnv()->CallVoidMethod ((jobject) getView(), AndroidView.setVisibility, invisible);

  446.     }

  447. 

  448.     bool isOpen() const noexcept          { return mediaSession.isVideoOpen(); }

  449.     bool isPlaying() const noexcept       { return mediaSession.isPlaying(); }

  450. 

  451.     void play()                           { mediaSession.play(); }

  452.     void stop()                           { mediaSession.stop(); }

  453. 

  454.     void setPosition (double newPosition) { mediaSession.setPosition (newPosition); }

  455.     double getPosition() const            { return mediaSession.getPosition(); }

  456. 

  457.     void setSpeed (double newSpeed)       { mediaSession.setSpeed (newSpeed); }

  458.     double getSpeed() const               { return mediaSession.getSpeed(); }

  459. 

  460.     Rectangle<int> getNativeSize() const  { return mediaSession.getNativeSize(); }

  461. 

  462.     double getDuration() const            { return mediaSession.getDuration(); }

  463. 

  464.     void setVolume (float newVolume)      { mediaSession.setVolume (newVolume); }

  465.     float getVolume() const               { return mediaSession.getVolume(); }

  466. 

  467.     File currentFile;

  468.     URL currentURL;

  469. 

  470. private:

  471.     //==============================================================================

  472.     class MediaSession  : private AudioManagerOnAudioFocusChangeListener::Owner

  473.     {

  474.     public:

  475.         MediaSession (Pimpl& ownerToUse)

  476.             : owner (ownerToUse),

  477.               sdkVersion (getAndroidSDKVersion()),

  478.               audioAttributes (getAudioAttributes()),

  479.               nativeMediaSession (LocalRef<jobject> (getEnv()->NewObject (AndroidMediaSession,

  480.                                                                           AndroidMediaSession.constructor,

  481.                                                                           getAppContext().get(),

  482.                                                                           javaString ("JuceVideoMediaSession").get()))),

  483.               mediaSessionCallback (createCallbackObject()),

  484.               playbackStateBuilder (LocalRef<jobject> (getEnv()->NewObject (AndroidPlaybackStateBuilder,

  485.                                                                             AndroidPlaybackStateBuilder.constructor))),

  486.               controller (*this, LocalRef<jobject> (getEnv()->CallObjectMethod (nativeMediaSession,

  487.                                                                                 AndroidMediaSession.getController))),

  488.               player (*this),

  489.               audioManager (LocalRef<jobject> (getEnv()->CallObjectMethod (getAppContext().get(), AndroidContext.getSystemService,

  490.                                                                            javaString ("audio").get()))),

  491.               audioFocusChangeListener (*this),

  492.               nativeAudioFocusChangeListener (GlobalRef (CreateJavaInterface (&audioFocusChangeListener,

  493.                                                                               "android/media/AudioManager$OnAudioFocusChangeListener"))),

  494.               audioFocusRequest (createAudioFocusRequestIfNecessary (sdkVersion, audioAttributes,

  495.                                                                      nativeAudioFocusChangeListener))

  496.         {

  497.             auto* env = getEnv();

  498. 

  499.             env->CallVoidMethod (nativeMediaSession, AndroidMediaSession.setPlaybackToLocal, audioAttributes.get());

  500.             env->CallVoidMethod (nativeMediaSession, AndroidMediaSession.setMediaButtonReceiver, nullptr);

  501.             env->CallVoidMethod (nativeMediaSession, AndroidMediaSession.setCallback, mediaSessionCallback.get());

  502.         }

  503. 

  504.         ~MediaSession() override

  505.         {

  506.             auto* env = getEnv();

  507. 

  508.             env->CallVoidMethod (nativeMediaSession, AndroidMediaSession.setCallback, nullptr);

  509. 

  510.             controller.stop();

  511.             env->CallVoidMethod (nativeMediaSession, AndroidMediaSession.release);

  512.         }

  513. 

  514.         bool isVideoOpen() const { return player.isVideoOpen(); }

  515.         bool isPlaying() const   { return player.isPlaying(); }

  516. 

  517.         void load (const URL& url) { controller.load (url); }

  518. 

  519.         void closeVideo()

  520.         {

  521.             resetState();

  522.             controller.closeVideo();

  523.         }

  524. 

  525.         void setDisplay (const LocalRef<jobject>& surfaceHolder) { player.setDisplay (surfaceHolder); }

  526. 

  527.         void play() { controller.play(); }

  528.         void stop() { controller.stop(); }

  529. 

  530.         void setPosition (double newPosition) { controller.setPosition (newPosition); }

  531.         double getPosition() const            { return controller.getPosition(); }

  532. 

  533.         void setSpeed (double newSpeed)

  534.         {

  535.             playSpeedMult = newSpeed;

  536. 

  537.             // Calling non 0.0 speed on a paused player would start it...

  538.             if (player.isPlaying())

  539.             {

  540.                 player.setPlaySpeed (playSpeedMult);

  541.                 updatePlaybackState();

  542.             }

  543.         }

  544. 

  545.         double getSpeed() const              { return controller.getPlaySpeed(); }

  546.         Rectangle<int> getNativeSize() const { return player.getVideoNativeSize(); }

  547.         double getDuration() const           { return (double) player.getVideoDuration() / 1000.0; }

  548. 

  549.         void setVolume (float newVolume)

  550.         {

  551.            #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  552.             controller.setVolume (newVolume);

  553.            #else

  554.             player.setAudioVolume (newVolume);

  555.            #endif

  556.         }

  557. 

  558.         float getVolume() const

  559.         {

  560.            #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  561.             return controller.getVolume();

  562.            #else

  563.             return player.getAudioVolume();

  564.            #endif

  565.         }

  566. 

  567.         void storeState()

  568.         {

  569.             storedPlaybackState.clear();

  570.             storedPlaybackState = GlobalRef (getCurrentPlaybackState());

  571.         }

  572. 

  573.         void restoreState()

  574.         {

  575.             if (storedPlaybackState.get() == nullptr)

  576.                 return;

  577. 

  578.             auto* env = getEnv();

  579. 

  580.             auto pos = env->CallLongMethod (storedPlaybackState, AndroidPlaybackState.getPosition);

  581.             setPosition ((double) pos / 1000.0);

  582. 

  583.             setSpeed (playSpeedMult);

  584. 

  585.             auto state = env->CallIntMethod (storedPlaybackState, AndroidPlaybackState.getState);

  586. 

  587.             if (state != PlaybackState::STATE_NONE && state != PlaybackState::STATE_STOPPED

  588.                 && state != PlaybackState::STATE_PAUSED && state != PlaybackState::STATE_ERROR)

  589.             {

  590.                 play();

  591.             }

  592.         }

  593. 

  594.     private:

  595.         struct PlaybackState

  596.         {

  597.             enum

  598.             {

  599.                 STATE_NONE = 0,

  600.                 STATE_STOPPED = 1,

  601.                 STATE_PAUSED = 2,

  602.                 STATE_PLAYING = 3,

  603.                 STATE_FAST_FORWARDING = 4,

  604.                 STATE_REWINDING = 5,

  605.                 STATE_BUFFERING = 6,

  606.                 STATE_ERROR = 7,

  607.                 STATE_CONNECTING = 8,

  608.                 STATE_SKIPPING_TO_PREVIOUS = 9,

  609.                 STATE_SKIPPING_TO_NEXT = 10,

  610.                 STATE_SKIPPING_TO_QUEUE_ITEM = 11,

  611.             };

  612. 

  613.             enum

  614.             {

  615.                 ACTION_PAUSE              = 0x2,

  616.                 ACTION_PLAY               = 0x4,

  617.                 ACTION_PLAY_FROM_MEDIA_ID = 0x8000,

  618.                 ACTION_PLAY_PAUSE         = 0x200,

  619.                 ACTION_SEEK_TO            = 0x100,

  620.                 ACTION_STOP               = 0x1,

  621.             };

  622.         };

  623. 

  624.         //==============================================================================

  625.         class Controller

  626.         {

  627.         public:

  628.             Controller (MediaSession& ownerToUse, const LocalRef<jobject>& nativeControllerToUse)

  629.                 : owner (ownerToUse),

  630.                   nativeController (GlobalRef (nativeControllerToUse)),

  631.                   controllerTransportControls (LocalRef<jobject> (getEnv()->CallObjectMethod (nativeControllerToUse,

  632.                                                                                               AndroidMediaController.getTransportControls))),

  633.                   controllerCallback (createControllerCallbacks())

  634.             {

  635.                 auto* env = getEnv();

  636. 

  637.                 env->CallVoidMethod (nativeController, AndroidMediaController.registerCallback, controllerCallback.get());

  638.             }

  639. 

  640.             ~Controller()

  641.             {

  642.                 auto* env = getEnv();

  643.                 env->CallVoidMethod (nativeController, AndroidMediaController.unregisterCallback, controllerCallback.get());

  644.             }

  645. 

  646.             void load (const URL& url)

  647.             {

  648.                 // NB: would use playFromUri, but it was only introduced in API 23...

  649.                 getEnv()->CallVoidMethod (controllerTransportControls, AndroidMediaControllerTransportControls.playFromMediaId,

  650.                                           javaString (url.toString (true)).get(), nullptr);

  651.             }

  652. 

  653.             void closeVideo()

  654.             {

  655.                 getEnv()->CallVoidMethod (controllerTransportControls, AndroidMediaControllerTransportControls.stop);

  656.             }

  657. 

  658.             void play()

  659.             {

  660.                 getEnv()->CallVoidMethod (controllerTransportControls, AndroidMediaControllerTransportControls.play);

  661.             }

  662. 

  663.             void stop()

  664.             {

  665.                 // NB: calling pause, rather than stop, because after calling stop, we would have to call load() again.

  666.                 getEnv()->CallVoidMethod (controllerTransportControls, AndroidMediaControllerTransportControls.pause);

  667.             }

  668. 

  669.             void setPosition (double newPosition)

  670.             {

  671.                 auto seekPos = static_cast<jlong> (newPosition * 1000);

  672. 

  673.                 getEnv()->CallVoidMethod (controllerTransportControls, AndroidMediaControllerTransportControls.seekTo, seekPos);

  674.             }

  675. 

  676.             double getPosition() const

  677.             {

  678.                 auto* env = getEnv();

  679. 

  680.                 auto playbackState = LocalRef<jobject> (env->CallObjectMethod (nativeController, AndroidMediaController.getPlaybackState));

  681. 

  682.                 if (playbackState != nullptr)

  683.                     return (double) env->CallLongMethod (playbackState, AndroidPlaybackState.getPosition) / 1000.0;

  684. 

  685.                 return 0.0;

  686.             }

  687. 

  688.             double getPlaySpeed() const

  689.             {

  690.                 auto* env = getEnv();

  691. 

  692.                 auto playbackState = LocalRef<jobject> (env->CallObjectMethod (nativeController, AndroidMediaController.getPlaybackState));

  693. 

  694.                 if (playbackState != nullptr)

  695.                     return (double) env->CallFloatMethod (playbackState, AndroidPlaybackState.getPlaybackSpeed);

  696. 

  697.                 return 1.0;

  698.             }

  699. 

  700.             void setVolume (float newVolume)

  701.             {

  702.                 auto* env = getEnv();

  703. 

  704.                 auto playbackInfo = LocalRef<jobject> (env->CallObjectMethod (nativeController, AndroidMediaController.getPlaybackInfo));

  705. 

  706.                 auto maxVolume = env->CallIntMethod (playbackInfo, AndroidMediaControllerPlaybackInfo.getMaxVolume);

  707. 

  708.                 auto targetVolume = jmin (jint ((float) maxVolume * newVolume), maxVolume);

  709. 

  710.                 static constexpr jint flagShowUI = 1;

  711.                 env->CallVoidMethod (nativeController, AndroidMediaController.setVolumeTo, targetVolume, flagShowUI);

  712.             }

  713. 

  714.             float getVolume() const

  715.             {

  716.                 auto* env = getEnv();

  717. 

  718.                 auto playbackInfo = LocalRef<jobject> (env->CallObjectMethod (nativeController, AndroidMediaController.getPlaybackInfo));

  719. 

  720.                 auto maxVolume = (int) (env->CallIntMethod (playbackInfo, AndroidMediaControllerPlaybackInfo.getMaxVolume));

  721.                 auto curVolume = (int) (env->CallIntMethod (playbackInfo, AndroidMediaControllerPlaybackInfo.getCurrentVolume));

  722. 

  723.                 return static_cast<float> (curVolume) / (float) maxVolume;

  724.             }

  725. 

  726.         private:

  727.             MediaSession& owner;

  728. 

  729.             GlobalRef nativeController;

  730.             GlobalRef controllerTransportControls;

  731.             GlobalRef controllerCallback;

  732.             bool wasPlaying = false;

  733.             bool wasPaused = true;

  734. 

  735.             //==============================================================================

  736.             void stateChanged (jobject playbackState)

  737.             {

  738.                 JUCE_VIDEO_LOG ("MediaSessionController::playbackStateChanged()");

  739. 

  740.                 if (playbackState == nullptr)

  741.                     return;

  742. 

  743.                 auto state = getEnv()->CallIntMethod (playbackState, AndroidPlaybackState.getState);

  744. 

  745.                 static constexpr jint statePaused  = 2;

  746.                 static constexpr jint statePlaying = 3;

  747. 

  748.                 if (wasPlaying == false && state == statePlaying)

  749.                     owner.playbackStarted();

  750.                 else if (wasPaused == false && state == statePaused)

  751.                     owner.playbackStopped();

  752. 

  753.                 wasPlaying = state == statePlaying;

  754.                 wasPaused  = state == statePaused;

  755.             }

  756. 

  757.             //==============================================================================

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

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

  760.                 CALLBACK (generatedCallback<&Controller::audioInfoChanged>,     "mediaControllerAudioInfoChanged",      "(JLandroid/media/session/MediaController$PlaybackInfo;)V") \

  761.                 CALLBACK (generatedCallback<&Controller::metadataChanged>,      "mediaControllerMetadataChanged",       "(JLandroid/media/MediaMetadata;)V") \

  762.                 CALLBACK (generatedCallback<&Controller::playbackStateChanged>, "mediaControllerPlaybackStateChanged",  "(JLandroid/media/session/PlaybackState;)V") \

  763.                 CALLBACK (generatedCallback<&Controller::sessionDestroyed>,     "mediaControllerSessionDestroyed",      "(J)V")

  764. 

  765.             DECLARE_JNI_CLASS_WITH_BYTECODE (AndroidMediaControllerCallback, "com/rmsl/juce/MediaControllerCallback", 21, MediaSessionByteCode)

  766.            #undef JNI_CLASS_MEMBERS

  767. 

  768.             LocalRef<jobject> createControllerCallbacks()

  769.             {

  770.                 return LocalRef<jobject> (getEnv()->NewObject (AndroidMediaControllerCallback,

  771.                                                                AndroidMediaControllerCallback.constructor,

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

  773.             }

  774. 

  775.             //==============================================================================

  776.             // MediaSessionController callbacks

  777.             static void audioInfoChanged (JNIEnv*, [[maybe_unused]] Controller& t, [[maybe_unused]] jobject playbackInfo)

  778.             {

  779.                 JUCE_VIDEO_LOG ("MediaSessionController::audioInfoChanged()");

  780.             }

  781. 

  782.             static void metadataChanged (JNIEnv*, [[maybe_unused]] Controller&, [[maybe_unused]] jobject metadata)

  783.             {

  784.                 JUCE_VIDEO_LOG ("MediaSessionController::metadataChanged()");

  785.             }

  786. 

  787.             static void playbackStateChanged (JNIEnv*, Controller& t, [[maybe_unused]] jobject state)

  788.             {

  789.                 t.stateChanged (state);

  790.             }

  791. 

  792.             static void sessionDestroyed (JNIEnv*, [[maybe_unused]] Controller& t)

  793.             {

  794.                 JUCE_VIDEO_LOG ("MediaSessionController::sessionDestroyed()");

  795.             }

  796.         };

  797. 

  798.         //==============================================================================

  799.         class Player   : private MediaPlayerListener::Owner

  800.         {

  801.         public:

  802.             Player (MediaSession& ownerToUse)

  803.                 : owner (ownerToUse),

  804.                   mediaPlayerListener (*this),

  805.                   nativeMediaPlayerListener (GlobalRef (CreateJavaInterface (&mediaPlayerListener,

  806.                                                                              getNativeMediaPlayerListenerInterfaces())))

  807. 

  808.             {}

  809. 

  810.             void setDisplay (const LocalRef<jobject>& surfaceHolder)

  811.             {

  812.                 if (surfaceHolder == nullptr)

  813.                 {

  814.                     videoSurfaceHolder.clear();

  815. 

  816.                     if (nativeMediaPlayer.get() != nullptr)

  817.                         getEnv()->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setDisplay, nullptr);

  818. 

  819.                     return;

  820.                 }

  821. 

  822.                 videoSurfaceHolder = GlobalRef (surfaceHolder);

  823. 

  824.                 if (nativeMediaPlayer.get() != nullptr)

  825.                     getEnv()->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setDisplay, videoSurfaceHolder.get());

  826.             }

  827. 

  828.             void load (const LocalRef<jstring>& mediaId, [[maybe_unused]] const LocalRef<jobject>& extras)

  829.             {

  830.                 closeVideo();

  831. 

  832.                 auto* env = getEnv();

  833. 

  834.                 nativeMediaPlayer = GlobalRef (LocalRef<jobject> (env->NewObject (AndroidMediaPlayer, AndroidMediaPlayer.constructor)));

  835. 

  836.                 currentState = State::idle;

  837. 

  838.                 auto uri = LocalRef<jobject> (env->CallStaticObjectMethod (AndroidUri, AndroidUri.parse, mediaId.get()));

  839.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setDataSource, getAppContext().get(), uri.get());

  840. 

  841.                 if (jniCheckHasExceptionOccurredAndClear())

  842.                 {

  843.                     owner.errorOccurred ("Could not find video under path provided (" + juceString (mediaId) + ")");

  844.                     return;

  845.                 }

  846. 

  847.                 currentState = State::initialised;

  848. 

  849.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setOnBufferingUpdateListener,   nativeMediaPlayerListener.get());

  850.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setOnCompletionListener, nativeMediaPlayerListener.get());

  851.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setOnErrorListener,      nativeMediaPlayerListener.get());

  852.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setOnInfoListener,       nativeMediaPlayerListener.get());

  853.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setOnPreparedListener,   nativeMediaPlayerListener.get());

  854.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setOnSeekCompleteListener,   nativeMediaPlayerListener.get());

  855. 

  856.                 if (videoSurfaceHolder != nullptr)

  857.                     env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setDisplay, videoSurfaceHolder.get());

  858. 

  859.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.prepareAsync);

  860. 

  861.                 currentState = State::preparing;

  862.             }

  863. 

  864.             void closeVideo()

  865.             {

  866.                 if (nativeMediaPlayer.get() == nullptr)

  867.                     return;

  868. 

  869.                 auto* env = getEnv();

  870. 

  871.                 if (getCurrentStateInfo().canCallStop)

  872.                     env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.stop);

  873. 

  874.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.release);

  875.                 nativeMediaPlayer.clear();

  876. 

  877.                 currentState = State::end;

  878.             }

  879. 

  880.             bool isVideoOpen() const noexcept

  881.             {

  882.                 return currentState == State::prepared || currentState == State::started

  883.                     || currentState == State::paused || currentState == State::complete;

  884.             }

  885. 

  886.             int getPlaybackStateFlag() const noexcept { return getCurrentStateInfo().playbackStateFlag; }

  887.             int getAllowedActions()    const noexcept { return getCurrentStateInfo().allowedActions; }

  888. 

  889.             jlong getVideoDuration() const

  890.             {

  891.                 if (! getCurrentStateInfo().canCallGetVideoDuration)

  892.                     return 0;

  893. 

  894.                 return getEnv()->CallIntMethod (nativeMediaPlayer, AndroidMediaPlayer.getDuration);

  895.             }

  896. 

  897.             Rectangle<int> getVideoNativeSize() const

  898.             {

  899.                 if (! getCurrentStateInfo().canCallGetVideoHeight)

  900.                 {

  901.                     jassertfalse;

  902.                     return {};

  903.                 }

  904. 

  905.                 auto* env = getEnv();

  906. 

  907.                 auto width  = (int) env->CallIntMethod (nativeMediaPlayer, AndroidMediaPlayer.getVideoWidth);

  908.                 auto height = (int) env->CallIntMethod (nativeMediaPlayer, AndroidMediaPlayer.getVideoHeight);

  909. 

  910.                 return Rectangle<int> (0, 0, width, height);

  911.             }

  912. 

  913.             void play()

  914.             {

  915.                 if (! getCurrentStateInfo().canCallStart)

  916.                 {

  917.                     jassertfalse;

  918.                     return;

  919.                 }

  920. 

  921.                 auto* env = getEnv();

  922. 

  923.                 // Perform a potentially pending volume setting

  924.                 if (! exactlyEqual (lastAudioVolume, std::numeric_limits<float>::min()))

  925.                     env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setVolume, (jfloat) lastAudioVolume, (jfloat) lastAudioVolume);

  926. 

  927.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.start);

  928. 

  929.                 currentState = State::started;

  930.             }

  931. 

  932.             void pause()

  933.             {

  934.                 if (! getCurrentStateInfo().canCallPause)

  935.                 {

  936.                     jassertfalse;

  937.                     return;

  938.                 }

  939. 

  940.                 getEnv()->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.pause);

  941. 

  942.                 currentState = State::paused;

  943.             }

  944. 

  945.             bool isPlaying() const

  946.             {

  947.                 return getCurrentStateInfo().isPlaying;

  948.             }

  949. 

  950.             void setPlayPosition (jint newPositionMs)

  951.             {

  952.                 if (! getCurrentStateInfo().canCallSeekTo)

  953.                 {

  954.                     jassertfalse;

  955.                     return;

  956.                 }

  957. 

  958.                 getEnv()->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.seekTo, (jint) newPositionMs);

  959.             }

  960. 

  961.             jint getPlayPosition() const

  962.             {

  963.                 if (! getCurrentStateInfo().canCallGetCurrentPosition)

  964.                     return 0.0;

  965. 

  966.                 return getEnv()->CallIntMethod (nativeMediaPlayer, AndroidMediaPlayer.getCurrentPosition);

  967.             }

  968. 

  969.             void setPlaySpeed (double newSpeed)

  970.             {

  971.                 if (! getCurrentStateInfo().canCallSetPlaybackParams)

  972.                 {

  973.                     jassertfalse;

  974.                     return;

  975.                 }

  976. 

  977.                 auto* env = getEnv();

  978. 

  979.                 auto playbackParams = LocalRef<jobject> (env->CallObjectMethod (nativeMediaPlayer, AndroidMediaPlayer.getPlaybackParams));

  980.                 LocalRef<jobject> (env->CallObjectMethod (playbackParams, AndroidPlaybackParams.setSpeed, (jfloat) newSpeed));

  981.                 env->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setPlaybackParams, playbackParams.get());

  982. 

  983.                 if (jniCheckHasExceptionOccurredAndClear())

  984.                 {

  985.                     // MediaPlayer can't handle speed provided!

  986.                     jassertfalse;

  987.                 }

  988.             }

  989. 

  990.             double getPlaySpeed() const

  991.             {

  992.                 if (! getCurrentStateInfo().canCallGetPlaybackParams)

  993.                     return 0.0;

  994. 

  995.                 auto* env = getEnv();

  996. 

  997.                 auto playbackParams = LocalRef<jobject> (env->CallObjectMethod (nativeMediaPlayer, AndroidMediaPlayer.getPlaybackParams));

  998.                 return (double) env->CallFloatMethod (playbackParams, AndroidPlaybackParams.getSpeed);

  999.             }

  1000. 

  1001.             void setAudioVolume (float newVolume)

  1002.             {

  1003.                 if (! getCurrentStateInfo().canCallSetVolume)

  1004.                 {

  1005.                     jassertfalse;

  1006.                     return;

  1007.                 }

  1008. 

  1009.                 lastAudioVolume = jlimit (0.0f, 1.0f, newVolume);

  1010. 

  1011.                 if (nativeMediaPlayer.get() != nullptr)

  1012.                     getEnv()->CallVoidMethod (nativeMediaPlayer, AndroidMediaPlayer.setVolume, (jfloat) lastAudioVolume, (jfloat) lastAudioVolume);

  1013.             }

  1014. 

  1015.             float getAudioVolume() const

  1016.             {

  1017.                 // There is NO getVolume() in MediaPlayer, so the value returned here can be incorrect!

  1018.                 return lastAudioVolume;

  1019.             }

  1020. 

  1021.         private:

  1022.             //==============================================================================

  1023.             struct StateInfo

  1024.             {

  1025.                 int playbackStateFlag = 0, allowedActions = 0;

  1026. 

  1027.                 bool isPlaying, canCallGetCurrentPosition, canCallGetVideoDuration,

  1028.                         canCallGetVideoHeight, canCallGetVideoWidth, canCallGetPlaybackParams,

  1029.                         canCallPause, canCallPrepare, canCallSeekTo, canCallSetAudioAttributes,

  1030.                         canCallSetDataSource, canCallSetPlaybackParams, canCallSetVolume,

  1031.                         canCallStart, canCallStop;

  1032.             };

  1033. 

  1034.             enum class State

  1035.             {

  1036.                 idle, initialised, preparing, prepared, started, paused, stopped, complete, error, end

  1037.             };

  1038. 

  1039.             static constexpr StateInfo stateInfos[] = {

  1040.                 /* idle */

  1041.                 {PlaybackState::STATE_NONE, PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1042.                             false, true, false, true, true, false, false, false, false, true,

  1043.                             true,  false, true, false, false},

  1044.                 /* initialised */

  1045.                 {PlaybackState::STATE_NONE, 0, // NB: could use action prepare, but that's API 24 onwards only

  1046.                             false, true, false, true, true, true, false, true, false, true,

  1047.                             false,  true, true, false, false},

  1048.                 /* preparing */

  1049.                 {PlaybackState::STATE_BUFFERING, 0,

  1050.                             false, false, false, false, false, true, false, false, false, false,

  1051.                             false,  false, false, false, false},

  1052.                 /* prepared */

  1053.                 {PlaybackState::STATE_PAUSED,

  1054.                             PlaybackState::ACTION_PLAY | PlaybackState::ACTION_PLAY_PAUSE | PlaybackState::ACTION_PLAY_FROM_MEDIA_ID | PlaybackState::ACTION_STOP | PlaybackState::ACTION_SEEK_TO,

  1055.                             false, true, true, true, true, true, false, false, true, true,

  1056.                             false, true, true, true, true},

  1057.                 /* started */

  1058.                 {PlaybackState::STATE_PLAYING,

  1059.                             PlaybackState::ACTION_PAUSE | PlaybackState::ACTION_PLAY_PAUSE | PlaybackState::ACTION_SEEK_TO | PlaybackState::ACTION_STOP | PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1060.                             true, true, true, true, true, true, true, false, true, true,

  1061.                             false, true, true, true, true},

  1062.                 /* paused */

  1063.                 {PlaybackState::STATE_PAUSED,

  1064.                             PlaybackState::ACTION_PLAY | PlaybackState::ACTION_PLAY_PAUSE | PlaybackState::ACTION_SEEK_TO | PlaybackState::ACTION_STOP | PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1065.                             false, true, true, true, true, true, true, false, true, true,

  1066.                             false, true, true, true, true},

  1067.                 /* stopped */

  1068.                 {PlaybackState::STATE_STOPPED,

  1069.                             PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1070.                             false, true, true, true, true, true, false, true, false, true,

  1071.                             false, false, true, false, true},

  1072.                 /* complete */

  1073.                 {PlaybackState::STATE_PAUSED,

  1074.                             PlaybackState::ACTION_SEEK_TO | PlaybackState::ACTION_STOP | PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1075.                             false, true, true, true, true, true, true, false, true, true,

  1076.                             false, true, true, true, true},

  1077.                 /* error */

  1078.                 {PlaybackState::STATE_ERROR,

  1079.                             PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1080.                             false, false, false, false, false, false, false, false, false, false,

  1081.                             false, false, false, false, false},

  1082.                 /* end */

  1083.                 {PlaybackState::STATE_NONE,

  1084.                             PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1085.                             false, false, false, false, false, false, false, false, false, false,

  1086.                             false, false, false, false, false}

  1087.             };

  1088. 

  1089.             StateInfo getCurrentStateInfo() const noexcept             { return stateInfos[static_cast<int> (currentState)]; }

  1090. 

  1091.             //==============================================================================

  1092.             MediaSession& owner;

  1093.             GlobalRef nativeMediaPlayer;

  1094. 

  1095.             MediaPlayerListener mediaPlayerListener;

  1096.             GlobalRef nativeMediaPlayerListener;

  1097. 

  1098.             float lastAudioVolume = std::numeric_limits<float>::min();

  1099. 

  1100.             GlobalRef videoSurfaceHolder;

  1101. 

  1102.             State currentState = State::idle;

  1103. 

  1104.             //==============================================================================

  1105.             void onPrepared ([[maybe_unused]] LocalRef<jobject>& mediaPlayer) override

  1106.             {

  1107.                 JUCE_VIDEO_LOG ("MediaPlayer::onPrepared()");

  1108. 

  1109.                 currentState = State::prepared;

  1110. 

  1111.                 owner.playerPrepared();

  1112.             }

  1113. 

  1114.             void onBufferingUpdate ([[maybe_unused]] LocalRef<jobject>& mediaPlayer, int progress) override

  1115.             {

  1116.                 owner.playerBufferingUpdated (progress);

  1117.             }

  1118. 

  1119.             void onSeekComplete ([[maybe_unused]] LocalRef<jobject>& mediaPlayer) override

  1120.             {

  1121.                 JUCE_VIDEO_LOG ("MediaPlayer::onSeekComplete()");

  1122. 

  1123.                 owner.playerSeekCompleted();

  1124.             }

  1125. 

  1126.             void onCompletion ([[maybe_unused]] LocalRef<jobject>& mediaPlayer) override

  1127.             {

  1128.                 JUCE_VIDEO_LOG ("MediaPlayer::onCompletion()");

  1129. 

  1130.                 currentState = State::complete;

  1131. 

  1132.                 owner.playerPlaybackCompleted();

  1133.             }

  1134. 

  1135.             enum

  1136.             {

  1137.                 MEDIA_INFO_UNKNOWN               = 1,

  1138.                 MEDIA_INFO_VIDEO_RENDERING_START = 3,

  1139.                 MEDIA_INFO_VIDEO_TRACK_LAGGING   = 700,

  1140.                 MEDIA_INFO_BUFFERING_START       = 701,

  1141.                 MEDIA_INFO_BUFFERING_END         = 702,

  1142.                 MEDIA_INFO_NETWORK_BANDWIDTH     = 703,

  1143.                 MEDIA_INFO_BAD_INTERLEAVING      = 800,

  1144.                 MEDIA_INFO_NOT_SEEKABLE          = 801,

  1145.                 MEDIA_INFO_METADATA_UPDATE       = 802,

  1146.                 MEDIA_INFO_AUDIO_NOT_PLAYING     = 804,

  1147.                 MEDIA_INFO_VIDEO_NOT_PLAYING     = 805,

  1148.                 MEDIA_INFO_UNSUPPORTED_SUBTITE   = 901,

  1149.                 MEDIA_INFO_SUBTITLE_TIMED_OUT    = 902

  1150.             };

  1151. 

  1152.             bool onInfo ([[maybe_unused]] LocalRef<jobject>& mediaPlayer, int what, [[maybe_unused]] int extra) override

  1153.             {

  1154.                 JUCE_VIDEO_LOG ("MediaPlayer::onInfo(), infoCode: " + String (what) + " (" + infoCodeToString (what) + ")"

  1155.                                 + ", extraCode: " + String (extra));

  1156. 

  1157.                 if (what == MEDIA_INFO_BUFFERING_START)

  1158.                     owner.playerBufferingStarted();

  1159.                 else if (what == MEDIA_INFO_BUFFERING_END)

  1160.                     owner.playerBufferingEnded();

  1161. 

  1162.                 return true;

  1163.             }

  1164. 

  1165.             static String infoCodeToString (int code)

  1166.             {

  1167.                 switch (code)

  1168.                 {

  1169.                     case MEDIA_INFO_UNKNOWN:               return "Unknown";

  1170.                     case MEDIA_INFO_VIDEO_RENDERING_START: return "Rendering start";

  1171.                     case MEDIA_INFO_VIDEO_TRACK_LAGGING:   return "Video track lagging";

  1172.                     case MEDIA_INFO_BUFFERING_START:       return "Buffering start";

  1173.                     case MEDIA_INFO_BUFFERING_END:         return "Buffering end";

  1174.                     case MEDIA_INFO_NETWORK_BANDWIDTH:     return "Network bandwidth info available";

  1175.                     case MEDIA_INFO_BAD_INTERLEAVING:      return "Bad interleaving";

  1176.                     case MEDIA_INFO_NOT_SEEKABLE:          return "Video not seekable";

  1177.                     case MEDIA_INFO_METADATA_UPDATE:       return "Metadata updated";

  1178.                     case MEDIA_INFO_AUDIO_NOT_PLAYING:     return "Audio not playing";

  1179.                     case MEDIA_INFO_VIDEO_NOT_PLAYING:     return "Video not playing";

  1180.                     case MEDIA_INFO_UNSUPPORTED_SUBTITE:   return "Unsupported subtitle";

  1181.                     case MEDIA_INFO_SUBTITLE_TIMED_OUT:    return "Subtitle timed out";

  1182.                     default:                               return "";

  1183.                 }

  1184.             }

  1185. 

  1186.             bool onError ([[maybe_unused]] LocalRef<jobject>& mediaPlayer, int what, int extra) override

  1187.             {

  1188.                 auto errorMessage = errorCodeToString (what);

  1189.                 auto extraMessage = errorCodeToString (extra);

  1190. 

  1191.                 if (extraMessage.isNotEmpty())

  1192.                     errorMessage << ", " << extraMessage;

  1193. 

  1194.                 JUCE_VIDEO_LOG ("MediaPlayer::onError(), errorCode: " + String (what) + " (" + errorMessage + ")"

  1195.                                 + ", extraCode: " + String (extra) + " (" + extraMessage + ")");

  1196. 

  1197.                 currentState = State::error;

  1198. 

  1199.                 owner.errorOccurred (errorMessage);

  1200.                 return true;

  1201.             }

  1202. 

  1203.             static String errorCodeToString (int code)

  1204.             {

  1205.                 enum

  1206.                 {

  1207.                     MEDIA_ERROR_UNSUPPORTED                        = -1010,

  1208.                     MEDIA_ERROR_MALFORMED                          = -1007,

  1209.                     MEDIA_ERROR_IO                                 = -1004,

  1210.                     MEDIA_ERROR_TIMED_OUT                          = -110,

  1211.                     MEDIA_ERROR_UNKNOWN                            = 1,

  1212.                     MEDIA_ERROR_SERVER_DIED                        = 100,

  1213.                     MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200

  1214.                 };

  1215. 

  1216.                 switch (code)

  1217.                 {

  1218.                     case MEDIA_ERROR_UNSUPPORTED:                        return "Unsupported bitstream";

  1219.                     case MEDIA_ERROR_MALFORMED:                          return "Malformed bitstream";

  1220.                     case MEDIA_ERROR_IO:                                 return "File/Network I/O error";

  1221.                     case MEDIA_ERROR_TIMED_OUT:                          return "Timed out";

  1222.                     case MEDIA_ERROR_UNKNOWN:                            return "Unknown error";

  1223.                     case MEDIA_ERROR_SERVER_DIED:                        return "Media server died (playback restart required)";

  1224.                     case MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK: return "Video container not valid for progressive playback";

  1225.                     default:                                             return "";

  1226.                 }

  1227.             }

  1228. 

  1229.             //==============================================================================

  1230.             static StringArray getNativeMediaPlayerListenerInterfaces()

  1231.             {

  1232.                 #define IFPREFIX "android/media/MediaPlayer$"

  1233. 

  1234.                 return { IFPREFIX "OnCompletionListener", IFPREFIX "OnErrorListener",

  1235.                          IFPREFIX "OnInfoListener", IFPREFIX "OnPreparedListener",

  1236.                          IFPREFIX "OnBufferingUpdateListener", IFPREFIX "OnSeekCompleteListener"

  1237.                 };

  1238. 

  1239.                 #undef IFPREFIX

  1240.             }

  1241.         };

  1242. 

  1243.         //==============================================================================

  1244.         Pimpl& owner;

  1245.         int sdkVersion;

  1246. 

  1247.         GlobalRef audioAttributes;

  1248.         GlobalRef nativeMediaSession;

  1249.         GlobalRef mediaSessionCallback;

  1250.         GlobalRef playbackStateBuilder;

  1251. 

  1252.         Controller controller;

  1253.         Player player;

  1254. 

  1255.         GlobalRef audioManager;

  1256.         AudioManagerOnAudioFocusChangeListener audioFocusChangeListener;

  1257.         GlobalRef nativeAudioFocusChangeListener;

  1258.         GlobalRef audioFocusRequest;

  1259. 

  1260.         GlobalRef storedPlaybackState;

  1261. 

  1262.         bool pendingSeekRequest = false;

  1263. 

  1264.         bool playerBufferingInProgress = false;

  1265.         bool usesBuffering = false;

  1266.         SparseSet<int> bufferedRegions;

  1267. 

  1268.         double playSpeedMult = 1.0;

  1269.         bool hasAudioFocus = false;

  1270. 

  1271.         //==============================================================================

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

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

  1274.             CALLBACK (generatedCallback<&MediaSession::pauseCallback>,           "mediaSessionPause",           "(J)V") \

  1275.             CALLBACK (generatedCallback<&MediaSession::playCallback>,            "mediaSessionPlay",            "(J)V") \

  1276.             CALLBACK (generatedCallback<&MediaSession::playFromMediaIdCallback>, "mediaSessionPlayFromMediaId", "(JLjava/lang/String;Landroid/os/Bundle;)V") \

  1277.             CALLBACK (generatedCallback<&MediaSession::seekToCallback>,          "mediaSessionSeekTo",          "(JJ)V") \

  1278.             CALLBACK (generatedCallback<&MediaSession::stopCallback>,            "mediaSessionStop",            "(J)V")

  1279. 

  1280.         DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidMediaSessionCallback, "com/rmsl/juce/MediaSessionCallback", 21)

  1281.         #undef JNI_CLASS_MEMBERS

  1282. 

  1283.         LocalRef<jobject> createCallbackObject()

  1284.         {

  1285.             return LocalRef<jobject> (getEnv()->NewObject (AndroidMediaSessionCallback,

  1286.                                                            AndroidMediaSessionCallback.constructor,

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

  1288.         }

  1289. 

  1290.         //==============================================================================

  1291.         // MediaSession callbacks

  1292.         static void pauseCallback (JNIEnv*, MediaSession& t)

  1293.         {

  1294.             JUCE_VIDEO_LOG ("MediaSession::pauseCallback()");

  1295.             t.player.pause();

  1296.             t.updatePlaybackState();

  1297.             t.abandonAudioFocus();

  1298.         }

  1299. 

  1300.         static void playCallback (JNIEnv* env, MediaSession& t)

  1301.         {

  1302.             JUCE_VIDEO_LOG ("MediaSession::playCallback()");

  1303. 

  1304.             t.requestAudioFocus();

  1305. 

  1306.             if (! t.hasAudioFocus)

  1307.             {

  1308.                 t.errorOccurred ("Application has been denied audio focus. Try again later.");

  1309.                 return;

  1310.             }

  1311. 

  1312.             env->CallVoidMethod (t.nativeMediaSession, AndroidMediaSession.setActive, true);

  1313. 

  1314.             t.player.play();

  1315.             t.setSpeed (t.playSpeedMult);

  1316.             t.updatePlaybackState();

  1317.         }

  1318. 

  1319.         static void playFromMediaIdCallback (JNIEnv* env, MediaSession& t, jstring mediaId, jobject extras)

  1320.         {

  1321.             JUCE_VIDEO_LOG ("MediaSession::playFromMediaIdCallback()");

  1322. 

  1323.             t.player.load (LocalRef<jstring> ((jstring) env->NewLocalRef (mediaId)), LocalRef<jobject> (env->NewLocalRef (extras)));

  1324.             t.updatePlaybackState();

  1325.         }

  1326. 

  1327.         static void seekToCallback (JNIEnv*, MediaSession& t, jlong pos)

  1328.         {

  1329.             JUCE_VIDEO_LOG ("MediaSession::seekToCallback()");

  1330. 

  1331.             t.pendingSeekRequest = true;

  1332.             t.player.setPlayPosition ((jint) pos);

  1333.             t.updatePlaybackState();

  1334.         }

  1335. 

  1336.         static void stopCallback (JNIEnv* env, MediaSession& t)

  1337.         {

  1338.             JUCE_VIDEO_LOG ("MediaSession::stopCallback()");

  1339. 

  1340.             env->CallVoidMethod (t.nativeMediaSession, AndroidMediaSession.setActive, false);

  1341. 

  1342.             t.player.closeVideo();

  1343.             t.updatePlaybackState();

  1344. 

  1345.             t.abandonAudioFocus();

  1346. 

  1347.             t.owner.closeVideoFinished();

  1348.         }

  1349. 

  1350.         //==============================================================================

  1351.         bool isSeekInProgress() const noexcept

  1352.         {

  1353.             if (pendingSeekRequest)

  1354.                 return true;

  1355. 

  1356.             if (! usesBuffering)

  1357.                 return false;

  1358. 

  1359.             // NB: player sometimes notifies us about buffering, but only for regions that

  1360.             // were previously buffered already. For buffering happening for the first time,

  1361.             // we don't get such notification...

  1362.             if (playerBufferingInProgress)

  1363.                 return true;

  1364. 

  1365.             auto playPos = player.getPlayPosition();

  1366.             auto durationMs = player.getVideoDuration();

  1367.             auto playPosPercent = (int) (100.0 * playPos / static_cast<double> (durationMs));

  1368. 

  1369.             // NB: assuming the playback will start roughly when there is 5% of content loaded...

  1370.             return ! bufferedRegions.containsRange (Range<int> (playPosPercent, jmin (101, playPosPercent + 5)));

  1371.         }

  1372. 

  1373.         void updatePlaybackState()

  1374.         {

  1375.             getEnv()->CallVoidMethod (nativeMediaSession, AndroidMediaSession.setPlaybackState, getCurrentPlaybackState().get());

  1376.         }

  1377. 

  1378.         LocalRef<jobject> getCurrentPlaybackState()

  1379.         {

  1380.             static constexpr int bufferingState = 6;

  1381. 

  1382.             auto playbackStateFlag = isSeekInProgress() ? bufferingState : player.getPlaybackStateFlag();

  1383.             auto playPos = player.getPlayPosition();

  1384.             auto playSpeed = player.getPlaySpeed();

  1385.             auto allowedActions = player.getAllowedActions();

  1386. 

  1387.             auto* env = getEnv();

  1388. 

  1389.             LocalRef<jobject> (env->CallObjectMethod (playbackStateBuilder, AndroidPlaybackStateBuilder.setState,

  1390.                                                       (jint) playbackStateFlag, (jlong) playPos, (jfloat) playSpeed));

  1391. 

  1392.             LocalRef<jobject> (env->CallObjectMethod (playbackStateBuilder, AndroidPlaybackStateBuilder.setActions, (jint) allowedActions));

  1393. 

  1394.             return LocalRef<jobject> (env->CallObjectMethod (playbackStateBuilder, AndroidPlaybackStateBuilder.build));

  1395.         }

  1396. 

  1397.         //==============================================================================

  1398.         void playerPrepared()

  1399.         {

  1400.             resetState();

  1401. 

  1402.             updateMetadata();

  1403. 

  1404.             owner.loadFinished();

  1405.         }

  1406. 

  1407.         void playerBufferingStarted() { playerBufferingInProgress = true; }

  1408.         void playerBufferingEnded()   { playerBufferingInProgress = false; }

  1409. 

  1410.         void playerBufferingUpdated (int progress)

  1411.         {

  1412.             usesBuffering = true;

  1413. 

  1414.             updatePlaybackState();

  1415. 

  1416.             auto playPos = player.getPlayPosition();

  1417.             auto durationMs = player.getVideoDuration();

  1418.             auto playPosPercent = (int) (100.0 * playPos / static_cast<double> (durationMs));

  1419. 

  1420.             bufferedRegions.addRange (Range<int> (playPosPercent, progress + 1));

  1421. 

  1422.             String ranges;

  1423. 

  1424.             for (auto& r : bufferedRegions.getRanges())

  1425.                 ranges << "[" << r.getStart() << "%, " << r.getEnd() - 1 << "%] ";

  1426. 

  1427.             JUCE_VIDEO_LOG ("Buffering status update, seek pos: " + String (playPosPercent) + "%, buffered regions: " + ranges);

  1428.         }

  1429. 

  1430.         void playerSeekCompleted()

  1431.         {

  1432.             pendingSeekRequest = false;

  1433.             updatePlaybackState();

  1434.         }

  1435. 

  1436.         void playerPlaybackCompleted()

  1437.         {

  1438.             player.pause();

  1439.             abandonAudioFocus();

  1440. 

  1441.             pendingSeekRequest = true;

  1442.             player.setPlayPosition (0);

  1443.             updatePlaybackState();

  1444.         }

  1445. 

  1446.         void updateMetadata()

  1447.         {

  1448.             auto* env = getEnv();

  1449. 

  1450.             auto metadataBuilder = LocalRef<jobject> (env->NewObject (AndroidMediaMetadataBuilder,

  1451.                                                                       AndroidMediaMetadataBuilder.constructor));

  1452. 

  1453.             auto durationMs = player.getVideoDuration();

  1454. 

  1455.             auto jDurationKey = javaString ("android.media.metadata.DURATION");

  1456.             LocalRef<jobject> (env->CallObjectMethod (metadataBuilder,

  1457.                                                       AndroidMediaMetadataBuilder.putLong,

  1458.                                                       jDurationKey.get(),

  1459.                                                       (jlong) durationMs));

  1460. 

  1461.             auto jNumTracksKey = javaString ("android.media.metadata.NUM_TRACKS");

  1462.             LocalRef<jobject> (env->CallObjectMethod (metadataBuilder,

  1463.                                                       AndroidMediaMetadataBuilder.putLong,

  1464.                                                       jNumTracksKey.get(),

  1465.                                                       (jlong) 1));

  1466. 

  1467.             env->CallVoidMethod (nativeMediaSession, AndroidMediaSession.setMetadata,

  1468.                                  env->CallObjectMethod (metadataBuilder, AndroidMediaMetadataBuilder.build));

  1469.         }

  1470. 

  1471.         void errorOccurred (const String& errorMessage)

  1472.         {

  1473.             auto* env = getEnv();

  1474. 

  1475.             // Propagate error to session controller(s) and ...

  1476.             LocalRef<jobject> (env->CallObjectMethod (playbackStateBuilder, AndroidPlaybackStateBuilder.setErrorMessage,

  1477.                                                       javaString (errorMessage).get()));

  1478. 

  1479.             auto state = LocalRef<jobject> (env->CallObjectMethod (playbackStateBuilder, AndroidPlaybackStateBuilder.build));

  1480.             env->CallVoidMethod (nativeMediaSession, AndroidMediaSession.setPlaybackState, state.get());

  1481. 

  1482.             // ...also notify JUCE side client

  1483.             owner.errorOccurred (errorMessage);

  1484.         }

  1485. 

  1486.         //==============================================================================

  1487.         static LocalRef<jobject> createAudioFocusRequestIfNecessary (int sdkVersion, const GlobalRef& audioAttributes,

  1488.                                                                      const GlobalRef& nativeAudioFocusChangeListener)

  1489.         {

  1490.             if (sdkVersion < 26)

  1491.                 return LocalRef<jobject>();

  1492. 

  1493.             auto* env = getEnv();

  1494. 

  1495.             auto requestBuilderClass = LocalRef<jclass> (env->FindClass ("android/media/AudioFocusRequest$Builder"));

  1496. 

  1497.             static jmethodID constructor = env->GetMethodID (requestBuilderClass, "<init>", "(I)V");

  1498.             static jmethodID buildMethod = env->GetMethodID (requestBuilderClass, "build", "()Landroid/media/AudioFocusRequest;");

  1499.             static jmethodID setAudioAttributesMethod = env->GetMethodID (requestBuilderClass, "setAudioAttributes",

  1500.                                                                           "(Landroid/media/AudioAttributes;)Landroid/media/AudioFocusRequest$Builder;");

  1501.             static jmethodID setOnAudioFocusChangeListenerMethod = env->GetMethodID (requestBuilderClass, "setOnAudioFocusChangeListener",

  1502.                                                                                      "(Landroid/media/AudioManager$OnAudioFocusChangeListener;)Landroid/media/AudioFocusRequest$Builder;");

  1503. 

  1504.             static constexpr jint audioFocusGain = 1;

  1505. 

  1506.             auto requestBuilder = LocalRef<jobject> (env->NewObject (requestBuilderClass, constructor, audioFocusGain));

  1507.             LocalRef<jobject> (env->CallObjectMethod (requestBuilder, setAudioAttributesMethod, audioAttributes.get()));

  1508.             LocalRef<jobject> (env->CallObjectMethod (requestBuilder, setOnAudioFocusChangeListenerMethod, nativeAudioFocusChangeListener.get()));

  1509. 

  1510.             return LocalRef<jobject> (env->CallObjectMethod (requestBuilder, buildMethod));

  1511.         }

  1512. 

  1513.         void requestAudioFocus()

  1514.         {

  1515.             static constexpr jint audioFocusGain = 1;

  1516.             static constexpr jint streamMusic = 3;

  1517.             static constexpr jint audioFocusRequestGranted = 1;

  1518. 

  1519.             jint result = audioFocusRequestGranted;

  1520. 

  1521.             if (sdkVersion >= 26)

  1522.             {

  1523.                 static jmethodID requestAudioFocusMethod = getEnv()->GetMethodID (AndroidAudioManager, "requestAudioFocus",

  1524.                                                                                   "(Landroid/media/AudioFocusRequest;)I");

  1525. 

  1526.                 result = getEnv()->CallIntMethod (audioManager, requestAudioFocusMethod, audioFocusRequest.get());

  1527.             }

  1528.             else

  1529.             {

  1530.                 result = getEnv()->CallIntMethod (audioManager, AndroidAudioManager.requestAudioFocus,

  1531.                                                   nativeAudioFocusChangeListener.get(), streamMusic, audioFocusGain);

  1532.             }

  1533. 

  1534.             hasAudioFocus = result == audioFocusRequestGranted;

  1535.         }

  1536. 

  1537.         void abandonAudioFocus()

  1538.         {

  1539.             if (! hasAudioFocus)

  1540.                 return;

  1541. 

  1542.             static constexpr jint audioFocusRequestGranted = 1;

  1543. 

  1544.             jint result = audioFocusRequestGranted;

  1545. 

  1546.             if (sdkVersion >= 26)

  1547.             {

  1548.                 static jmethodID abandonAudioFocusMethod = getEnv()->GetMethodID (AndroidAudioManager, "abandonAudioFocusRequest",

  1549.                                                                                   "(Landroid/media/AudioFocusRequest;)I");

  1550. 

  1551.                 result = getEnv()->CallIntMethod (audioManager, abandonAudioFocusMethod, audioFocusRequest.get());

  1552.             }

  1553.             else

  1554.             {

  1555.                 result = getEnv()->CallIntMethod (audioManager, AndroidAudioManager.abandonAudioFocus,

  1556.                                                    nativeAudioFocusChangeListener.get());

  1557.             }

  1558. 

  1559.             // NB: granted in this case means "granted to change the focus to abandoned"...

  1560.             hasAudioFocus = result != audioFocusRequestGranted;

  1561.         }

  1562. 

  1563.         void onAudioFocusChange (int changeType) override

  1564.         {

  1565.             static constexpr jint audioFocusGain = 1;

  1566. 

  1567.             if (changeType == audioFocusGain)

  1568.                 JUCE_VIDEO_LOG ("Audio focus gained");

  1569.             else

  1570.                 JUCE_VIDEO_LOG ("Audio focus lost");

  1571. 

  1572.             if (changeType != audioFocusGain)

  1573.             {

  1574.                 if (isPlaying())

  1575.                 {

  1576.                     JUCE_VIDEO_LOG ("Received a request to abandon audio focus. Stopping playback...");

  1577.                     stop();

  1578.                 }

  1579. 

  1580.                 abandonAudioFocus();

  1581.             }

  1582.         }

  1583. 

  1584.         //==============================================================================

  1585.         void playbackStarted()

  1586.         {

  1587.             owner.playbackStarted();

  1588.         }

  1589. 

  1590.         void playbackStopped()

  1591.         {

  1592.             owner.playbackStopped();

  1593.         }

  1594. 

  1595.         //==============================================================================

  1596.         void resetState()

  1597.         {

  1598.             usesBuffering = false;

  1599.             bufferedRegions.clear();

  1600.             playerBufferingInProgress = false;

  1601. 

  1602.             pendingSeekRequest = false;

  1603. 

  1604.             playSpeedMult = 1.0;

  1605.             hasAudioFocus = false;

  1606.         }

  1607. 

  1608.         //==============================================================================

  1609.         static LocalRef<jobject> getAudioAttributes()

  1610.         {

  1611.             // Video requires SDK version 21 or higher

  1612.             jassert (getAndroidSDKVersion() >= 21);

  1613. 

  1614.             auto* env = getEnv();

  1615. 

  1616.             auto audioAttribsBuilder = LocalRef<jobject> (env->NewObject (AndroidAudioAttributesBuilder,

  1617.                                                                           AndroidAudioAttributesBuilder.constructor));

  1618.             static constexpr jint contentTypeMovie = 3;

  1619.             static constexpr jint usageMedia = 1;

  1620. 

  1621.             LocalRef<jobject> (env->CallObjectMethod (audioAttribsBuilder, AndroidAudioAttributesBuilder.setContentType, contentTypeMovie));

  1622.             LocalRef<jobject> (env->CallObjectMethod (audioAttribsBuilder, AndroidAudioAttributesBuilder.setUsage, usageMedia));

  1623. 

  1624.             return LocalRef<jobject> (env->CallObjectMethod (audioAttribsBuilder, AndroidAudioAttributesBuilder.build));

  1625.         }

  1626.     };

  1627. 

  1628.    #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1629.     //==============================================================================

  1630.     class SystemVolumeListener

  1631.     {

  1632.     public:

  1633.         SystemVolumeListener (Pimpl& ownerToUse)

  1634.             : owner (ownerToUse),

  1635.               nativeObserver (createCallbackObject())

  1636.         {

  1637.             setEnabled (true);

  1638.         }

  1639. 

  1640.         ~SystemVolumeListener()

  1641.         {

  1642.             setEnabled (false);

  1643.         }

  1644.     private:

  1645.         Pimpl& owner;

  1646.         GlobalRef nativeObserver;

  1647. 

  1648.         //==============================================================================

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

  1650.             METHOD (constructor, "<init>",     "(Landroid/app/Activity;J)V") \

  1651.             METHOD (setEnabled,  "setEnabled", "(Z)V")                  \

  1652.             CALLBACK (generatedCallback<&SystemVolumeListener::systemVolumeChanged>, "mediaSessionSystemVolumeChanged", "(J)V")

  1653. 

  1654.         DECLARE_JNI_CLASS_WITH_MIN_SDK (SystemVolumeObserver, "com/rmsl/juce/SystemVolumeObserver", 21)

  1655.         #undef JNI_CLASS_MEMBERS

  1656. 

  1657. 

  1658.         LocalRef<jobject> createCallbackObject()

  1659.         {

  1660.             return LocalRef<jobject> (getEnv()->NewObject (SystemVolumeObserver,

  1661.                                                            SystemVolumeObserver.constructor,

  1662.                                                            getCurrentActivity().get(),

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

  1664.         }

  1665.     public:

  1666.         void setEnabled (bool shouldBeEnabled)

  1667.         {

  1668.             getEnv()->CallVoidMethod (nativeObserver, SystemVolumeObserver.setEnabled, shouldBeEnabled);

  1669. 

  1670.             // Send first notification instantly to ensure sync.

  1671.             if (shouldBeEnabled)

  1672.                 systemVolumeChanged (getEnv(), *this);

  1673.         }

  1674. 

  1675.     private:

  1676.         //==============================================================================

  1677.         static void systemVolumeChanged (JNIEnv*, SystemVolumeListener& t)

  1678.         {

  1679.             MessageManager::callAsync ([weakThis = WeakReference<SystemVolumeListener> { &t }]

  1680.                                        {

  1681.                                            if (weakThis == nullptr)

  1682.                                                return;

  1683. 

  1684.                                            if (weakThis->owner.owner.onGlobalMediaVolumeChanged != nullptr)

  1685.                                                weakThis->owner.owner.onGlobalMediaVolumeChanged();

  1686.                                        });

  1687. 

  1688.         }

  1689. 

  1690.         JUCE_DECLARE_WEAK_REFERENCEABLE (SystemVolumeListener)

  1691.     };

  1692. 

  1693.     //==============================================================================

  1694.     VideoComponent& owner;

  1695. 

  1696.     MediaSession mediaSession;

  1697.     GlobalRef activityLifeListener;

  1698.    #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1699.     SystemVolumeListener systemVolumeListener;

  1700.    #endif

  1701.     GlobalRef surfaceHolderCallback;

  1702. 

  1703.     std::function<void (const URL&, Result)> loadFinishedCallback;

  1704. 

  1705.     bool wasOpen = false;

  1706. 

  1707.     //==============================================================================

  1708.     void loadFinished()

  1709.     {

  1710.         owner.resized();

  1711. 

  1712.         if (loadFinishedCallback != nullptr)

  1713.         {

  1714.             loadFinishedCallback (currentURL, Result::ok());

  1715.             loadFinishedCallback = nullptr;

  1716.         }

  1717.     }

  1718. 

  1719.     void closeVideoFinished()

  1720.     {

  1721.         owner.resized();

  1722.     }

  1723. 

  1724.     void errorOccurred (const String& errorMessage)

  1725.     {

  1726.         if (owner.onErrorOccurred != nullptr)

  1727.             owner.onErrorOccurred (errorMessage);

  1728.     }

  1729. 

  1730.     void playbackStarted()

  1731.     {

  1732.         if (owner.onPlaybackStarted != nullptr)

  1733.             owner.onPlaybackStarted();

  1734.     }

  1735. 

  1736.     void playbackStopped()

  1737.     {

  1738.         if (owner.onPlaybackStopped != nullptr)

  1739.             owner.onPlaybackStopped();

  1740.     }

  1741. 

  1742.     //==============================================================================

  1743.     void surfaceChanged (LocalRef<jobject> holder, int /*format*/, int /*width*/, int /*height*/) override

  1744.     {

  1745.         mediaSession.setDisplay (holder);

  1746.     }

  1747. 

  1748.     void surfaceDestroyed (LocalRef<jobject> /*holder*/) override

  1749.     {

  1750.         mediaSession.setDisplay (LocalRef<jobject>());

  1751.     }

  1752. 

  1753.     void surfaceCreated (LocalRef<jobject> /*holder*/) override

  1754.     {

  1755.     }

  1756. 

  1757.     //==============================================================================

  1758.     void onActivityPaused (jobject) override

  1759.     {

  1760.         wasOpen = isOpen();

  1761. 

  1762.         if (! wasOpen)

  1763.             return;

  1764. 

  1765.         JUCE_VIDEO_LOG ("App paused, releasing media player...");

  1766. 

  1767.         mediaSession.storeState();

  1768.         mediaSession.closeVideo();

  1769. 

  1770.        #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1771.         systemVolumeListener.setEnabled (false);

  1772.        #endif

  1773.     }

  1774. 

  1775.     void onActivityResumed (jobject) override

  1776.     {

  1777.         if (! wasOpen)

  1778.             return;

  1779. 

  1780.         JUCE_VIDEO_LOG ("App resumed, restoring media player...");

  1781. 

  1782.         loadAsync (currentURL, [this] (const URL&, Result r)

  1783.                    {

  1784.                        if (r.wasOk())

  1785.                            mediaSession.restoreState();

  1786.                    });

  1787. 

  1788.        #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1789.         systemVolumeListener.setEnabled (true);

  1790.        #endif

  1791.     }

  1792. 

  1793.     //==============================================================================

  1794.    #endif

  1795. 

  1796.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Pimpl)

  1797. };

  1798. 

  1799. //==============================================================================

  1800. constexpr VideoComponent::Pimpl::MediaSession::Player::StateInfo VideoComponent::Pimpl::MediaSession::Player::stateInfos[];