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

1856 lines
84KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2018 - ROLI Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of either:

  8.    a) the GPL v2 (or any later version)

  9.    b) the Affero GPL v3

  10. 

  11.    Details of these licenses can be found at: www.gnu.org/licenses

  12. 

  13.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  14.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  15.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  16. 

  17.    ------------------------------------------------------------------------------

  18. 

  19.    To release a closed-source product which uses JUCE, commercial licenses are

  20.    available: visit www.juce.com for more information.

  21. 

  22.   ==============================================================================

  23. */

  24. 

  25. //==============================================================================

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

  27. //

  28. // native/java/com/roli/juce/MediaControllerCallback.java

  29. // native/java/com/roli/juce/MediaSessionCallback.java

  30. // native/java/com/roli/juce/SystemVolumeObserver.java

  31. //

  32. // files with min sdk version 21

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

  34. static const unsigned char MediaSessionByteCode[] =

  35. {31,139,8,8,235,44,227,91,0,3,77,101,100,105,97,83,101,115,115,105,111,110,46,100,101,120,0,149,152,127,108,28,71,21,199,

  36. 223,236,253,244,157,125,183,119,254,21,55,110,226,52,206,15,151,218,119,36,129,58,57,215,248,7,54,113,56,59,110,206,118,

  37. 131,41,13,107,223,214,222,228,188,123,236,238,185,177,80,69,85,165,82,145,250,7,34,32,85,72,69,65,2,137,72,1,84,250,15,

  38. 63,42,26,9,81,33,129,10,149,42,17,4,130,34,1,165,168,18,63,148,72,21,164,130,239,204,206,158,247,46,14,42,151,124,246,

  39. 189,121,239,205,236,155,55,51,231,219,45,235,23,19,249,163,31,162,82,113,228,219,95,188,252,253,171,127,206,39,23,143,

  40. 254,97,228,234,196,107,173,223,121,242,213,183,126,120,41,67,84,37,162,139,75,199,178,36,63,215,85,162,85,242,236,221,

  41. 224,54,243,228,89,133,40,2,89,9,17,29,134,252,18,36,254,211,27,97,162,249,86,162,99,112,62,22,39,210,64,25,84,128,13,62,

  42. 7,158,6,207,128,23,192,117,240,27,112,11,244,180,16,13,131,243,224,10,248,5,248,15,56,152,32,58,14,230,64,25,60,11,94,4,

  43. 191,2,239,129,222,36,81,30,140,131,18,248,50,120,9,188,6,222,6,239,128,191,131,91,224,95,128,144,95,24,180,128,20,232,0,

  44. 187,192,189,160,15,244,131,33,240,16,208,193,6,184,4,158,7,95,5,87,193,183,192,75,224,85,240,22,136,181,17,61,0,102,193,

  45. 18,48,192,103,193,243,224,26,248,17,248,61,120,27,188,7,98,41,162,46,112,63,120,8,76,131,57,160,129,45,240,121,112,25,

  46. 188,0,94,4,175,128,215,193,31,193,59,224,31,224,93,144,73,35,111,48,0,78,128,105,48,11,74,224,83,224,34,120,50,237,173,

  47. 85,12,160,204,132,146,18,202,70,178,20,132,116,8,67,17,194,8,91,128,248,226,183,131,14,208,9,186,228,218,239,2,61,224,30,

  48. 208,11,246,129,7,64,20,40,114,191,112,61,20,208,219,165,190,79,142,197,63,247,73,253,58,18,218,47,245,159,66,239,151,250,

  49. 47,3,250,141,128,254,38,244,3,82,255,11,244,67,82,191,9,253,160,212,111,7,244,112,124,91,111,13,232,29,208,7,164,222,27,

  50. 176,31,142,123,123,153,235,249,128,125,24,250,253,82,31,131,254,1,169,159,132,62,40,235,51,31,208,207,198,121,61,147,20,

  51. 150,53,61,6,84,41,51,196,104,72,214,153,183,25,254,29,17,245,75,211,89,33,147,244,105,89,195,163,196,215,77,21,181,141,

  52. 193,162,136,181,243,100,18,215,115,98,252,176,104,167,17,113,92,200,40,157,16,50,78,5,233,31,17,178,141,166,132,108,165,

  53. 25,33,83,52,43,100,150,230,132,12,209,195,34,79,111,60,46,71,165,252,136,144,45,52,38,100,132,198,165,125,66,200,16,125,

  54. 76,200,78,58,41,219,167,164,252,184,144,25,42,202,246,105,217,111,94,182,207,72,89,146,246,5,217,94,20,245,73,136,60,50,

  55. 176,79,10,217,65,211,66,182,211,178,216,87,93,244,168,172,47,35,111,111,243,207,30,240,77,52,6,84,175,173,74,127,139,244,

  56. 239,149,242,19,210,159,145,254,136,180,247,73,249,13,233,231,190,30,232,97,228,197,245,75,105,111,95,87,213,8,218,203,89,

  57. 134,58,242,138,241,181,126,78,250,74,125,140,170,99,45,164,124,112,219,119,185,193,151,104,240,125,165,193,151,20,62,69,

  58. 158,168,175,165,189,28,82,98,79,48,177,47,174,5,227,243,173,164,176,84,61,191,239,214,243,139,138,252,20,244,100,194,67,

  59. 244,131,134,177,188,241,95,73,123,103,55,171,166,235,227,255,164,62,190,130,241,219,197,248,190,239,103,13,190,14,225,

  60. 139,192,195,235,247,122,208,183,208,41,230,225,223,251,215,129,123,71,101,252,239,252,248,60,226,23,187,40,52,190,29,255,

  61. 167,64,188,111,251,107,67,254,222,183,204,223,118,168,207,173,134,28,187,69,142,81,185,175,255,157,246,246,66,150,170,

  62. 125,220,242,201,253,33,90,238,15,139,254,17,57,106,68,245,190,3,77,53,134,94,173,116,15,203,147,217,119,8,123,41,65,195,

  63. 216,105,37,244,172,230,251,229,220,189,53,76,169,222,119,220,112,184,157,22,242,33,244,229,217,181,66,134,132,92,65,146,

  64. 217,172,57,198,72,61,146,218,49,194,68,182,121,58,252,79,170,127,24,109,239,97,254,247,212,111,43,13,50,42,101,92,202,

  65. 132,172,76,187,248,110,87,228,56,254,30,103,228,213,134,145,247,183,128,145,247,183,128,247,73,226,76,249,49,109,178,47,

  66. 31,133,183,59,164,189,75,218,187,16,205,219,97,105,111,39,118,152,216,8,69,71,12,211,112,71,41,60,90,24,88,162,228,228,

  67. 233,185,133,169,185,133,115,139,103,102,136,157,34,86,164,174,162,102,150,109,203,40,231,180,106,53,55,190,234,26,155,

  68. 134,187,85,160,125,117,251,170,101,186,186,233,230,38,61,121,70,119,172,202,166,110,23,168,103,231,144,139,110,129,118,

  69. 221,225,154,17,162,64,247,213,61,101,205,213,86,52,71,247,7,62,189,226,232,182,24,248,222,122,204,134,94,54,180,220,44,

  70. 191,206,234,174,198,187,20,40,223,228,118,116,199,49,44,211,11,227,131,217,86,165,162,219,253,147,90,165,178,162,173,94,

  71. 40,208,177,247,217,99,190,162,109,241,30,51,230,227,86,129,6,255,87,175,146,215,8,220,100,232,253,132,63,92,211,107,250,

  72. 140,171,111,20,232,192,93,226,253,36,74,174,230,234,5,202,212,195,76,221,205,45,218,70,129,218,235,38,203,201,77,212,204,

  73. 114,5,113,29,65,227,73,141,27,237,96,185,171,182,181,105,148,117,59,87,210,93,215,48,215,156,254,210,150,35,18,57,84,92,

  74. 181,54,114,40,129,145,59,95,91,213,155,171,178,61,195,254,157,2,229,204,238,30,229,221,102,201,170,212,54,244,224,26,151,

  75. 181,202,166,113,33,167,153,166,133,153,242,153,151,140,53,83,115,107,54,102,147,45,158,215,54,181,92,69,51,215,114,37,

  76. 215,70,190,5,74,123,182,154,107,84,114,69,195,113,73,109,50,20,104,172,201,50,242,255,173,201,104,129,122,239,50,251,33,

  77. 62,48,245,236,52,101,233,218,105,158,158,139,45,145,178,116,138,66,75,167,196,165,72,97,92,138,176,21,209,44,114,91,145,

  78. 219,138,203,220,182,140,38,20,182,76,10,68,92,147,39,146,218,124,109,193,90,116,116,58,40,15,214,137,28,38,229,45,104,

  79. 206,17,25,228,54,69,10,231,54,106,142,177,74,81,156,71,91,115,168,115,77,119,199,171,213,138,177,42,106,45,79,42,101,97,

  80. 110,58,216,20,94,183,80,220,22,126,245,238,165,24,101,10,27,56,19,148,17,101,156,168,185,174,101,122,39,154,246,110,52,

  81. 22,108,188,86,54,44,126,128,38,215,177,120,122,153,246,52,5,248,7,217,247,239,111,242,55,236,127,63,168,249,46,114,9,62,

  82. 170,59,48,108,33,32,38,2,102,202,50,69,233,159,215,106,200,95,109,48,97,120,218,221,108,153,182,173,141,89,57,66,54,232,

  83. 44,233,250,133,5,171,113,136,146,107,85,101,70,190,37,176,246,126,202,241,13,57,81,202,90,230,29,85,137,99,13,132,74,109,

  84. 150,57,173,57,238,180,101,63,161,217,101,30,60,187,93,228,169,77,94,227,12,183,53,86,45,230,79,46,42,167,148,185,115,34,

  85. 93,158,233,142,98,166,44,83,236,249,64,46,103,244,39,12,83,104,114,194,89,174,53,213,184,21,182,11,70,117,193,154,227,91,

  86. 71,245,91,243,182,190,105,88,53,135,167,224,89,234,39,138,103,39,170,21,170,90,14,69,62,195,237,212,109,235,107,56,155,

  87. 56,91,141,95,252,148,112,244,202,227,178,42,208,221,41,83,91,169,224,190,105,103,221,170,85,202,19,186,111,72,56,174,102,

  88. 187,206,35,134,187,78,17,135,79,141,194,238,186,225,80,220,181,188,111,11,234,169,153,119,187,77,168,102,27,20,217,212,

  89. 42,200,37,203,62,28,75,141,12,82,15,27,142,165,150,105,47,155,226,226,0,123,140,139,1,70,97,118,182,115,15,30,14,135,136,

  90. 27,58,100,244,131,252,121,113,132,29,199,117,183,112,236,19,215,67,202,232,17,46,199,184,123,144,61,194,245,73,174,79,

  91. 243,203,12,123,16,215,163,34,50,165,228,49,82,113,112,144,246,42,203,43,177,212,143,151,169,139,61,26,75,13,50,53,211,75,

  92. 74,150,173,244,70,186,169,123,119,55,235,86,187,241,59,42,18,97,74,252,169,167,194,47,39,216,211,10,5,105,99,55,18,140,

  93. 221,4,95,72,50,118,13,92,199,47,129,104,82,81,178,136,255,109,178,57,158,179,139,189,139,184,231,90,25,187,2,94,6,55,192,

  94. 77,240,108,27,99,95,7,223,3,63,7,111,182,145,162,40,33,133,41,251,49,218,237,54,222,251,0,187,146,98,244,70,138,212,166,

  95. 223,69,92,250,239,38,248,111,18,255,253,68,136,182,223,81,132,105,251,61,5,151,254,187,10,255,57,149,191,175,8,169,222,

  96. 88,226,55,86,159,247,108,55,2,61,218,231,217,249,243,4,83,189,103,89,254,204,170,244,121,247,229,239,55,66,50,158,63,23,

  97. 132,251,182,159,23,248,131,4,31,95,60,135,200,241,249,187,148,255,2,145,38,223,176,132,17,0,0};

  98. 

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

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

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

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

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

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

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

  106. 

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

  108. #undef JNI_CLASS_MEMBERS

  109. 

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

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

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

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

  114. 

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

  116. #undef JNI_CLASS_MEMBERS

  117. 

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

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

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

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

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

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

  124. 

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

  126. #undef JNI_CLASS_MEMBERS

  127. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  153. 

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

  155. #undef JNI_CLASS_MEMBERS

  156. 

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

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

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

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

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

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

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

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

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

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

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

  168. 

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

  170. #undef JNI_CLASS_MEMBERS

  171. 

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

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

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

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

  176. 

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

  178. #undef JNI_CLASS_MEMBERS

  179. 

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

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

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

  183. 

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

  185. #undef JNI_CLASS_MEMBERS

  186. 

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

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

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

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

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

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

  193. 

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

  195. #undef JNI_CLASS_MEMBERS

  196. 

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

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

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

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

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

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

  203. 

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

  205. #undef JNI_CLASS_MEMBERS

  206. 

  207. //==============================================================================

  208. class MediaPlayerListener  : public AndroidInterfaceImplementer

  209. {

  210. public:

  211.     struct Owner

  212.     {

  213.         virtual ~Owner() {}

  214. 

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

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

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

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

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

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

  221.     };

  222. 

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

  224. 

  225. private:

  226.     Owner& owner;

  227. 

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

  229.     {

  230.         auto* env = getEnv();

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

  232. 

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

  234. 

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

  236.         {

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

  238. 

  239.             owner.onPrepared (mediaPlayer);

  240.             return nullptr;

  241.         }

  242. 

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

  244.         {

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

  246. 

  247.             owner.onCompletion (mediaPlayer);

  248.             return nullptr;

  249.         }

  250. 

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

  252.         {

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

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

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

  256. 

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

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

  259. 

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

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

  262.         }

  263. 

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

  265.         {

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

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

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

  269. 

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

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

  272. 

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

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

  275.         }

  276. 

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

  278.         {

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

  280. 

  281.             owner.onSeekComplete (mediaPlayer);

  282.             return nullptr;

  283.         }

  284. 

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

  286.         {

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

  288. 

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

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

  291. 

  292.             owner.onBufferingUpdate (mediaPlayer, progressInt);

  293. 

  294.             return nullptr;

  295.         }

  296. 

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

  298.     }

  299. };

  300. 

  301. //==============================================================================

  302. class AudioManagerOnAudioFocusChangeListener  : public AndroidInterfaceImplementer

  303. {

  304. public:

  305.     struct Owner

  306.     {

  307.         virtual ~Owner() {}

  308. 

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

  310.     };

  311. 

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

  313. 

  314. private:

  315.     Owner& owner;

  316. 

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

  318.     {

  319.         auto* env = getEnv();

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

  321. 

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

  323. 

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

  325.         {

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

  327. 

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

  329. 

  330.             owner.onAudioFocusChange (changeTypeInt);

  331.             return nullptr;

  332.         }

  333. 

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

  335.     }

  336. };

  337. 

  338. //==============================================================================

  339. struct VideoComponent::Pimpl

  340.     : public AndroidViewComponent, private ActivityLifecycleCallbacks, private SurfaceHolderCallback

  341. {

  342.     Pimpl (VideoComponent& ownerToUse, bool)

  343.         : owner (ownerToUse),

  344.           mediaSession (*this)

  345.        #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  346.         , systemVolumeListener (*this)

  347.        #endif

  348.     {

  349.         // Video requires SDK version 21 or higher

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

  351. 

  352.         setVisible (true);

  353. 

  354.         auto* env = getEnv();

  355. 

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

  357. 

  358.         if (appContext != nullptr)

  359.         {

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

  361. 

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

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

  364.         }

  365. 

  366.         {

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

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

  369. 

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

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

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

  373. 

  374.             setView (surfaceView.get());

  375.         }

  376.     }

  377. 

  378.     ~Pimpl()

  379.     {

  380.         auto* env = getEnv();

  381. 

  382.         if (surfaceHolderCallback != nullptr)

  383.         {

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

  385. 

  386.             if (view != nullptr)

  387.             {

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

  389. 

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

  391.                 SurfaceHolderCallback::clear();

  392.                 surfaceHolderCallback.clear();

  393.             }

  394.         }

  395. 

  396.         if (activityLifeListener != nullptr)

  397.         {

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

  399.             ActivityLifecycleCallbacks::clear();

  400.             activityLifeListener.clear();

  401.         }

  402.     }

  403. 

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

  405.     {

  406.         close();

  407.         wasOpen = false;

  408. 

  409.         if (url.isEmpty())

  410.         {

  411.             jassertfalse;

  412.             return;

  413.         }

  414. 

  415.         if (! url.isLocalFile())

  416.         {

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

  418.             {

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

  420.                 // Android Manifest.

  421.                 jassertfalse;

  422.                 return;

  423.             }

  424.         }

  425. 

  426.         currentURL = url;

  427. 

  428.         jassert (callback != nullptr);

  429. 

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

  431. 

  432.         static constexpr jint visible = 0;

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

  434. 

  435.         mediaSession.load (url);

  436.     }

  437. 

  438.     void close()

  439.     {

  440.         if (! isOpen())

  441.             return;

  442. 

  443.         mediaSession.closeVideo();

  444. 

  445.         static constexpr jint invisible = 4;

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

  447.     }

  448. 

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

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

  451. 

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

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

  454. 

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

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

  457. 

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

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

  460. 

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

  462. 

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

  464. 

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

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

  467. 

  468.     File currentFile;

  469.     URL currentURL;

  470. 

  471. private:

  472.     //==============================================================================

  473.     class MediaSession  : private AudioManagerOnAudioFocusChangeListener::Owner

  474.     {

  475.     public:

  476.         MediaSession (Pimpl& ownerToUse)

  477.             : owner (ownerToUse),

  478.               sdkVersion (getAndroidSDKVersion()),

  479.               audioAttributes (getAudioAttributes()),

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

  481.                                                                           AndroidMediaSession.constructor,

  482.                                                                           getAppContext().get(),

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

  484.               mediaSessionCallback (createCallbackObject()),

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

  486.                                                                             AndroidPlaybackStateBuilder.constructor))),

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

  488.                                                                                 AndroidMediaSession.getController))),

  489.               player (*this),

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

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

  492.               audioFocusChangeListener (*this),

  493.               nativeAudioFocusChangeListener (GlobalRef (CreateJavaInterface (&audioFocusChangeListener,

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

  495.               audioFocusRequest (createAudioFocusRequestIfNecessary (sdkVersion, audioAttributes,

  496.                                                                      nativeAudioFocusChangeListener))

  497.         {

  498.             auto* env = getEnv();

  499. 

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

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

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

  503.         }

  504. 

  505.         ~MediaSession()

  506.         {

  507.             auto* env = getEnv();

  508. 

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

  510. 

  511.             controller.stop();

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

  513.         }

  514. 

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

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

  517. 

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

  519. 

  520.         void closeVideo()

  521.         {

  522.             resetState();

  523.             controller.closeVideo();

  524.         }

  525. 

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

  527. 

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

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

  530. 

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

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

  533. 

  534.         void setSpeed (double newSpeed)

  535.         {

  536.             playSpeedMult = newSpeed;

  537. 

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

  539.             if (player.isPlaying())

  540.             {

  541.                 player.setPlaySpeed (playSpeedMult);

  542.                 updatePlaybackState();

  543.             }

  544.         }

  545. 

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

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

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

  549. 

  550.         void setVolume (float newVolume)

  551.         {

  552.            #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  553.             controller.setVolume (newVolume);

  554.            #else

  555.             player.setAudioVolume (newVolume);

  556.            #endif

  557.         }

  558. 

  559.         float getVolume() const

  560.         {

  561.            #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  562.             return controller.getVolume();

  563.            #else

  564.             return player.getAudioVolume();

  565.            #endif

  566.         }

  567. 

  568.         void storeState()

  569.         {

  570.             storedPlaybackState.clear();

  571.             storedPlaybackState = GlobalRef (getCurrentPlaybackState());

  572.         }

  573. 

  574.         void restoreState()

  575.         {

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

  577.                 return;

  578. 

  579.             auto* env = getEnv();

  580. 

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

  582.             setPosition (pos / 1000.0);

  583. 

  584.             setSpeed (playSpeedMult);

  585. 

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

  587. 

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

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

  590.             {

  591.                 play();

  592.             }

  593.         }

  594. 

  595.     private:

  596.         struct PlaybackState

  597.         {

  598.             enum

  599.             {

  600.                 STATE_NONE = 0,

  601.                 STATE_STOPPED = 1,

  602.                 STATE_PAUSED = 2,

  603.                 STATE_PLAYING = 3,

  604.                 STATE_FAST_FORWARDING = 4,

  605.                 STATE_REWINDING = 5,

  606.                 STATE_BUFFERING = 6,

  607.                 STATE_ERROR = 7,

  608.                 STATE_CONNECTING = 8,

  609.                 STATE_SKIPPING_TO_PREVIOUS = 9,

  610.                 STATE_SKIPPING_TO_NEXT = 10,

  611.                 STATE_SKIPPING_TO_QUEUE_ITEM = 11,

  612.             };

  613. 

  614.             enum

  615.             {

  616.                 ACTION_PAUSE              = 0x2,

  617.                 ACTION_PLAY               = 0x4,

  618.                 ACTION_PLAY_FROM_MEDIA_ID = 0x8000,

  619.                 ACTION_PLAY_PAUSE         = 0x200,

  620.                 ACTION_SEEK_TO            = 0x100,

  621.                 ACTION_STOP               = 0x1,

  622.             };

  623.         };

  624. 

  625.         //==============================================================================

  626.         class Controller

  627.         {

  628.         public:

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

  630.                 : owner (ownerToUse),

  631.                   nativeController (GlobalRef (nativeControllerToUse)),

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

  633.                                                                                               AndroidMediaController.getTransportControls))),

  634.                   controllerCallback (createControllerCallbacks())

  635.             {

  636.                 auto* env = getEnv();

  637. 

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

  639.             }

  640. 

  641.             ~Controller()

  642.             {

  643.                 auto* env = getEnv();

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

  645.             }

  646. 

  647.             void load (const URL& url)

  648.             {

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

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

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

  652.             }

  653. 

  654.             void closeVideo()

  655.             {

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

  657.             }

  658. 

  659.             void play()

  660.             {

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

  662.             }

  663. 

  664.             void stop()

  665.             {

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

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

  668.             }

  669. 

  670.             void setPosition (double newPosition)

  671.             {

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

  673. 

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

  675.             }

  676. 

  677.             double getPosition() const

  678.             {

  679.                 auto* env = getEnv();

  680. 

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

  682. 

  683.                 if (playbackState != nullptr)

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

  685. 

  686.                 return 0.0;

  687.             }

  688. 

  689.             double getPlaySpeed() const

  690.             {

  691.                 auto* env = getEnv();

  692. 

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

  694. 

  695.                 if (playbackState != nullptr)

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

  697. 

  698.                 return 1.0;

  699.             }

  700. 

  701.             void setVolume (float newVolume)

  702.             {

  703.                 auto* env = getEnv();

  704. 

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

  706. 

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

  708. 

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

  710. 

  711.                 static constexpr jint flagShowUI = 1;

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

  713.             }

  714. 

  715.             float getVolume() const

  716.             {

  717.                 auto* env = getEnv();

  718. 

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

  720. 

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

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

  723. 

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

  725.             }

  726. 

  727.         private:

  728.             MediaSession& owner;

  729. 

  730.             GlobalRef nativeController;

  731.             GlobalRef controllerTransportControls;

  732.             GlobalRef controllerCallback;

  733.             bool wasPlaying = false;

  734.             bool wasPaused = true;

  735. 

  736.             //==============================================================================

  737.             void stateChanged (jobject playbackState)

  738.             {

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

  740. 

  741.                 if (playbackState == nullptr)

  742.                     return;

  743. 

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

  745. 

  746.                 static constexpr jint statePaused  = 2;

  747.                 static constexpr jint statePlaying = 3;

  748. 

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

  750.                     owner.playbackStarted();

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

  752.                     owner.playbackStopped();

  753. 

  754.                 wasPlaying = state == statePlaying;

  755.                 wasPaused  = state == statePaused;

  756.             }

  757. 

  758.             //==============================================================================

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

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

  761.                 CALLBACK (audioInfoChanged,     "mediaControllerAudioInfoChanged",      "(JLandroid/media/session/MediaController$PlaybackInfo;)V") \

  762.                 CALLBACK (metadataChanged,      "mediaControllerMetadataChanged",       "(JLandroid/media/MediaMetadata;)V") \

  763.                 CALLBACK (playbackStateChanged, "mediaControllerPlaybackStateChanged",  "(JLandroid/media/session/PlaybackState;)V") \

  764.                 CALLBACK (sessionDestroyed,     "mediaControllerSessionDestroyed",      "(J)V")

  765. 

  766.             DECLARE_JNI_CLASS_WITH_BYTECODE (AndroidMediaControllerCallback, "com/roli/juce/MediaControllerCallback", 21, MediaSessionByteCode, sizeof(MediaSessionByteCode))

  767.            #undef JNI_CLASS_MEMBERS

  768. 

  769.             LocalRef<jobject> createControllerCallbacks()

  770.             {

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

  772.                                                                AndroidMediaControllerCallback.constructor,

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

  774.             }

  775. 

  776.             //==============================================================================

  777.             // MediaSessionController callbacks

  778.             static void audioInfoChanged (JNIEnv*, jobject, jlong host, jobject playbackInfo)

  779.             {

  780.                 if (auto* myself = reinterpret_cast<VideoComponent::Pimpl::MediaSession::Controller*> (host))

  781.                 {

  782.                     ignoreUnused (playbackInfo);

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

  784.                 }

  785.             }

  786. 

  787.             static void metadataChanged (JNIEnv*, jobject, jlong host, jobject metadata)

  788.             {

  789.                 if (auto* myself = reinterpret_cast<VideoComponent::Pimpl::MediaSession::Controller*> (host))

  790.                 {

  791.                     ignoreUnused (metadata);

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

  793.                 }

  794.             }

  795. 

  796.             static void playbackStateChanged (JNIEnv*, jobject, jlong host, jobject state)

  797.             {

  798.                 if (auto* myself = reinterpret_cast<VideoComponent::Pimpl::MediaSession::Controller*> (host))

  799.                     myself->stateChanged (state);

  800.             }

  801. 

  802.             static void sessionDestroyed (JNIEnv*, jobject, jlong host)

  803.             {

  804.                 if (auto* myself = reinterpret_cast<VideoComponent::Pimpl::MediaSession::Controller*> (host))

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

  806.             }

  807.         };

  808. 

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

  810.         class Player   : private MediaPlayerListener::Owner

  811.         {

  812.         public:

  813.             Player (MediaSession& ownerToUse)

  814.                 : owner (ownerToUse),

  815.                   mediaPlayerListener (*this),

  816.                   nativeMediaPlayerListener (GlobalRef (CreateJavaInterface (&mediaPlayerListener,

  817.                                                                              getNativeMediaPlayerListenerInterfaces())))

  818. 

  819.             {}

  820. 

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

  822.             {

  823.                 if (surfaceHolder == nullptr)

  824.                 {

  825.                     videoSurfaceHolder.clear();

  826. 

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

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

  829. 

  830.                     return;

  831.                 }

  832. 

  833.                 videoSurfaceHolder = GlobalRef (surfaceHolder);

  834. 

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

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

  837.             }

  838. 

  839.             void load (const LocalRef<jstring>& mediaId, const LocalRef<jobject>& extras)

  840.             {

  841.                 ignoreUnused (extras);

  842. 

  843.                 closeVideo();

  844. 

  845.                 auto* env = getEnv();

  846. 

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

  848. 

  849.                 currentState = State::idle;

  850. 

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

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

  853. 

  854.                 if (jniCheckHasExceptionOccurredAndClear())

  855.                 {

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

  857.                     return;

  858.                 }

  859. 

  860.                 currentState = State::initialised;

  861. 

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

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

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

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

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

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

  868. 

  869.                 if (videoSurfaceHolder != nullptr)

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

  871. 

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

  873. 

  874.                 currentState = State::preparing;

  875.             }

  876. 

  877.             void closeVideo()

  878.             {

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

  880.                     return;

  881. 

  882.                 auto* env = getEnv();

  883. 

  884.                 if (getCurrentStateInfo().canCallStop)

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

  886. 

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

  888.                 nativeMediaPlayer.clear();

  889. 

  890.                 currentState = State::end;

  891.             }

  892. 

  893.             bool isVideoOpen() const noexcept

  894.             {

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

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

  897.             }

  898. 

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

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

  901. 

  902.             jlong getVideoDuration() const

  903.             {

  904.                 if (! getCurrentStateInfo().canCallGetVideoDuration)

  905.                     return 0;

  906. 

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

  908.             }

  909. 

  910.             Rectangle<int> getVideoNativeSize() const

  911.             {

  912.                 if (! getCurrentStateInfo().canCallGetVideoHeight)

  913.                 {

  914.                     jassertfalse;

  915.                     return {};

  916.                 }

  917. 

  918.                 auto* env = getEnv();

  919. 

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

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

  922. 

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

  924.             }

  925. 

  926.             void play()

  927.             {

  928.                 if (! getCurrentStateInfo().canCallStart)

  929.                 {

  930.                     jassertfalse;

  931.                     return;

  932.                 }

  933. 

  934.                 auto* env = getEnv();

  935. 

  936.                 // Perform a potentially pending volume setting

  937.                 if (lastAudioVolume != std::numeric_limits<float>::min())

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

  939. 

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

  941. 

  942.                 currentState = State::started;

  943.             }

  944. 

  945.             void pause()

  946.             {

  947.                 if (! getCurrentStateInfo().canCallPause)

  948.                 {

  949.                     jassertfalse;

  950.                     return;

  951.                 }

  952. 

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

  954. 

  955.                 currentState = State::paused;

  956.             }

  957. 

  958.             bool isPlaying() const

  959.             {

  960.                 return getCurrentStateInfo().isPlaying;

  961.             }

  962. 

  963.             void setPlayPosition (jint newPositionMs)

  964.             {

  965.                 if (! getCurrentStateInfo().canCallSeekTo)

  966.                 {

  967.                     jassertfalse;

  968.                     return;

  969.                 }

  970. 

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

  972.             }

  973. 

  974.             jint getPlayPosition() const

  975.             {

  976.                 if (! getCurrentStateInfo().canCallGetCurrentPosition)

  977.                     return 0.0;

  978. 

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

  980.             }

  981. 

  982.             void setPlaySpeed (double newSpeed)

  983.             {

  984.                 if (! getCurrentStateInfo().canCallSetPlaybackParams)

  985.                 {

  986.                     jassertfalse;

  987.                     return;

  988.                 }

  989. 

  990.                 auto* env = getEnv();

  991. 

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

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

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

  995. 

  996.                 if (jniCheckHasExceptionOccurredAndClear())

  997.                 {

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

  999.                     jassertfalse;

  1000.                 }

  1001.             }

  1002. 

  1003.             double getPlaySpeed() const

  1004.             {

  1005.                 if (! getCurrentStateInfo().canCallGetPlaybackParams)

  1006.                     return 0.0;

  1007. 

  1008.                 auto* env = getEnv();

  1009. 

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

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

  1012.             }

  1013. 

  1014.             void setAudioVolume (float newVolume)

  1015.             {

  1016.                 if (! getCurrentStateInfo().canCallSetVolume)

  1017.                 {

  1018.                     jassertfalse;

  1019.                     return;

  1020.                 }

  1021. 

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

  1023. 

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

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

  1026.             }

  1027. 

  1028.             float getAudioVolume() const

  1029.             {

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

  1031.                 return lastAudioVolume;

  1032.             }

  1033. 

  1034.         private:

  1035.             //=============================================================================

  1036.             struct StateInfo

  1037.             {

  1038.                 int playbackStateFlag = 0, allowedActions = 0;

  1039. 

  1040.                 bool isPlaying, canCallGetCurrentPosition, canCallGetVideoDuration,

  1041.                         canCallGetVideoHeight, canCallGetVideoWidth, canCallGetPlaybackParams,

  1042.                         canCallPause, canCallPrepare, canCallSeekTo, canCallSetAudioAttributes,

  1043.                         canCallSetDataSource, canCallSetPlaybackParams, canCallSetVolume,

  1044.                         canCallStart, canCallStop;

  1045.             };

  1046. 

  1047.             enum class State

  1048.             {

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

  1050.             };

  1051. 

  1052.             static constexpr StateInfo stateInfos[] = {

  1053.                 /* idle */

  1054.                 {PlaybackState::STATE_NONE, PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

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

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

  1057.                 /* initialised */

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

  1059.                             false, true, false, true, true, true, false, true, false, true,

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

  1061.                 /* preparing */

  1062.                 {PlaybackState::STATE_BUFFERING, 0,

  1063.                             false, false, false, false, false, true, false, false, false, false,

  1064.                             false,  false, false, false, false},

  1065.                 /* prepared */

  1066.                 {PlaybackState::STATE_PAUSED,

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

  1068.                             false, true, true, true, true, true, false, false, true, true,

  1069.                             false, true, true, true, true},

  1070.                 /* started */

  1071.                 {PlaybackState::STATE_PLAYING,

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

  1073.                             true, true, true, true, true, true, true, false, true, true,

  1074.                             false, true, true, true, true},

  1075.                 /* paused */

  1076.                 {PlaybackState::STATE_PAUSED,

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

  1078.                             false, true, true, true, true, true, true, false, true, true,

  1079.                             false, true, true, true, true},

  1080.                 /* stopped */

  1081.                 {PlaybackState::STATE_STOPPED,

  1082.                             PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1083.                             false, true, true, true, true, true, false, true, false, true,

  1084.                             false, false, true, false, true},

  1085.                 /* complete */

  1086.                 {PlaybackState::STATE_PAUSED,

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

  1088.                             false, true, true, true, true, true, true, false, true, true,

  1089.                             false, true, true, true, true},

  1090.                 /* error */

  1091.                 {PlaybackState::STATE_ERROR,

  1092.                             PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1093.                             false, false, false, false, false, false, false, false, false, false,

  1094.                             false, false, false, false, false},

  1095.                 /* end */

  1096.                 {PlaybackState::STATE_NONE,

  1097.                             PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1098.                             false, false, false, false, false, false, false, false, false, false,

  1099.                             false, false, false, false, false}

  1100.             };

  1101. 

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

  1103. 

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

  1105.             MediaSession& owner;

  1106.             GlobalRef nativeMediaPlayer;

  1107. 

  1108.             MediaPlayerListener mediaPlayerListener;

  1109.             GlobalRef nativeMediaPlayerListener;

  1110. 

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

  1112. 

  1113.             GlobalRef videoSurfaceHolder;

  1114. 

  1115.             State currentState = State::idle;

  1116. 

  1117.             //==============================================================================

  1118.             void onPrepared (LocalRef<jobject>& mediaPlayer) override

  1119.             {

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

  1121. 

  1122.                 ignoreUnused (mediaPlayer);

  1123. 

  1124.                 currentState = State::prepared;

  1125. 

  1126.                 owner.playerPrepared();

  1127.             }

  1128. 

  1129.             void onBufferingUpdate (LocalRef<jobject>& mediaPlayer, int progress) override

  1130.             {

  1131.                 ignoreUnused (mediaPlayer);

  1132. 

  1133.                 owner.playerBufferingUpdated (progress);

  1134.             }

  1135. 

  1136.             void onSeekComplete (LocalRef<jobject>& mediaPlayer) override

  1137.             {

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

  1139. 

  1140.                 ignoreUnused (mediaPlayer);

  1141. 

  1142.                 owner.playerSeekCompleted();

  1143.             }

  1144. 

  1145.             void onCompletion (LocalRef<jobject>& mediaPlayer) override

  1146.             {

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

  1148. 

  1149.                 ignoreUnused (mediaPlayer);

  1150. 

  1151.                 currentState = State::complete;

  1152. 

  1153.                 owner.playerPlaybackCompleted();

  1154.             }

  1155. 

  1156.             enum

  1157.             {

  1158.                 MEDIA_INFO_UNKNOWN               = 1,

  1159.                 MEDIA_INFO_VIDEO_RENDERING_START = 3,

  1160.                 MEDIA_INFO_VIDEO_TRACK_LAGGING   = 700,

  1161.                 MEDIA_INFO_BUFFERING_START       = 701,

  1162.                 MEDIA_INFO_BUFFERING_END         = 702,

  1163.                 MEDIA_INFO_NETWORK_BANDWIDTH     = 703,

  1164.                 MEDIA_INFO_BAD_INTERLEAVING      = 800,

  1165.                 MEDIA_INFO_NOT_SEEKABLE          = 801,

  1166.                 MEDIA_INFO_METADATA_UPDATE       = 802,

  1167.                 MEDIA_INFO_AUDIO_NOT_PLAYING     = 804,

  1168.                 MEDIA_INFO_VIDEO_NOT_PLAYING     = 805,

  1169.                 MEDIA_INFO_UNSUPPORTED_SUBTITE   = 901,

  1170.                 MEDIA_INFO_SUBTITLE_TIMED_OUT    = 902

  1171.             };

  1172. 

  1173.             bool onInfo (LocalRef<jobject>& mediaPlayer, int what, int extra) override

  1174.             {

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

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

  1177. 

  1178.                 ignoreUnused (mediaPlayer, extra);

  1179. 

  1180.                 if (what == MEDIA_INFO_BUFFERING_START)

  1181.                     owner.playerBufferingStarted();

  1182.                 else if (what == MEDIA_INFO_BUFFERING_END)

  1183.                     owner.playerBufferingEnded();

  1184. 

  1185.                 return true;

  1186.             }

  1187. 

  1188.             static String infoCodeToString (int code)

  1189.             {

  1190.                 switch (code)

  1191.                 {

  1192.                     case MEDIA_INFO_UNKNOWN:               return "Unknown";

  1193.                     case MEDIA_INFO_VIDEO_RENDERING_START: return "Rendering start";

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

  1195.                     case MEDIA_INFO_BUFFERING_START:       return "Buffering start";

  1196.                     case MEDIA_INFO_BUFFERING_END:         return "Buffering end";

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

  1198.                     case MEDIA_INFO_BAD_INTERLEAVING:      return "Bad interleaving";

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

  1200.                     case MEDIA_INFO_METADATA_UPDATE:       return "Metadata updated";

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

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

  1203.                     case MEDIA_INFO_UNSUPPORTED_SUBTITE:   return "Unsupported subtitle";

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

  1205.                     default:                               return "";

  1206.                 }

  1207.             }

  1208. 

  1209.             bool onError (LocalRef<jobject>& mediaPlayer, int what, int extra) override

  1210.             {

  1211.                 auto errorMessage = errorCodeToString (what);

  1212.                 auto extraMessage = errorCodeToString (extra);

  1213. 

  1214.                 if (extraMessage.isNotEmpty())

  1215.                     errorMessage << ", " << extraMessage;

  1216. 

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

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

  1219. 

  1220.                 ignoreUnused (mediaPlayer);

  1221. 

  1222.                 currentState = State::error;

  1223. 

  1224.                 owner.errorOccurred (errorMessage);

  1225.                 return true;

  1226.             }

  1227. 

  1228.             static String errorCodeToString (int code)

  1229.             {

  1230.                 enum

  1231.                 {

  1232.                     MEDIA_ERROR_UNSUPPORTED                        = -1010,

  1233.                     MEDIA_ERROR_MALFORMED                          = -1007,

  1234.                     MEDIA_ERROR_IO                                 = -1004,

  1235.                     MEDIA_ERROR_TIMED_OUT                          = -110,

  1236.                     MEDIA_ERROR_UNKNOWN                            = 1,

  1237.                     MEDIA_ERROR_SERVER_DIED                        = 100,

  1238.                     MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200

  1239.                 };

  1240. 

  1241.                 switch (code)

  1242.                 {

  1243.                     case MEDIA_ERROR_UNSUPPORTED:                        return "Unsupported bitstream";

  1244.                     case MEDIA_ERROR_MALFORMED:                          return "Malformed bitstream";

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

  1246.                     case MEDIA_ERROR_TIMED_OUT:                          return "Timed out";

  1247.                     case MEDIA_ERROR_UNKNOWN:                            return "Unknown error";

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

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

  1250.                     default:                                             return "";

  1251.                 }

  1252.             }

  1253. 

  1254.             //==============================================================================

  1255.             static StringArray getNativeMediaPlayerListenerInterfaces()

  1256.             {

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

  1258. 

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

  1260.                          IFPREFIX "OnInfoListener", IFPREFIX "OnPreparedListener",

  1261.                          IFPREFIX "OnBufferingUpdateListener", IFPREFIX "OnSeekCompleteListener"

  1262.                 };

  1263. 

  1264.                 #undef IFPREFIX

  1265.             }

  1266.         };

  1267. 

  1268.         //==============================================================================

  1269.         Pimpl& owner;

  1270.         int sdkVersion;

  1271. 

  1272.         GlobalRef audioAttributes;

  1273.         GlobalRef nativeMediaSession;

  1274.         GlobalRef mediaSessionCallback;

  1275.         GlobalRef playbackStateBuilder;

  1276. 

  1277.         Controller controller;

  1278.         Player player;

  1279. 

  1280.         GlobalRef audioManager;

  1281.         AudioManagerOnAudioFocusChangeListener audioFocusChangeListener;

  1282.         GlobalRef nativeAudioFocusChangeListener;

  1283.         GlobalRef audioFocusRequest;

  1284. 

  1285.         GlobalRef storedPlaybackState;

  1286. 

  1287.         bool pendingSeekRequest = false;

  1288. 

  1289.         bool playerBufferingInProgress = false;

  1290.         bool usesBuffering = false;

  1291.         SparseSet<int> bufferedRegions;

  1292. 

  1293.         double playSpeedMult = 1.0;

  1294.         bool hasAudioFocus = false;

  1295. 

  1296.         //==============================================================================

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

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

  1299.             CALLBACK (pauseCallback,           "mediaSessionPause",           "(J)V") \

  1300.             CALLBACK (playCallback,            "mediaSessionPlay",            "(J)V") \

  1301.             CALLBACK (playFromMediaIdCallback, "mediaSessionPlayFromMediaId", "(JLjava/lang/String;Landroid/os/Bundle;)V") \

  1302.             CALLBACK (seekToCallback,          "mediaSessionSeekTo",          "(JJ)V") \

  1303.             CALLBACK (stopCallback,            "mediaSessionStop",            "(J)V")

  1304. 

  1305.         DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidMediaSessionCallback, "com/roli/juce/MediaSessionCallback", 21)

  1306.         #undef JNI_CLASS_MEMBERS

  1307. 

  1308.         LocalRef<jobject> createCallbackObject()

  1309.         {

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

  1311.                                                            AndroidMediaSessionCallback.constructor,

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

  1313.         }

  1314. 

  1315.         //==============================================================================

  1316.         // MediaSession callbacks

  1317.         static void pauseCallback (JNIEnv*, jobject, jlong host)

  1318.         {

  1319.             if (auto* myself = reinterpret_cast<VideoComponent::Pimpl::MediaSession*> (host))

  1320.             {

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

  1322.                 myself->player.pause();

  1323.                 myself->updatePlaybackState();

  1324. 

  1325.                 myself->abandonAudioFocus();

  1326.             }

  1327.         }

  1328. 

  1329.         static void playCallback (JNIEnv*, jobject, jlong host)

  1330.         {

  1331.             if (auto* myself = reinterpret_cast<VideoComponent::Pimpl::MediaSession*> (host))

  1332.             {

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

  1334. 

  1335.                 myself->requestAudioFocus();

  1336. 

  1337.                 if (! myself->hasAudioFocus)

  1338.                 {

  1339.                     myself->errorOccurred ("Application has been denied audio focus. Try again later.");

  1340.                     return;

  1341.                 }

  1342. 

  1343.                 getEnv()->CallVoidMethod (myself->nativeMediaSession, AndroidMediaSession.setActive, true);

  1344. 

  1345.                 myself->player.play();

  1346.                 myself->setSpeed (myself->playSpeedMult);

  1347.                 myself->updatePlaybackState();

  1348.             }

  1349.         }

  1350. 

  1351.         static void playFromMediaIdCallback (JNIEnv* env, jobject, jlong host, jstring mediaId, jobject extras)

  1352.         {

  1353.             if (auto* myself = reinterpret_cast<VideoComponent::Pimpl::MediaSession*> (host))

  1354.             {

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

  1356. 

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

  1358.                 myself->updatePlaybackState();

  1359.             }

  1360.         }

  1361. 

  1362.         static void seekToCallback (JNIEnv* /*env*/, jobject, jlong host, jlong pos)

  1363.         {

  1364.             if (auto* myself = reinterpret_cast<VideoComponent::Pimpl::MediaSession*> (host))

  1365.             {

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

  1367. 

  1368.                 myself->pendingSeekRequest = true;

  1369.                 myself->player.setPlayPosition ((jint) pos);

  1370.                 myself->updatePlaybackState();

  1371.             }

  1372.         }

  1373. 

  1374.         static void stopCallback(JNIEnv* env, jobject, jlong host)

  1375.         {

  1376.             if (auto* myself = reinterpret_cast<VideoComponent::Pimpl::MediaSession*> (host))

  1377.             {

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

  1379. 

  1380.                 env->CallVoidMethod (myself->nativeMediaSession, AndroidMediaSession.setActive, false);

  1381. 

  1382.                 myself->player.closeVideo();

  1383.                 myself->updatePlaybackState();

  1384. 

  1385.                 myself->abandonAudioFocus();

  1386. 

  1387.                 myself->owner.closeVideoFinished();

  1388.             }

  1389.         }

  1390. 

  1391.         //==============================================================================

  1392.         bool isSeekInProgress() const noexcept

  1393.         {

  1394.             if (pendingSeekRequest)

  1395.                 return true;

  1396. 

  1397.             if (! usesBuffering)

  1398.                 return false;

  1399. 

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

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

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

  1403.             if (playerBufferingInProgress)

  1404.                 return true;

  1405. 

  1406.             auto playPos = player.getPlayPosition();

  1407.             auto durationMs = player.getVideoDuration();

  1408.             int playPosPercent = 100 * playPos / static_cast<double> (durationMs);

  1409. 

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

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

  1412.         }

  1413. 

  1414.         void updatePlaybackState()

  1415.         {

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

  1417.         }

  1418. 

  1419.         LocalRef<jobject> getCurrentPlaybackState()

  1420.         {

  1421.             static constexpr int bufferingState = 6;

  1422. 

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

  1424.             auto playPos = player.getPlayPosition();

  1425.             auto playSpeed = player.getPlaySpeed();

  1426.             auto allowedActions = player.getAllowedActions();

  1427. 

  1428.             auto* env = getEnv();

  1429. 

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

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

  1432. 

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

  1434. 

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

  1436.         }

  1437. 

  1438.         //==============================================================================

  1439.         void playerPrepared()

  1440.         {

  1441.             resetState();

  1442. 

  1443.             updateMetadata();

  1444. 

  1445.             owner.loadFinished();

  1446.         }

  1447. 

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

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

  1450. 

  1451.         void playerBufferingUpdated (int progress)

  1452.         {

  1453.             usesBuffering = true;

  1454. 

  1455.             updatePlaybackState();

  1456. 

  1457.             auto playPos = player.getPlayPosition();

  1458.             auto durationMs = player.getVideoDuration();

  1459.             int playPosPercent = 100 * playPos / static_cast<double> (durationMs);

  1460. 

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

  1462. 

  1463.             String ranges;

  1464. 

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

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

  1467. 

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

  1469.         }

  1470. 

  1471.         void playerSeekCompleted()

  1472.         {

  1473.             pendingSeekRequest = false;

  1474.             updatePlaybackState();

  1475.         }

  1476. 

  1477.         void playerPlaybackCompleted()

  1478.         {

  1479.             player.pause();

  1480.             abandonAudioFocus();

  1481. 

  1482.             pendingSeekRequest = true;

  1483.             player.setPlayPosition (0);

  1484.             updatePlaybackState();

  1485.         }

  1486. 

  1487.         void updateMetadata()

  1488.         {

  1489.             auto* env = getEnv();

  1490. 

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

  1492.                                                                       AndroidMediaMetadataBuilder.constructor));

  1493. 

  1494.             auto durationMs = player.getVideoDuration();

  1495. 

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

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

  1498.                                                       AndroidMediaMetadataBuilder.putLong,

  1499.                                                       jDurationKey.get(),

  1500.                                                       (jlong) durationMs));

  1501. 

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

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

  1504.                                                       AndroidMediaMetadataBuilder.putLong,

  1505.                                                       jNumTracksKey.get(),

  1506.                                                       (jlong) 1));

  1507. 

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

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

  1510.         }

  1511. 

  1512.         void errorOccurred (const String& errorMessage)

  1513.         {

  1514.             auto* env = getEnv();

  1515. 

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

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

  1518.                                                       javaString (errorMessage).get()));

  1519. 

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

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

  1522. 

  1523.             // ...also notify JUCE side client

  1524.             owner.errorOccurred (errorMessage);

  1525.         }

  1526. 

  1527.         //==============================================================================

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

  1529.                                                                      const GlobalRef& nativeAudioFocusChangeListener)

  1530.         {

  1531.             if (sdkVersion < 26)

  1532.                 return LocalRef<jobject>();

  1533. 

  1534.             auto* env = getEnv();

  1535. 

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

  1537. 

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

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

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

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

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

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

  1544. 

  1545.             static constexpr jint audioFocusGain = 1;

  1546. 

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

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

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

  1550. 

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

  1552.         }

  1553. 

  1554.         void requestAudioFocus()

  1555.         {

  1556.             static constexpr jint audioFocusGain = 1;

  1557.             static constexpr jint streamMusic = 3;

  1558.             static constexpr jint audioFocusRequestGranted = 1;

  1559. 

  1560.             jint result = audioFocusRequestGranted;

  1561. 

  1562.             if (sdkVersion >= 26)

  1563.             {

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

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

  1566. 

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

  1568.             }

  1569.             else

  1570.             {

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

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

  1573.             }

  1574. 

  1575.             hasAudioFocus = result == audioFocusRequestGranted;

  1576.         }

  1577. 

  1578.         void abandonAudioFocus()

  1579.         {

  1580.             if (! hasAudioFocus)

  1581.                 return;

  1582. 

  1583.             static constexpr jint audioFocusRequestGranted = 1;

  1584. 

  1585.             jint result = audioFocusRequestGranted;

  1586. 

  1587.             if (sdkVersion >= 26)

  1588.             {

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

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

  1591. 

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

  1593.             }

  1594.             else

  1595.             {

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

  1597.                                                    nativeAudioFocusChangeListener.get());

  1598.             }

  1599. 

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

  1601.             hasAudioFocus = result != audioFocusRequestGranted;

  1602.         }

  1603. 

  1604.         void onAudioFocusChange (int changeType) override

  1605.         {

  1606.             static constexpr jint audioFocusGain = 1;

  1607. 

  1608.             if (changeType == audioFocusGain)

  1609.                 JUCE_VIDEO_LOG ("Audio focus gained");

  1610.             else

  1611.                 JUCE_VIDEO_LOG ("Audio focus lost");

  1612. 

  1613.             if (changeType != audioFocusGain)

  1614.             {

  1615.                 if (isPlaying())

  1616.                 {

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

  1618.                     stop();

  1619.                 }

  1620. 

  1621.                 abandonAudioFocus();

  1622.             }

  1623.         }

  1624. 

  1625.         //==============================================================================

  1626.         void playbackStarted()

  1627.         {

  1628.             owner.playbackStarted();

  1629.         }

  1630. 

  1631.         void playbackStopped()

  1632.         {

  1633.             owner.playbackStopped();

  1634.         }

  1635. 

  1636.         //==============================================================================

  1637.         void resetState()

  1638.         {

  1639.             usesBuffering = false;

  1640.             bufferedRegions.clear();

  1641.             playerBufferingInProgress = false;

  1642. 

  1643.             pendingSeekRequest = false;

  1644. 

  1645.             playSpeedMult = 1.0;

  1646.             hasAudioFocus = false;

  1647.         }

  1648. 

  1649.         //==============================================================================

  1650.         static LocalRef<jobject> getAudioAttributes()

  1651.         {

  1652.             // Video requires SDK version 21 or higher

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

  1654. 

  1655.             auto* env = getEnv();

  1656. 

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

  1658.                                                                           AndroidAudioAttributesBuilder.constructor));

  1659.             static constexpr jint contentTypeMovie = 3;

  1660.             static constexpr jint usageMedia = 1;

  1661. 

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

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

  1664. 

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

  1666.         }

  1667.     };

  1668. 

  1669.    #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

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

  1671.     class SystemVolumeListener

  1672.     {

  1673.     public:

  1674.         SystemVolumeListener (Pimpl& ownerToUse)

  1675.             : owner (ownerToUse),

  1676.               nativeObserver (createCallbackObject())

  1677.         {

  1678.             setEnabled (true);

  1679.         }

  1680. 

  1681.         ~SystemVolumeListener()

  1682.         {

  1683.             setEnabled (false);

  1684.         }

  1685.     private:

  1686.         Pimpl& owner;

  1687.         GlobalRef nativeObserver;

  1688. 

  1689.         //==============================================================================

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

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

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

  1693.             CALLBACK (systemVolumeChangedCallback, "mediaSessionSystemVolumeChanged", "(J)V")

  1694. 

  1695.         DECLARE_JNI_CLASS_WITH_MIN_SDK (SystemVolumeObserver, "com/roli/juce/SystemVolumeObserver", 21)

  1696.         #undef JNI_CLASS_MEMBERS

  1697. 

  1698. 

  1699.         LocalRef<jobject> createCallbackObject()

  1700.         {

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

  1702.                                                            SystemVolumeObserver.constructor,

  1703.                                                            getCurrentActivity().get(),

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

  1705.         }

  1706.     public:

  1707.         void setEnabled (bool shouldBeEnabled)

  1708.         {

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

  1710. 

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

  1712.             if (shouldBeEnabled)

  1713.                 systemVolumeChanged();

  1714.         }

  1715. 

  1716.     private:

  1717.         //==============================================================================

  1718.         void systemVolumeChanged()

  1719.         {

  1720.             WeakReference<SystemVolumeListener> weakThis (this);

  1721. 

  1722.             MessageManager::callAsync ([weakThis]() mutable

  1723.                                        {

  1724.                                            if (weakThis == nullptr)

  1725.                                                return;

  1726. 

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

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

  1729.                                        });

  1730. 

  1731.         }

  1732. 

  1733.         //==============================================================================

  1734.         static void systemVolumeChangedCallback (JNIEnv*, jobject, jlong host)

  1735.         {

  1736.             if (auto* myself = reinterpret_cast<VideoComponent::Pimpl::SystemVolumeListener*> (host))

  1737.                 myself->systemVolumeChanged();

  1738.         }

  1739. 

  1740.         JUCE_DECLARE_WEAK_REFERENCEABLE (SystemVolumeListener)

  1741.     };

  1742. 

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

  1744.     VideoComponent& owner;

  1745. 

  1746.     MediaSession mediaSession;

  1747.     GlobalRef activityLifeListener;

  1748.    #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1749.     SystemVolumeListener systemVolumeListener;

  1750.    #endif

  1751.     GlobalRef surfaceHolderCallback;

  1752. 

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

  1754. 

  1755.     bool wasOpen = false;

  1756. 

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

  1758.     void loadFinished()

  1759.     {

  1760.         owner.resized();

  1761. 

  1762.         if (loadFinishedCallback != nullptr)

  1763.         {

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

  1765.             loadFinishedCallback = nullptr;

  1766.         }

  1767.     }

  1768. 

  1769.     void closeVideoFinished()

  1770.     {

  1771.         owner.resized();

  1772.     }

  1773. 

  1774.     void errorOccurred (const String& errorMessage)

  1775.     {

  1776.         if (owner.onErrorOccurred != nullptr)

  1777.             owner.onErrorOccurred (errorMessage);

  1778.     }

  1779. 

  1780.     void playbackStarted()

  1781.     {

  1782.         if (owner.onPlaybackStarted != nullptr)

  1783.             owner.onPlaybackStarted();

  1784.     }

  1785. 

  1786.     void playbackStopped()

  1787.     {

  1788.         if (owner.onPlaybackStopped != nullptr)

  1789.             owner.onPlaybackStopped();

  1790.     }

  1791. 

  1792.     //==============================================================================

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

  1794.     {

  1795.         mediaSession.setDisplay (holder);

  1796.     }

  1797. 

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

  1799.     {

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

  1801.     }

  1802. 

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

  1804.     {

  1805.     }

  1806. 

  1807.     //==============================================================================

  1808.     void onActivityPaused (jobject) override

  1809.     {

  1810.         wasOpen = isOpen();

  1811. 

  1812.         if (! wasOpen)

  1813.             return;

  1814. 

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

  1816. 

  1817.         mediaSession.storeState();

  1818.         mediaSession.closeVideo();

  1819. 

  1820.        #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1821.         systemVolumeListener.setEnabled (false);

  1822.        #endif

  1823.     }

  1824. 

  1825.     void onActivityResumed (jobject) override

  1826.     {

  1827.         if (! wasOpen)

  1828.             return;

  1829. 

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

  1831. 

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

  1833.                    {

  1834.                        if (r.wasOk())

  1835.                            mediaSession.restoreState();

  1836.                    });

  1837. 

  1838.        #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1839.         systemVolumeListener.setEnabled (true);

  1840.        #endif

  1841.     }

  1842. 

  1843.     //==============================================================================

  1844.    #endif

  1845. 

  1846.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Pimpl)

  1847. };

  1848. 

  1849. //==============================================================================

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

  1851. 

  1852. //==============================================================================

  1853. VideoComponent::Pimpl::MediaSession::AndroidMediaSessionCallback_Class VideoComponent::Pimpl::MediaSession::AndroidMediaSessionCallback;

  1854. VideoComponent::Pimpl::MediaSession::Controller::AndroidMediaControllerCallback_Class VideoComponent::Pimpl::MediaSession::Controller::AndroidMediaControllerCallback;

  1855. VideoComponent::Pimpl::SystemVolumeListener::SystemVolumeObserver_Class VideoComponent::Pimpl::SystemVolumeListener::SystemVolumeObserver;