xbmc/platform/android/activity/XBMCApp.h

   1 /*
   2  *  Copyright (C) 2012-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #pragma once
  10
  11 #include "IActivityHandler.h"
  12 #include "IInputHandler.h"
  13 #include "JNIMainActivity.h"
  14 #include "JNIXBMCAudioManagerOnAudioFocusChangeListener.h"
  15 #include "JNIXBMCDisplayManagerDisplayListener.h"
  16 #include "JNIXBMCMainView.h"
  17 #include "JNIXBMCMediaSession.h"
  18 #include "interfaces/IAnnouncer.h"
  19 #include "platform/xbmc.h"
  20 #include "threads/Event.h"
  21 #include "utils/Geometry.h"
  22
  23 #include <atomic>
  24 #include <map>
  25 #include <memory>
  26 #include <string>
  27 #include <thread>
  28 #include <vector>
  29
  30 #include <android/native_activity.h>
  31 #include <androidjni/Activity.h>
  32 #include <androidjni/AudioManager.h>
  33 #include <androidjni/BroadcastReceiver.h>
  34 #include <androidjni/SurfaceHolder.h>
  35 #include <androidjni/View.h>
  36
  37 // forward declares
  38 class CAESinkAUDIOTRACK;
  39 class CVariant;
  40 class IInputDeviceCallbacks;
  41 class IInputDeviceEventHandler;
  42 class CVideoSyncAndroid;
  43
  44 typedef struct _JNIEnv JNIEnv;
  45
  46 struct androidIcon
  47 {
  48   unsigned int width;
  49   unsigned int height;
  50   void *pixels;
  51 };
  52
  53 struct androidPackage
  54 {
  55   std::string packageName;
  56   std::string packageLabel;
  57   int icon;
  58 };
  59
  60 class CNativeWindow
  61 {
  62   friend class CWinSystemAndroidGLESContext; // meh
  63
  64 public:
  65   static std::shared_ptr<CNativeWindow> CreateFromSurface(CJNISurfaceHolder holder);
  66   ~CNativeWindow();
  67
  68   bool SetBuffersGeometry(int width, int height, int format);
  69   int32_t GetWidth() const;
  70   int32_t GetHeight() const;
  71
  72 private:
  73   explicit CNativeWindow(ANativeWindow* window);
  74
  75   CNativeWindow() = delete;
  76   CNativeWindow(const CNativeWindow&) = delete;
  77   CNativeWindow& operator=(const CNativeWindow&) = delete;
  78
  79   ANativeWindow* m_window{nullptr};
  80 };
  81
  82 class CXBMCApp : public IActivityHandler,
  83                  public jni::CJNIMainActivity,
  84                  public CJNIBroadcastReceiver,
  85                  public ANNOUNCEMENT::IAnnouncer,
  86                  public CJNISurfaceHolderCallback
  87 {
  88 public:
  89   static CXBMCApp& Create(ANativeActivity* nativeActivity, IInputHandler& inputhandler)
  90   {
  91     m_appinstance.reset(new CXBMCApp(nativeActivity, inputhandler));
  92     return *m_appinstance;
  93   }
  94   static CXBMCApp& Get() { return *m_appinstance; }
  95   static void Destroy() { m_appinstance.reset(); }
  96
  97   CXBMCApp() = delete;
  98   ~CXBMCApp() override;
  99
 100   // IAnnouncer IF
 101   void Announce(ANNOUNCEMENT::AnnouncementFlag flag,
 102                 const std::string& sender,
 103                 const std::string& message,
 104                 const CVariant& data) override;
 105
 106   void onReceive(CJNIIntent intent) override;
 107   void onNewIntent(CJNIIntent intent) override;
 108   void onActivityResult(int requestCode, int resultCode, CJNIIntent resultData) override;
 109   void onVolumeChanged(int volume) override;
 110   virtual void onAudioFocusChange(int focusChange);
 111   void doFrame(int64_t frameTimeNanos) override;
 112   void onVisibleBehindCanceled() override;
 113
 114   // implementation of CJNIInputManagerInputDeviceListener
 115   void onInputDeviceAdded(int deviceId) override;
 116   void onInputDeviceChanged(int deviceId) override;
 117   void onInputDeviceRemoved(int deviceId) override;
 118
 119   // implementation of DisplayManager::DisplayListener
 120   void onDisplayAdded(int displayId) override;
 121   void onDisplayChanged(int displayId) override;
 122   void onDisplayRemoved(int displayId) override;
 123   jni::jhobject getDisplayListener() { return m_displayListener.get_raw(); }
 124
 125   bool isValid() { return m_activity != NULL; }
 126
 127   void onStart() override;
 128   void onResume() override;
 129   void onPause() override;
 130   void onStop() override;
 131   void onDestroy() override;
 132
 133   void onSaveState(void **data, size_t *size) override;
 134   void onConfigurationChanged() override;
 135   void onLowMemory() override;
 136
 137   void onCreateWindow(ANativeWindow* window) override;
 138   void onResizeWindow() override;
 139   void onDestroyWindow() override;
 140   void onGainFocus() override;
 141   void onLostFocus() override;
 142
 143   void Initialize();
 144   void Deinitialize();
 145
 146   bool Stop(int exitCode);
 147   void Quit();
 148
 149   std::shared_ptr<CNativeWindow> GetNativeWindow(int timeout) const;
 150
 151   bool SetBuffersGeometry(int width, int height, int format);
 152   static int android_printf(const char *format, ...);
 153
 154   int GetBatteryLevel() const;
 155   void KeepScreenOn(bool on);
 156   bool HasFocus() const { return m_hasFocus; }
 157
 158   static bool StartActivity(const std::string& package,
 159                             const std::string& intent = std::string(),
 160                             const std::string& dataType = std::string(),
 161                             const std::string& dataURI = std::string(),
 162                             const std::string& flags = std::string(),
 163                             const std::string& extras = std::string(),
 164                             const std::string& action = std::string(),
 165                             const std::string& category = std::string(),
 166                             const std::string& className = std::string());
 167   std::vector<androidPackage> GetApplications() const;
 168
 169   static int GetMaxSystemVolume();
 170   static float GetSystemVolume();
 171   static void SetSystemVolume(float percent);
 172
 173   void SetDisplayMode(int mode, float rate);
 174   int GetDPI() const;
 175   void SetVideoLayoutBackgroundColor(const int color);
 176
 177   CRect MapRenderToDroid(const CRect& srcRect);
 178
 179   // Playback callbacks
 180   void OnPlayBackStarted();
 181   void OnPlayBackPaused();
 182   void OnPlayBackStopped();
 183
 184   // Info callback
 185   void UpdateSessionMetadata();
 186   void UpdateSessionState();
 187
 188   // input device methods
 189   void RegisterInputDeviceCallbacks(IInputDeviceCallbacks* handler);
 190   void UnregisterInputDeviceCallbacks();
 191   static const CJNIViewInputDevice GetInputDevice(int deviceId);
 192   static std::vector<int> GetInputDeviceIds();
 193
 194   void RegisterInputDeviceEventHandler(IInputDeviceEventHandler* handler);
 195   void UnregisterInputDeviceEventHandler();
 196   bool onInputDeviceEvent(const AInputEvent* event);
 197
 198   void InitFrameCallback(CVideoSyncAndroid* syncImpl);
 199   void DeinitFrameCallback();
 200
 201   // Application slow ping
 202   void ProcessSlow();
 203
 204   bool WaitVSync(unsigned int milliSeconds);
 205   int64_t GetNextFrameTime() const;
 206   float GetFrameLatencyMs() const;
 207
 208   bool getVideosurfaceInUse();
 209   void setVideosurfaceInUse(bool videosurfaceInUse);
 210
 211 protected:
 212   // limit who can access Volume
 213   friend class CAESinkAUDIOTRACK;
 214
 215   static int GetMaxSystemVolume(JNIEnv *env);
 216   bool AcquireAudioFocus();
 217   bool ReleaseAudioFocus();
 218   void RequestVisibleBehind(bool requested);
 219
 220 private:
 221   static std::unique_ptr<CXBMCApp> m_appinstance;
 222
 223   CXBMCApp(ANativeActivity* nativeActivity, IInputHandler& inputhandler);
 224
 225   jni::CJNIXBMCAudioManagerOnAudioFocusChangeListener m_audioFocusListener;
 226   jni::CJNIXBMCDisplayManagerDisplayListener m_displayListener;
 227   std::unique_ptr<jni::CJNIXBMCMainView> m_mainView;
 228   std::unique_ptr<jni::CJNIXBMCMediaSession> m_mediaSession;
 229   std::string GetFilenameFromIntent(const CJNIIntent &intent);
 230
 231   void run();
 232   void stop();
 233   void SetupEnv();
 234   static void SetDisplayModeCallback(void* modeVariant);
 235   static void KeepScreenOnCallback(void* onVariant);
 236   static void SetViewBackgroundColorCallback(void* mapVariant);
 237
 238   static void RegisterDisplayListenerCallback(void*);
 239   void UnregisterDisplayListener();
 240
 241   ANativeActivity* m_activity{nullptr};
 242   IInputHandler& m_inputHandler;
 243   int m_batteryLevel{0};
 244   bool m_hasFocus{false};
 245   bool m_headsetPlugged{false};
 246   bool m_hdmiSource{false};
 247   bool m_wakeUp{false};
 248   bool m_aeReset{false};
 249   bool m_hdmiPlugged{true};
 250   bool m_mediaSessionUpdated{false};
 251   IInputDeviceCallbacks* m_inputDeviceCallbacks{nullptr};
 252   IInputDeviceEventHandler* m_inputDeviceEventHandler{nullptr};
 253   bool m_hasReqVisible{false};
 254   bool m_firstrun{true};
 255   std::atomic<bool> m_exiting{false};
 256   int m_exitCode{0};
 257   bool m_bResumePlayback{false};
 258   std::thread m_thread;
 259   mutable CCriticalSection m_applicationsMutex;
 260   mutable std::vector<androidPackage> m_applications;
 261
 262   std::shared_ptr<CNativeWindow> m_window;
 263
 264   CVideoSyncAndroid* m_syncImpl{nullptr};
 265   CEvent m_vsyncEvent;
 266   CEvent m_displayChangeEvent;
 267
 268   bool XBMC_DestroyDisplay();
 269   bool XBMC_SetupDisplay();
 270
 271   void OnSleep();
 272   void OnWakeup();
 273
 274   uint32_t m_playback_state{0};
 275   int64_t m_frameTimeNanos{0};
 276   float m_refreshRate{0.0f};
 277
 278 public:
 279   // CJNISurfaceHolderCallback interface
 280   void surfaceChanged(CJNISurfaceHolder holder, int format, int width, int height) override;
 281   void surfaceCreated(CJNISurfaceHolder holder) override;
 282   void surfaceDestroyed(CJNISurfaceHolder holder) override;
 283 };