DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
12503 Commits
9 Branches
1.4GB
Tree: cdbefa3b51
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cdbefa3b51'
${ noResults }
JUCE/modules/juce_video/native/juce_android_Video.h

1853 lines
84KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

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

  6. 

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

  8.    licensing.

  9. 

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

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

  12. 

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

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

  15. 

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

  17.    www.gnu.org/licenses).

  18. 

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

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

  21.    DISCLAIMED.

  22. 

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

  24. */

  25. 

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

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

  28. //

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

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

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

  32. //

  33. // files with min sdk version 21

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

  35. static const unsigned char MediaSessionByteCode[] =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  97. 

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

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

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

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

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

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

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

  105. 

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

  107. #undef JNI_CLASS_MEMBERS

  108. 

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

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

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

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

  113. 

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

  115. #undef JNI_CLASS_MEMBERS

  116. 

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

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

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

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

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

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

  123. 

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

  125. #undef JNI_CLASS_MEMBERS

  126. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  152. 

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

  154. #undef JNI_CLASS_MEMBERS

  155. 

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

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

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

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

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

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

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

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

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

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

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

  167. 

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

  169. #undef JNI_CLASS_MEMBERS

  170. 

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

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

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

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

  175. 

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

  177. #undef JNI_CLASS_MEMBERS

  178. 

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

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

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

  182. 

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

  184. #undef JNI_CLASS_MEMBERS

  185. 

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

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

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

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

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

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

  192. 

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

  194. #undef JNI_CLASS_MEMBERS

  195. 

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

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

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

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

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

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

  202. 

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

  204. #undef JNI_CLASS_MEMBERS

  205. 

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

  207. class MediaPlayerListener  : public AndroidInterfaceImplementer

  208. {

  209. public:

  210.     struct Owner

  211.     {

  212.         virtual ~Owner() {}

  213. 

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

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

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

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

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

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

  220.     };

  221. 

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

  223. 

  224. private:

  225.     Owner& owner;

  226. 

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

  228.     {

  229.         auto* env = getEnv();

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

  231. 

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

  233. 

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

  235.         {

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

  237. 

  238.             owner.onPrepared (mediaPlayer);

  239.             return nullptr;

  240.         }

  241. 

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

  243.         {

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

  245. 

  246.             owner.onCompletion (mediaPlayer);

  247.             return nullptr;

  248.         }

  249. 

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

  251.         {

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

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

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

  255. 

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

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

  258. 

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

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

  261.         }

  262. 

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

  264.         {

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

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

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

  268. 

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

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

  271. 

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

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

  274.         }

  275. 

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

  277.         {

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

  279. 

  280.             owner.onSeekComplete (mediaPlayer);

  281.             return nullptr;

  282.         }

  283. 

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

  285.         {

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

  287. 

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

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

  290. 

  291.             owner.onBufferingUpdate (mediaPlayer, progressInt);

  292. 

  293.             return nullptr;

  294.         }

  295. 

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

  297.     }

  298. };

  299. 

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

  301. class AudioManagerOnAudioFocusChangeListener  : public AndroidInterfaceImplementer

  302. {

  303. public:

  304.     struct Owner

  305.     {

  306.         virtual ~Owner() {}

  307. 

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

  309.     };

  310. 

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

  312. 

  313. private:

  314.     Owner& owner;

  315. 

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

  317.     {

  318.         auto* env = getEnv();

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

  320. 

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

  322. 

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

  324.         {

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

  326. 

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

  328. 

  329.             owner.onAudioFocusChange (changeTypeInt);

  330.             return nullptr;

  331.         }

  332. 

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

  334.     }

  335. };

  336. 

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

  338. struct VideoComponent::Pimpl

  339.     : public AndroidViewComponent, private ActivityLifecycleCallbacks, private SurfaceHolderCallback

  340. {

  341.     Pimpl (VideoComponent& ownerToUse, bool)

  342.         : owner (ownerToUse),

  343.           mediaSession (*this)

  344.        #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  345.         , systemVolumeListener (*this)

  346.        #endif

  347.     {

  348.         // Video requires SDK version 21 or higher

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

  350. 

  351.         setVisible (true);

  352. 

  353.         auto* env = getEnv();

  354. 

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

  356. 

  357.         if (appContext != nullptr)

  358.         {

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

  360. 

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

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

  363.         }

  364. 

  365.         {

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

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

  368. 

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

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

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

  372. 

  373.             setView (surfaceView.get());

  374.         }

  375.     }

  376. 

  377.     ~Pimpl() override

  378.     {

  379.         auto* env = getEnv();

  380. 

  381.         if (surfaceHolderCallback != nullptr)

  382.         {

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

  384. 

  385.             if (view != nullptr)

  386.             {

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

  388. 

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

  390.                 SurfaceHolderCallback::clear();

  391.                 surfaceHolderCallback.clear();

  392.             }

  393.         }

  394. 

  395.         if (activityLifeListener != nullptr)

  396.         {

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

  398.             ActivityLifecycleCallbacks::clear();

  399.             activityLifeListener.clear();

  400.         }

  401.     }

  402. 

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

  404.     {

  405.         close();

  406.         wasOpen = false;

  407. 

  408.         if (url.isEmpty())

  409.         {

  410.             jassertfalse;

  411.             return;

  412.         }

  413. 

  414.         if (! url.isLocalFile())

  415.         {

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

  417.             {

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

  419.                 // Android Manifest.

  420.                 jassertfalse;

  421.                 return;

  422.             }

  423.         }

  424. 

  425.         currentURL = url;

  426. 

  427.         jassert (callback != nullptr);

  428. 

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

  430. 

  431.         static constexpr jint visible = 0;

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

  433. 

  434.         mediaSession.load (url);

  435.     }

  436. 

  437.     void close()

  438.     {

  439.         if (! isOpen())

  440.             return;

  441. 

  442.         mediaSession.closeVideo();

  443. 

  444.         static constexpr jint invisible = 4;

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

  446.     }

  447. 

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

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

  450. 

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

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

  453. 

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

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

  456. 

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

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

  459. 

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

  461. 

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

  463. 

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

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

  466. 

  467.     File currentFile;

  468.     URL currentURL;

  469. 

  470. private:

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

  472.     class MediaSession  : private AudioManagerOnAudioFocusChangeListener::Owner

  473.     {

  474.     public:

  475.         MediaSession (Pimpl& ownerToUse)

  476.             : owner (ownerToUse),

  477.               sdkVersion (getAndroidSDKVersion()),

  478.               audioAttributes (getAudioAttributes()),

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

  480.                                                                           AndroidMediaSession.constructor,

  481.                                                                           getAppContext().get(),

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

  483.               mediaSessionCallback (createCallbackObject()),

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

  485.                                                                             AndroidPlaybackStateBuilder.constructor))),

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

  487.                                                                                 AndroidMediaSession.getController))),

  488.               player (*this),

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

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

  491.               audioFocusChangeListener (*this),

  492.               nativeAudioFocusChangeListener (GlobalRef (CreateJavaInterface (&audioFocusChangeListener,

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

  494.               audioFocusRequest (createAudioFocusRequestIfNecessary (sdkVersion, audioAttributes,

  495.                                                                      nativeAudioFocusChangeListener))

  496.         {

  497.             auto* env = getEnv();

  498. 

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

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

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

  502.         }

  503. 

  504.         ~MediaSession() override

  505.         {

  506.             auto* env = getEnv();

  507. 

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

  509. 

  510.             controller.stop();

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

  512.         }

  513. 

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

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

  516. 

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

  518. 

  519.         void closeVideo()

  520.         {

  521.             resetState();

  522.             controller.closeVideo();

  523.         }

  524. 

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

  526. 

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

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

  529. 

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

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

  532. 

  533.         void setSpeed (double newSpeed)

  534.         {

  535.             playSpeedMult = newSpeed;

  536. 

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

  538.             if (player.isPlaying())

  539.             {

  540.                 player.setPlaySpeed (playSpeedMult);

  541.                 updatePlaybackState();

  542.             }

  543.         }

  544. 

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

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

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

  548. 

  549.         void setVolume (float newVolume)

  550.         {

  551.            #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  552.             controller.setVolume (newVolume);

  553.            #else

  554.             player.setAudioVolume (newVolume);

  555.            #endif

  556.         }

  557. 

  558.         float getVolume() const

  559.         {

  560.            #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  561.             return controller.getVolume();

  562.            #else

  563.             return player.getAudioVolume();

  564.            #endif

  565.         }

  566. 

  567.         void storeState()

  568.         {

  569.             storedPlaybackState.clear();

  570.             storedPlaybackState = GlobalRef (getCurrentPlaybackState());

  571.         }

  572. 

  573.         void restoreState()

  574.         {

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

  576.                 return;

  577. 

  578.             auto* env = getEnv();

  579. 

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

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

  582. 

  583.             setSpeed (playSpeedMult);

  584. 

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

  586. 

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

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

  589.             {

  590.                 play();

  591.             }

  592.         }

  593. 

  594.     private:

  595.         struct PlaybackState

  596.         {

  597.             enum

  598.             {

  599.                 STATE_NONE = 0,

  600.                 STATE_STOPPED = 1,

  601.                 STATE_PAUSED = 2,

  602.                 STATE_PLAYING = 3,

  603.                 STATE_FAST_FORWARDING = 4,

  604.                 STATE_REWINDING = 5,

  605.                 STATE_BUFFERING = 6,

  606.                 STATE_ERROR = 7,

  607.                 STATE_CONNECTING = 8,

  608.                 STATE_SKIPPING_TO_PREVIOUS = 9,

  609.                 STATE_SKIPPING_TO_NEXT = 10,

  610.                 STATE_SKIPPING_TO_QUEUE_ITEM = 11,

  611.             };

  612. 

  613.             enum

  614.             {

  615.                 ACTION_PAUSE              = 0x2,

  616.                 ACTION_PLAY               = 0x4,

  617.                 ACTION_PLAY_FROM_MEDIA_ID = 0x8000,

  618.                 ACTION_PLAY_PAUSE         = 0x200,

  619.                 ACTION_SEEK_TO            = 0x100,

  620.                 ACTION_STOP               = 0x1,

  621.             };

  622.         };

  623. 

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

  625.         class Controller

  626.         {

  627.         public:

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

  629.                 : owner (ownerToUse),

  630.                   nativeController (GlobalRef (nativeControllerToUse)),

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

  632.                                                                                               AndroidMediaController.getTransportControls))),

  633.                   controllerCallback (createControllerCallbacks())

  634.             {

  635.                 auto* env = getEnv();

  636. 

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

  638.             }

  639. 

  640.             ~Controller()

  641.             {

  642.                 auto* env = getEnv();

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

  644.             }

  645. 

  646.             void load (const URL& url)

  647.             {

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

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

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

  651.             }

  652. 

  653.             void closeVideo()

  654.             {

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

  656.             }

  657. 

  658.             void play()

  659.             {

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

  661.             }

  662. 

  663.             void stop()

  664.             {

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

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

  667.             }

  668. 

  669.             void setPosition (double newPosition)

  670.             {

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

  672. 

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

  674.             }

  675. 

  676.             double getPosition() const

  677.             {

  678.                 auto* env = getEnv();

  679. 

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

  681. 

  682.                 if (playbackState != nullptr)

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

  684. 

  685.                 return 0.0;

  686.             }

  687. 

  688.             double getPlaySpeed() const

  689.             {

  690.                 auto* env = getEnv();

  691. 

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

  693. 

  694.                 if (playbackState != nullptr)

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

  696. 

  697.                 return 1.0;

  698.             }

  699. 

  700.             void setVolume (float newVolume)

  701.             {

  702.                 auto* env = getEnv();

  703. 

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

  705. 

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

  707. 

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

  709. 

  710.                 static constexpr jint flagShowUI = 1;

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

  712.             }

  713. 

  714.             float getVolume() const

  715.             {

  716.                 auto* env = getEnv();

  717. 

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

  719. 

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

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

  722. 

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

  724.             }

  725. 

  726.         private:

  727.             MediaSession& owner;

  728. 

  729.             GlobalRef nativeController;

  730.             GlobalRef controllerTransportControls;

  731.             GlobalRef controllerCallback;

  732.             bool wasPlaying = false;

  733.             bool wasPaused = true;

  734. 

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

  736.             void stateChanged (jobject playbackState)

  737.             {

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

  739. 

  740.                 if (playbackState == nullptr)

  741.                     return;

  742. 

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

  744. 

  745.                 static constexpr jint statePaused  = 2;

  746.                 static constexpr jint statePlaying = 3;

  747. 

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

  749.                     owner.playbackStarted();

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

  751.                     owner.playbackStopped();

  752. 

  753.                 wasPlaying = state == statePlaying;

  754.                 wasPaused  = state == statePaused;

  755.             }

  756. 

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

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

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

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

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

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

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

  764. 

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

  766.            #undef JNI_CLASS_MEMBERS

  767. 

  768.             LocalRef<jobject> createControllerCallbacks()

  769.             {

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

  771.                                                                AndroidMediaControllerCallback.constructor,

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

  773.             }

  774. 

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

  776.             // MediaSessionController callbacks

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

  778.             {

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

  780.                 {

  781.                     ignoreUnused (playbackInfo);

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

  783.                 }

  784.             }

  785. 

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

  787.             {

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

  789.                 {

  790.                     ignoreUnused (metadata);

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

  792.                 }

  793.             }

  794. 

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

  796.             {

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

  798.                     myself->stateChanged (state);

  799.             }

  800. 

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

  802.             {

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

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

  805.             }

  806.         };

  807. 

  808.         //==============================================================================

  809.         class Player   : private MediaPlayerListener::Owner

  810.         {

  811.         public:

  812.             Player (MediaSession& ownerToUse)

  813.                 : owner (ownerToUse),

  814.                   mediaPlayerListener (*this),

  815.                   nativeMediaPlayerListener (GlobalRef (CreateJavaInterface (&mediaPlayerListener,

  816.                                                                              getNativeMediaPlayerListenerInterfaces())))

  817. 

  818.             {}

  819. 

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

  821.             {

  822.                 if (surfaceHolder == nullptr)

  823.                 {

  824.                     videoSurfaceHolder.clear();

  825. 

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

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

  828. 

  829.                     return;

  830.                 }

  831. 

  832.                 videoSurfaceHolder = GlobalRef (surfaceHolder);

  833. 

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

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

  836.             }

  837. 

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

  839.             {

  840.                 ignoreUnused (extras);

  841. 

  842.                 closeVideo();

  843. 

  844.                 auto* env = getEnv();

  845. 

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

  847. 

  848.                 currentState = State::idle;

  849. 

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

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

  852. 

  853.                 if (jniCheckHasExceptionOccurredAndClear())

  854.                 {

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

  856.                     return;

  857.                 }

  858. 

  859.                 currentState = State::initialised;

  860. 

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

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

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

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

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

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

  867. 

  868.                 if (videoSurfaceHolder != nullptr)

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

  870. 

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

  872. 

  873.                 currentState = State::preparing;

  874.             }

  875. 

  876.             void closeVideo()

  877.             {

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

  879.                     return;

  880. 

  881.                 auto* env = getEnv();

  882. 

  883.                 if (getCurrentStateInfo().canCallStop)

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

  885. 

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

  887.                 nativeMediaPlayer.clear();

  888. 

  889.                 currentState = State::end;

  890.             }

  891. 

  892.             bool isVideoOpen() const noexcept

  893.             {

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

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

  896.             }

  897. 

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

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

  900. 

  901.             jlong getVideoDuration() const

  902.             {

  903.                 if (! getCurrentStateInfo().canCallGetVideoDuration)

  904.                     return 0;

  905. 

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

  907.             }

  908. 

  909.             Rectangle<int> getVideoNativeSize() const

  910.             {

  911.                 if (! getCurrentStateInfo().canCallGetVideoHeight)

  912.                 {

  913.                     jassertfalse;

  914.                     return {};

  915.                 }

  916. 

  917.                 auto* env = getEnv();

  918. 

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

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

  921. 

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

  923.             }

  924. 

  925.             void play()

  926.             {

  927.                 if (! getCurrentStateInfo().canCallStart)

  928.                 {

  929.                     jassertfalse;

  930.                     return;

  931.                 }

  932. 

  933.                 auto* env = getEnv();

  934. 

  935.                 // Perform a potentially pending volume setting

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

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

  938. 

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

  940. 

  941.                 currentState = State::started;

  942.             }

  943. 

  944.             void pause()

  945.             {

  946.                 if (! getCurrentStateInfo().canCallPause)

  947.                 {

  948.                     jassertfalse;

  949.                     return;

  950.                 }

  951. 

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

  953. 

  954.                 currentState = State::paused;

  955.             }

  956. 

  957.             bool isPlaying() const

  958.             {

  959.                 return getCurrentStateInfo().isPlaying;

  960.             }

  961. 

  962.             void setPlayPosition (jint newPositionMs)

  963.             {

  964.                 if (! getCurrentStateInfo().canCallSeekTo)

  965.                 {

  966.                     jassertfalse;

  967.                     return;

  968.                 }

  969. 

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

  971.             }

  972. 

  973.             jint getPlayPosition() const

  974.             {

  975.                 if (! getCurrentStateInfo().canCallGetCurrentPosition)

  976.                     return 0.0;

  977. 

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

  979.             }

  980. 

  981.             void setPlaySpeed (double newSpeed)

  982.             {

  983.                 if (! getCurrentStateInfo().canCallSetPlaybackParams)

  984.                 {

  985.                     jassertfalse;

  986.                     return;

  987.                 }

  988. 

  989.                 auto* env = getEnv();

  990. 

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

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

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

  994. 

  995.                 if (jniCheckHasExceptionOccurredAndClear())

  996.                 {

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

  998.                     jassertfalse;

  999.                 }

  1000.             }

  1001. 

  1002.             double getPlaySpeed() const

  1003.             {

  1004.                 if (! getCurrentStateInfo().canCallGetPlaybackParams)

  1005.                     return 0.0;

  1006. 

  1007.                 auto* env = getEnv();

  1008. 

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

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

  1011.             }

  1012. 

  1013.             void setAudioVolume (float newVolume)

  1014.             {

  1015.                 if (! getCurrentStateInfo().canCallSetVolume)

  1016.                 {

  1017.                     jassertfalse;

  1018.                     return;

  1019.                 }

  1020. 

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

  1022. 

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

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

  1025.             }

  1026. 

  1027.             float getAudioVolume() const

  1028.             {

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

  1030.                 return lastAudioVolume;

  1031.             }

  1032. 

  1033.         private:

  1034.             //==============================================================================

  1035.             struct StateInfo

  1036.             {

  1037.                 int playbackStateFlag = 0, allowedActions = 0;

  1038. 

  1039.                 bool isPlaying, canCallGetCurrentPosition, canCallGetVideoDuration,

  1040.                         canCallGetVideoHeight, canCallGetVideoWidth, canCallGetPlaybackParams,

  1041.                         canCallPause, canCallPrepare, canCallSeekTo, canCallSetAudioAttributes,

  1042.                         canCallSetDataSource, canCallSetPlaybackParams, canCallSetVolume,

  1043.                         canCallStart, canCallStop;

  1044.             };

  1045. 

  1046.             enum class State

  1047.             {

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

  1049.             };

  1050. 

  1051.             static constexpr StateInfo stateInfos[] = {

  1052.                 /* idle */

  1053.                 {PlaybackState::STATE_NONE, PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1054.                             false, true, false, true, true, false, false, false, false, true,

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

  1056.                 /* initialised */

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

  1058.                             false, true, false, true, true, true, false, true, false, true,

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

  1060.                 /* preparing */

  1061.                 {PlaybackState::STATE_BUFFERING, 0,

  1062.                             false, false, false, false, false, true, false, false, false, false,

  1063.                             false,  false, false, false, false},

  1064.                 /* prepared */

  1065.                 {PlaybackState::STATE_PAUSED,

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

  1067.                             false, true, true, true, true, true, false, false, true, true,

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

  1069.                 /* started */

  1070.                 {PlaybackState::STATE_PLAYING,

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

  1072.                             true, true, true, true, true, true, true, false, true, true,

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

  1074.                 /* paused */

  1075.                 {PlaybackState::STATE_PAUSED,

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

  1077.                             false, true, true, true, true, true, true, false, true, true,

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

  1079.                 /* stopped */

  1080.                 {PlaybackState::STATE_STOPPED,

  1081.                             PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1082.                             false, true, true, true, true, true, false, true, false, true,

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

  1084.                 /* complete */

  1085.                 {PlaybackState::STATE_PAUSED,

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

  1087.                             false, true, true, true, true, true, true, false, true, true,

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

  1089.                 /* error */

  1090.                 {PlaybackState::STATE_ERROR,

  1091.                             PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1092.                             false, false, false, false, false, false, false, false, false, false,

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

  1094.                 /* end */

  1095.                 {PlaybackState::STATE_NONE,

  1096.                             PlaybackState::ACTION_PLAY_FROM_MEDIA_ID,

  1097.                             false, false, false, false, false, false, false, false, false, false,

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

  1099.             };

  1100. 

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

  1102. 

  1103.             //==============================================================================

  1104.             MediaSession& owner;

  1105.             GlobalRef nativeMediaPlayer;

  1106. 

  1107.             MediaPlayerListener mediaPlayerListener;

  1108.             GlobalRef nativeMediaPlayerListener;

  1109. 

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

  1111. 

  1112.             GlobalRef videoSurfaceHolder;

  1113. 

  1114.             State currentState = State::idle;

  1115. 

  1116.             //==============================================================================

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

  1118.             {

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

  1120. 

  1121.                 ignoreUnused (mediaPlayer);

  1122. 

  1123.                 currentState = State::prepared;

  1124. 

  1125.                 owner.playerPrepared();

  1126.             }

  1127. 

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

  1129.             {

  1130.                 ignoreUnused (mediaPlayer);

  1131. 

  1132.                 owner.playerBufferingUpdated (progress);

  1133.             }

  1134. 

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

  1136.             {

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

  1138. 

  1139.                 ignoreUnused (mediaPlayer);

  1140. 

  1141.                 owner.playerSeekCompleted();

  1142.             }

  1143. 

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

  1145.             {

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

  1147. 

  1148.                 ignoreUnused (mediaPlayer);

  1149. 

  1150.                 currentState = State::complete;

  1151. 

  1152.                 owner.playerPlaybackCompleted();

  1153.             }

  1154. 

  1155.             enum

  1156.             {

  1157.                 MEDIA_INFO_UNKNOWN               = 1,

  1158.                 MEDIA_INFO_VIDEO_RENDERING_START = 3,

  1159.                 MEDIA_INFO_VIDEO_TRACK_LAGGING   = 700,

  1160.                 MEDIA_INFO_BUFFERING_START       = 701,

  1161.                 MEDIA_INFO_BUFFERING_END         = 702,

  1162.                 MEDIA_INFO_NETWORK_BANDWIDTH     = 703,

  1163.                 MEDIA_INFO_BAD_INTERLEAVING      = 800,

  1164.                 MEDIA_INFO_NOT_SEEKABLE          = 801,

  1165.                 MEDIA_INFO_METADATA_UPDATE       = 802,

  1166.                 MEDIA_INFO_AUDIO_NOT_PLAYING     = 804,

  1167.                 MEDIA_INFO_VIDEO_NOT_PLAYING     = 805,

  1168.                 MEDIA_INFO_UNSUPPORTED_SUBTITE   = 901,

  1169.                 MEDIA_INFO_SUBTITLE_TIMED_OUT    = 902

  1170.             };

  1171. 

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

  1173.             {

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

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

  1176. 

  1177.                 ignoreUnused (mediaPlayer, extra);

  1178. 

  1179.                 if (what == MEDIA_INFO_BUFFERING_START)

  1180.                     owner.playerBufferingStarted();

  1181.                 else if (what == MEDIA_INFO_BUFFERING_END)

  1182.                     owner.playerBufferingEnded();

  1183. 

  1184.                 return true;

  1185.             }

  1186. 

  1187.             static String infoCodeToString (int code)

  1188.             {

  1189.                 switch (code)

  1190.                 {

  1191.                     case MEDIA_INFO_UNKNOWN:               return "Unknown";

  1192.                     case MEDIA_INFO_VIDEO_RENDERING_START: return "Rendering start";

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

  1194.                     case MEDIA_INFO_BUFFERING_START:       return "Buffering start";

  1195.                     case MEDIA_INFO_BUFFERING_END:         return "Buffering end";

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

  1197.                     case MEDIA_INFO_BAD_INTERLEAVING:      return "Bad interleaving";

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

  1199.                     case MEDIA_INFO_METADATA_UPDATE:       return "Metadata updated";

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

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

  1202.                     case MEDIA_INFO_UNSUPPORTED_SUBTITE:   return "Unsupported subtitle";

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

  1204.                     default:                               return "";

  1205.                 }

  1206.             }

  1207. 

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

  1209.             {

  1210.                 auto errorMessage = errorCodeToString (what);

  1211.                 auto extraMessage = errorCodeToString (extra);

  1212. 

  1213.                 if (extraMessage.isNotEmpty())

  1214.                     errorMessage << ", " << extraMessage;

  1215. 

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

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

  1218. 

  1219.                 ignoreUnused (mediaPlayer);

  1220. 

  1221.                 currentState = State::error;

  1222. 

  1223.                 owner.errorOccurred (errorMessage);

  1224.                 return true;

  1225.             }

  1226. 

  1227.             static String errorCodeToString (int code)

  1228.             {

  1229.                 enum

  1230.                 {

  1231.                     MEDIA_ERROR_UNSUPPORTED                        = -1010,

  1232.                     MEDIA_ERROR_MALFORMED                          = -1007,

  1233.                     MEDIA_ERROR_IO                                 = -1004,

  1234.                     MEDIA_ERROR_TIMED_OUT                          = -110,

  1235.                     MEDIA_ERROR_UNKNOWN                            = 1,

  1236.                     MEDIA_ERROR_SERVER_DIED                        = 100,

  1237.                     MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200

  1238.                 };

  1239. 

  1240.                 switch (code)

  1241.                 {

  1242.                     case MEDIA_ERROR_UNSUPPORTED:                        return "Unsupported bitstream";

  1243.                     case MEDIA_ERROR_MALFORMED:                          return "Malformed bitstream";

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

  1245.                     case MEDIA_ERROR_TIMED_OUT:                          return "Timed out";

  1246.                     case MEDIA_ERROR_UNKNOWN:                            return "Unknown error";

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

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

  1249.                     default:                                             return "";

  1250.                 }

  1251.             }

  1252. 

  1253.             //==============================================================================

  1254.             static StringArray getNativeMediaPlayerListenerInterfaces()

  1255.             {

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

  1257. 

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

  1259.                          IFPREFIX "OnInfoListener", IFPREFIX "OnPreparedListener",

  1260.                          IFPREFIX "OnBufferingUpdateListener", IFPREFIX "OnSeekCompleteListener"

  1261.                 };

  1262. 

  1263.                 #undef IFPREFIX

  1264.             }

  1265.         };

  1266. 

  1267.         //==============================================================================

  1268.         Pimpl& owner;

  1269.         int sdkVersion;

  1270. 

  1271.         GlobalRef audioAttributes;

  1272.         GlobalRef nativeMediaSession;

  1273.         GlobalRef mediaSessionCallback;

  1274.         GlobalRef playbackStateBuilder;

  1275. 

  1276.         Controller controller;

  1277.         Player player;

  1278. 

  1279.         GlobalRef audioManager;

  1280.         AudioManagerOnAudioFocusChangeListener audioFocusChangeListener;

  1281.         GlobalRef nativeAudioFocusChangeListener;

  1282.         GlobalRef audioFocusRequest;

  1283. 

  1284.         GlobalRef storedPlaybackState;

  1285. 

  1286.         bool pendingSeekRequest = false;

  1287. 

  1288.         bool playerBufferingInProgress = false;

  1289.         bool usesBuffering = false;

  1290.         SparseSet<int> bufferedRegions;

  1291. 

  1292.         double playSpeedMult = 1.0;

  1293.         bool hasAudioFocus = false;

  1294. 

  1295.         //==============================================================================

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

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

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

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

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

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

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

  1303. 

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

  1305.         #undef JNI_CLASS_MEMBERS

  1306. 

  1307.         LocalRef<jobject> createCallbackObject()

  1308.         {

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

  1310.                                                            AndroidMediaSessionCallback.constructor,

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

  1312.         }

  1313. 

  1314.         //==============================================================================

  1315.         // MediaSession callbacks

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

  1317.         {

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

  1319.             {

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

  1321.                 myself->player.pause();

  1322.                 myself->updatePlaybackState();

  1323. 

  1324.                 myself->abandonAudioFocus();

  1325.             }

  1326.         }

  1327. 

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

  1329.         {

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

  1331.             {

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

  1333. 

  1334.                 myself->requestAudioFocus();

  1335. 

  1336.                 if (! myself->hasAudioFocus)

  1337.                 {

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

  1339.                     return;

  1340.                 }

  1341. 

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

  1343. 

  1344.                 myself->player.play();

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

  1346.                 myself->updatePlaybackState();

  1347.             }

  1348.         }

  1349. 

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

  1351.         {

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

  1353.             {

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

  1355. 

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

  1357.                 myself->updatePlaybackState();

  1358.             }

  1359.         }

  1360. 

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

  1362.         {

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

  1364.             {

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

  1366. 

  1367.                 myself->pendingSeekRequest = true;

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

  1369.                 myself->updatePlaybackState();

  1370.             }

  1371.         }

  1372. 

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

  1374.         {

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

  1376.             {

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

  1378. 

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

  1380. 

  1381.                 myself->player.closeVideo();

  1382.                 myself->updatePlaybackState();

  1383. 

  1384.                 myself->abandonAudioFocus();

  1385. 

  1386.                 myself->owner.closeVideoFinished();

  1387.             }

  1388.         }

  1389. 

  1390.         //==============================================================================

  1391.         bool isSeekInProgress() const noexcept

  1392.         {

  1393.             if (pendingSeekRequest)

  1394.                 return true;

  1395. 

  1396.             if (! usesBuffering)

  1397.                 return false;

  1398. 

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

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

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

  1402.             if (playerBufferingInProgress)

  1403.                 return true;

  1404. 

  1405.             auto playPos = player.getPlayPosition();

  1406.             auto durationMs = player.getVideoDuration();

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

  1408. 

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

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

  1411.         }

  1412. 

  1413.         void updatePlaybackState()

  1414.         {

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

  1416.         }

  1417. 

  1418.         LocalRef<jobject> getCurrentPlaybackState()

  1419.         {

  1420.             static constexpr int bufferingState = 6;

  1421. 

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

  1423.             auto playPos = player.getPlayPosition();

  1424.             auto playSpeed = player.getPlaySpeed();

  1425.             auto allowedActions = player.getAllowedActions();

  1426. 

  1427.             auto* env = getEnv();

  1428. 

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

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

  1431. 

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

  1433. 

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

  1435.         }

  1436. 

  1437.         //==============================================================================

  1438.         void playerPrepared()

  1439.         {

  1440.             resetState();

  1441. 

  1442.             updateMetadata();

  1443. 

  1444.             owner.loadFinished();

  1445.         }

  1446. 

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

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

  1449. 

  1450.         void playerBufferingUpdated (int progress)

  1451.         {

  1452.             usesBuffering = true;

  1453. 

  1454.             updatePlaybackState();

  1455. 

  1456.             auto playPos = player.getPlayPosition();

  1457.             auto durationMs = player.getVideoDuration();

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

  1459. 

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

  1461. 

  1462.             String ranges;

  1463. 

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

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

  1466. 

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

  1468.         }

  1469. 

  1470.         void playerSeekCompleted()

  1471.         {

  1472.             pendingSeekRequest = false;

  1473.             updatePlaybackState();

  1474.         }

  1475. 

  1476.         void playerPlaybackCompleted()

  1477.         {

  1478.             player.pause();

  1479.             abandonAudioFocus();

  1480. 

  1481.             pendingSeekRequest = true;

  1482.             player.setPlayPosition (0);

  1483.             updatePlaybackState();

  1484.         }

  1485. 

  1486.         void updateMetadata()

  1487.         {

  1488.             auto* env = getEnv();

  1489. 

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

  1491.                                                                       AndroidMediaMetadataBuilder.constructor));

  1492. 

  1493.             auto durationMs = player.getVideoDuration();

  1494. 

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

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

  1497.                                                       AndroidMediaMetadataBuilder.putLong,

  1498.                                                       jDurationKey.get(),

  1499.                                                       (jlong) durationMs));

  1500. 

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

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

  1503.                                                       AndroidMediaMetadataBuilder.putLong,

  1504.                                                       jNumTracksKey.get(),

  1505.                                                       (jlong) 1));

  1506. 

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

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

  1509.         }

  1510. 

  1511.         void errorOccurred (const String& errorMessage)

  1512.         {

  1513.             auto* env = getEnv();

  1514. 

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

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

  1517.                                                       javaString (errorMessage).get()));

  1518. 

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

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

  1521. 

  1522.             // ...also notify JUCE side client

  1523.             owner.errorOccurred (errorMessage);

  1524.         }

  1525. 

  1526.         //==============================================================================

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

  1528.                                                                      const GlobalRef& nativeAudioFocusChangeListener)

  1529.         {

  1530.             if (sdkVersion < 26)

  1531.                 return LocalRef<jobject>();

  1532. 

  1533.             auto* env = getEnv();

  1534. 

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

  1536. 

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

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

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

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

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

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

  1543. 

  1544.             static constexpr jint audioFocusGain = 1;

  1545. 

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

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

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

  1549. 

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

  1551.         }

  1552. 

  1553.         void requestAudioFocus()

  1554.         {

  1555.             static constexpr jint audioFocusGain = 1;

  1556.             static constexpr jint streamMusic = 3;

  1557.             static constexpr jint audioFocusRequestGranted = 1;

  1558. 

  1559.             jint result = audioFocusRequestGranted;

  1560. 

  1561.             if (sdkVersion >= 26)

  1562.             {

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

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

  1565. 

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

  1567.             }

  1568.             else

  1569.             {

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

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

  1572.             }

  1573. 

  1574.             hasAudioFocus = result == audioFocusRequestGranted;

  1575.         }

  1576. 

  1577.         void abandonAudioFocus()

  1578.         {

  1579.             if (! hasAudioFocus)

  1580.                 return;

  1581. 

  1582.             static constexpr jint audioFocusRequestGranted = 1;

  1583. 

  1584.             jint result = audioFocusRequestGranted;

  1585. 

  1586.             if (sdkVersion >= 26)

  1587.             {

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

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

  1590. 

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

  1592.             }

  1593.             else

  1594.             {

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

  1596.                                                    nativeAudioFocusChangeListener.get());

  1597.             }

  1598. 

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

  1600.             hasAudioFocus = result != audioFocusRequestGranted;

  1601.         }

  1602. 

  1603.         void onAudioFocusChange (int changeType) override

  1604.         {

  1605.             static constexpr jint audioFocusGain = 1;

  1606. 

  1607.             if (changeType == audioFocusGain)

  1608.                 JUCE_VIDEO_LOG ("Audio focus gained");

  1609.             else

  1610.                 JUCE_VIDEO_LOG ("Audio focus lost");

  1611. 

  1612.             if (changeType != audioFocusGain)

  1613.             {

  1614.                 if (isPlaying())

  1615.                 {

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

  1617.                     stop();

  1618.                 }

  1619. 

  1620.                 abandonAudioFocus();

  1621.             }

  1622.         }

  1623. 

  1624.         //==============================================================================

  1625.         void playbackStarted()

  1626.         {

  1627.             owner.playbackStarted();

  1628.         }

  1629. 

  1630.         void playbackStopped()

  1631.         {

  1632.             owner.playbackStopped();

  1633.         }

  1634. 

  1635.         //==============================================================================

  1636.         void resetState()

  1637.         {

  1638.             usesBuffering = false;

  1639.             bufferedRegions.clear();

  1640.             playerBufferingInProgress = false;

  1641. 

  1642.             pendingSeekRequest = false;

  1643. 

  1644.             playSpeedMult = 1.0;

  1645.             hasAudioFocus = false;

  1646.         }

  1647. 

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

  1649.         static LocalRef<jobject> getAudioAttributes()

  1650.         {

  1651.             // Video requires SDK version 21 or higher

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

  1653. 

  1654.             auto* env = getEnv();

  1655. 

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

  1657.                                                                           AndroidAudioAttributesBuilder.constructor));

  1658.             static constexpr jint contentTypeMovie = 3;

  1659.             static constexpr jint usageMedia = 1;

  1660. 

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

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

  1663. 

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

  1665.         }

  1666.     };

  1667. 

  1668.    #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1669.     //==============================================================================

  1670.     class SystemVolumeListener

  1671.     {

  1672.     public:

  1673.         SystemVolumeListener (Pimpl& ownerToUse)

  1674.             : owner (ownerToUse),

  1675.               nativeObserver (createCallbackObject())

  1676.         {

  1677.             setEnabled (true);

  1678.         }

  1679. 

  1680.         ~SystemVolumeListener()

  1681.         {

  1682.             setEnabled (false);

  1683.         }

  1684.     private:

  1685.         Pimpl& owner;

  1686.         GlobalRef nativeObserver;

  1687. 

  1688.         //==============================================================================

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

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

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

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

  1693. 

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

  1695.         #undef JNI_CLASS_MEMBERS

  1696. 

  1697. 

  1698.         LocalRef<jobject> createCallbackObject()

  1699.         {

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

  1701.                                                            SystemVolumeObserver.constructor,

  1702.                                                            getCurrentActivity().get(),

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

  1704.         }

  1705.     public:

  1706.         void setEnabled (bool shouldBeEnabled)

  1707.         {

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

  1709. 

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

  1711.             if (shouldBeEnabled)

  1712.                 systemVolumeChanged();

  1713.         }

  1714. 

  1715.     private:

  1716.         //==============================================================================

  1717.         void systemVolumeChanged()

  1718.         {

  1719.             MessageManager::callAsync ([weakThis = WeakReference<SystemVolumeListener> { this }]() mutable

  1720.                                        {

  1721.                                            if (weakThis == nullptr)

  1722.                                                return;

  1723. 

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

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

  1726.                                        });

  1727. 

  1728.         }

  1729. 

  1730.         //==============================================================================

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

  1732.         {

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

  1734.                 myself->systemVolumeChanged();

  1735.         }

  1736. 

  1737.         JUCE_DECLARE_WEAK_REFERENCEABLE (SystemVolumeListener)

  1738.     };

  1739. 

  1740.     //==============================================================================

  1741.     VideoComponent& owner;

  1742. 

  1743.     MediaSession mediaSession;

  1744.     GlobalRef activityLifeListener;

  1745.    #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1746.     SystemVolumeListener systemVolumeListener;

  1747.    #endif

  1748.     GlobalRef surfaceHolderCallback;

  1749. 

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

  1751. 

  1752.     bool wasOpen = false;

  1753. 

  1754.     //==============================================================================

  1755.     void loadFinished()

  1756.     {

  1757.         owner.resized();

  1758. 

  1759.         if (loadFinishedCallback != nullptr)

  1760.         {

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

  1762.             loadFinishedCallback = nullptr;

  1763.         }

  1764.     }

  1765. 

  1766.     void closeVideoFinished()

  1767.     {

  1768.         owner.resized();

  1769.     }

  1770. 

  1771.     void errorOccurred (const String& errorMessage)

  1772.     {

  1773.         if (owner.onErrorOccurred != nullptr)

  1774.             owner.onErrorOccurred (errorMessage);

  1775.     }

  1776. 

  1777.     void playbackStarted()

  1778.     {

  1779.         if (owner.onPlaybackStarted != nullptr)

  1780.             owner.onPlaybackStarted();

  1781.     }

  1782. 

  1783.     void playbackStopped()

  1784.     {

  1785.         if (owner.onPlaybackStopped != nullptr)

  1786.             owner.onPlaybackStopped();

  1787.     }

  1788. 

  1789.     //==============================================================================

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

  1791.     {

  1792.         mediaSession.setDisplay (holder);

  1793.     }

  1794. 

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

  1796.     {

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

  1798.     }

  1799. 

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

  1801.     {

  1802.     }

  1803. 

  1804.     //==============================================================================

  1805.     void onActivityPaused (jobject) override

  1806.     {

  1807.         wasOpen = isOpen();

  1808. 

  1809.         if (! wasOpen)

  1810.             return;

  1811. 

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

  1813. 

  1814.         mediaSession.storeState();

  1815.         mediaSession.closeVideo();

  1816. 

  1817.        #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1818.         systemVolumeListener.setEnabled (false);

  1819.        #endif

  1820.     }

  1821. 

  1822.     void onActivityResumed (jobject) override

  1823.     {

  1824.         if (! wasOpen)

  1825.             return;

  1826. 

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

  1828. 

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

  1830.                    {

  1831.                        if (r.wasOk())

  1832.                            mediaSession.restoreState();

  1833.                    });

  1834. 

  1835.        #if JUCE_SYNC_VIDEO_VOLUME_WITH_OS_MEDIA_VOLUME

  1836.         systemVolumeListener.setEnabled (true);

  1837.        #endif

  1838.     }

  1839. 

  1840.     //==============================================================================

  1841.    #endif

  1842. 

  1843.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Pimpl)

  1844. };

  1845. 

  1846. //==============================================================================

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

  1848. 

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

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

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

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