char *m_IconData;

unsigned short m_IconSize;

public:

{

m_Payload.clear();

}

}

{

m_DeviceName.clear();

delete[] m_IconData;

char *m_IconData;

unsigned short m_IconSize;

public:

{

m_Payload.clear();

m_IconType = ICON_NONE;

}

{

m_Title.clear();

m_Message.clear();

unsigned short m_Amount;

unsigned short m_Flags;

public:

{

m_Payload.clear();

m_ButtonCode = 0;

}

{

m_DeviceMap.clear();

m_Button.clear();

{

m_PacketType = PT_PING;

}

};

class CPacketBYE : public CPacket

{

m_PacketType = PT_BYE;

}

};

class CPacketMOUSE : public CPacket

m_Y = Y;

}

{

m_Payload.clear();

m_Payload.push_back( (m_Y & 0x00ff));

}

};

class CPacketLOG : public CPacket

m_AutoPrintf = AutoPrintf;

}

{

m_Payload.clear();

m_Payload.push_back('\0');

}

};

class CPacketACTION : public CPacket

m_Action.push_back(Action[i]);

}

{

m_Payload.clear();

m_Payload.push_back('\0');

}

};

class CXBMCClient

friend class CAddonCallbacksGUI;

public:

explicit CGUIAddonRenderingControl(CGUIRenderingControl *pControl);

bool Create(int x, int y, int w, int h, void *device) override;

void Render() override;

void Stop() override;

friend struct Interface_GUIControlAddonRendering;

public:

explicit CGUIAddonRenderingControl(CGUIRenderingControl *pControl);

bool Create(int x, int y, int w, int h, void *device) override;

void Render() override;

{

public:

CActiveAESettings(CActiveAE &ae);

void OnSettingChanged(std::shared_ptr<const CSetting> setting) override;

class CAESinkAUDIOTRACK : public IAESink

{

public:

CAESinkAUDIOTRACK();

bool IsInitialized();

static void EnumerateDevicesEx(AEDeviceInfoList &list, bool force = false);

static void Register();

static IAESink* Create(std::string &device, AEAudioFormat &desiredFormat);

class CAESinkDARWINIOS : public IAESink

{

public:

CAESinkDARWINIOS();

static void Register();

static void EnumerateDevicesEx(AEDeviceInfoList &list, bool force);

static IAESink* Create(std::string &device, AEAudioFormat &desiredFormat);

private:

static AEDeviceInfoList m_devices;

class CAESinkDARWINOSX : public IAESink

{

public:

CAESinkDARWINOSX();

static void Register();

static void EnumerateDevicesEx(AEDeviceInfoList &list, bool force);

static IAESink* Create(std::string &device, AEAudioFormat &desiredFormat);

private:

static OSStatus renderCallback(AudioDeviceID inDevice, const AudioTimeStamp* inNow, const AudioBufferList* inInputData, const AudioTimeStamp* inInputTime, AudioBufferList* outOutputData, const AudioTimeStamp* inOutputTime, void* inClientData);

protected:

// implementation of CThread

private:

// Construction parameters

protected:

// implementation of CBaseRenderBufferPool

IRenderBuffer *CreateRenderBuffer(void *header = nullptr) override;

// Construction parameters

CRenderContext &m_context;

{

public:

CRenderBufferGuiTexture(SCALINGMETHOD scalingMethod);

// implementation of IRenderBuffer via CBaseRenderBuffer

bool Allocate(AVPixelFormat format, unsigned int width, unsigned int height) override;

{

public:

CRenderBufferSysMem() = default;

// implementation of IRenderBuffer

bool Allocate(AVPixelFormat format, unsigned int width, unsigned int height) override;

{

public:

CGUIGameSettings(CRPProcessInfo &processInfo);

// implementation of IGUIRenderSettings

CRenderSettings GetSettings() const override;

public:

CGameLoop(IGameLoopCallback* callback, double fps);

void Start();

void Stop();

protected:

// implementation of CThread

private:

double FrameTimeMs() const;

class CRealtimePlayback : public IPlayback

{

public:

// implementation of IPlayback

};

}

}

public:

CReversiblePlayback(GAME::CGameClient* gameClient, double fps, size_t serializeSize);

// implementation of IPlayback

// implementation of IGameLoopCallback

// implementation of Observer

private:

void AddFrame();

class CRendererFactoryGuiTexture : public IRendererFactory

{

public:

// implementation of IRendererFactory

std::string RenderSystemName() const override;

class CRendererFactoryOpenGL : public IRendererFactory

{

public:

// implementation of IRendererFactory

std::string RenderSystemName() const override;

class CRendererFactoryOpenGLES : public IRendererFactory

{

public:

// implementation of IRendererFactory

std::string RenderSystemName() const override;

{

public:

CSavestateFlatBuffer();

// Implementation of ISavestate

void Reset() override;

public:

CBasicMemoryStream();

// implementation of IMemoryStream

private:

size_t m_frameSize;

public:

CDeltaPairMemoryStream() = default;

// implementation of IMemoryStream via CLinearMemoryStream

protected:

// implementation of CLinearMemoryStream

/*!

* Rewinding is implemented by applying XOR deltas on the specific parts of

public:

CLinearMemoryStream();

// partial implementation of IMemoryStream

protected:

virtual void SubmitFrameInternal() = 0;

{

public:

explicit CAudioSinkAE(CDVDClock *clock);

void SetVolume(float fVolume);

void SetDynamicRangeCompression(long drc);

{

public:

CDVDAudioCodecAndroidMediaCodec(CProcessInfo &processInfo);

// registration

static CDVDAudioCodec* Create(CProcessInfo &processInfo);

m_surfaceTexture->setOnFrameAvailableListener(*this);

}

{

// unhook the callback

CJNIXBMCSurfaceTextureOnFrameAvailableListener nullListener(jni::jhobject(NULL));

}

protected:

private:

std::shared_ptr<CJNISurfaceTexture> m_surfaceTexture;

public:

CMediaCodecVideoBuffer(int id)

: CVideoBuffer(id){};

void Set(int internalId,

int textureId,

CMediaCodecVideoBufferPool(std::shared_ptr<CMediaCodec> mediaCodec)

: m_codec(mediaCodec){};

std::shared_ptr<CMediaCodec> GetMediaCodec();

void ResetMediaCodec();

{

public:

CDVDVideoCodecAndroidMediaCodec(CProcessInfo& processInfo, bool surface_render = false);

// registration

static CDVDVideoCodec* Create(CProcessInfo& processInfo);

static bool Register();

// required overrides

protected:

void Dispose();

// CJNISurfaceHolderCallback interface

public:

};

{

public:

explicit CDVDVideoCodecDRMPRIME(CProcessInfo& processInfo);

static CDVDVideoCodec* Create(CProcessInfo& processInfo);

static void Register();

class VTB::CVideoBufferPoolVTB : public IVideoBufferPool

{

public:

protected:

CCriticalSection m_critSection;

{

public:

CVideoBufferVTB(IVideoBufferPool &pool, int id);

void SetRef(AVFrame *frame);

void Unref();

CVPixelBufferRef GetPB();

{

public:

CDecoder(CProcessInfo& processInfo);

static IHardwareDecoder* Create(CDVDStreamInfo &hint, CProcessInfo &processInfo, AVPixelFormat fmt);

static bool Register();

void Close();

{

public:

IVideoBufferDRMPRIME() = delete;

virtual AVDRMFrameDescriptor* GetDescriptor() const = 0;

virtual uint32_t GetWidth() const = 0;

{

public:

CVideoBufferDRMPRIME(IVideoBufferPool& pool, int id);

void SetRef(AVFrame* frame);

void Unref();

class CVideoBufferPoolDRMPRIME : public IVideoBufferPool

{

public:

void Return(int id) override;

CVideoBuffer* Get() override;

{

public:

CRendererDRMPRIME() = default;

// Registration

static CBaseRenderer* Create(CVideoBuffer* buffer);

{

public:

CRendererDRMPRIMEGLES() = default;

// Registration

static CBaseRenderer* Create(CVideoBuffer* buffer);

{

public:

CRendererMediaCodec();

// Registration

static CBaseRenderer* Create(CVideoBuffer *buffer);

static bool Register();

// Player functions

// Feature support

protected:

// textures

// hooks for hw dec renderer

private:

float m_textureMatrix[16];

{

public:

CRendererMediaCodecSurface();

static CBaseRenderer* Create(CVideoBuffer *buffer);

static bool Register();

// Player functions

// Feature support

protected:

private:

void Reset();

{

public:

CRendererVTB() = default;

static CBaseRenderer* Create(CVideoBuffer *buffer);

static bool Register();

// Player functions

protected:

// textures

};

{

public:

CRendererVTB();

static CBaseRenderer* Create(CVideoBuffer *buffer);

static bool Register();

{

public:

CVideoLayerBridgeDRMPRIME(std::shared_ptr<KODI::WINDOWING::GBM::CDRMUtils> drm);

void Disable() override;

virtual void Configure(IVideoBufferDRMPRIME* buffer);

{

public:

CLinuxRendererGLES();

// Registration

static CBaseRenderer* Create(CVideoBuffer *buffer);

static bool Register();

// Player functions

// Feature support

protected:

static const int FIELD_FULL{0};

{

public:

CRenderCaptureGL();

int GetCaptureFormat();

public:

CGlMatrix() = default;

CGlMatrix(float (&src)[3][3]);

CMatrix operator*(const float (&other)[4][4]) override;

};

{

public:

CScale(float x, float y, float z);

};

class CTranslate : public CGlMatrix

{

public:

CTranslate(float x, float y, float z);

};

class ConversionToRGB : public CMatrix<3>

{

public:

ConversionToRGB(float Kr, float Kb);

ConversionToRGB& operator=(const float (&src)[3][3]);

protected:

{

public:

PrimaryToXYZ(const float (&primaries)[3][2], const float (&whitepoint)[2]);

protected:

PrimaryToXYZ() = default;

{

public:

PrimaryToRGB(float (&primaries)[3][2], float (&whitepoint)[2]);

};

//------------------------------------------------------------------------------

{

public:

BaseVideoFilterShader();

virtual bool GetTextureFilter(GLint& filter) { return false; }

void SetSourceTexture(GLint ytex) { m_sourceTexUnit = ytex; }

{

public:

BaseVideoFilterShader();

virtual void SetSourceTexture(GLint ytex) { m_sourceTexUnit = ytex; }

virtual void SetWidth(int w) { m_width = w; m_stepX = w>0?1.0f/w:0; }

virtual void SetHeight(int h) { m_height = h; m_stepY = h>0?1.0f/h:0; }

AVColorPrimaries dst, AVColorPrimaries src,

bool toneMap,

std::shared_ptr<GLSLOutput> output);

void SetField(int field) { m_field = field; }

void SetWidth(int w) { m_width = w; }

{

public:

BaseYUV2RGBGLSLShader(EShaderFormat format, AVColorPrimaries dst, AVColorPrimaries src, bool toneMap);

void SetField(int field) { m_field = field; }

void SetWidth(int w) { m_width = w; }

void SetHeight(int h) { m_height = h; }

explicit CBusyWaiter(IRunnable *runnable) :

CThread(runnable, "waiting"), m_done(new CEvent()), m_runnable(runnable) { }

bool Wait(unsigned int displaytime, bool allowCancel)

{

bool IsVisible(const CFileItem& item) const override;

bool Execute(const CFileItemPtr& item) const override;

protected:

virtual bool DoExecute(CFileItemList& items, const CFileItemPtr& item) const = 0;

};

const std::string GetProperty(XFILE::FileProperty type, const std::string &name = "") const override;

{

return std::vector<std::string>();

}

unsigned int MaxRewindTimeSec();

// Inherited from ISettingCallback

private:

// Construction parameters

public:

explicit CGameClient(const ADDON::AddonInfoPtr& addonInfo);

// Game subsystems (const)

const CGameClientInput &Input() const { return *m_subsystems.Input; }

CGameClientStreams &Streams() { return *m_subsystems.Streams; }

// Implementation of IAddon via CAddonDll

// Query properties of the game client

bool SupportsStandalone() const { return m_bSupportsStandalone; }

void UnregisterInput(JOYSTICK::IInputProvider *inputProvider);

// Implementation of IInputHandler

bool SetRumble(const std::string& feature, float magnitude);

/*!

* \brief Destructor unregisters from keyboard events from CInputManager.

*/

// implementation of IKeyboardInputHandler

std::string ControllerID() const override;

/*!

* \brief Destructor unregisters from mouse events from CInputManager.

*/

// implementation of IMouseInputHandler

private:

// Construction parameters

public:

explicit CController(const ADDON::AddonInfoPtr& addonInfo);

static const ControllerPtr EmptyPtr;

public:

CGUIDialogAxisDetection() = default;

// specialization of IButtonMapper via CGUIDialogButtonCapture

bool AcceptsPrimitive(JOYSTICK::PRIMITIVE_TYPE type) const override;

protected:

// implementation of CGUIDialogButtonCapture

private:

void AddAxis(const std::string& deviceName, unsigned int axisIndex);

public:

CGUIDialogButtonCapture();

// implementation of IButtonMapper

// implementation of Observer

/*!

* \brief Show the dialog

protected:

// implementation of CThread

virtual std::string GetDialogText() = 0;

virtual std::string GetDialogHeader() = 0;

public:

CGUIDialogIgnoreInput() = default;

// specialization of IButtonMapper via CGUIDialogButtonCapture

bool AcceptsPrimitive(JOYSTICK::PRIMITIVE_TYPE type) const override;

protected:

// implementation of CGUIDialogButtonCapture

void OnClose(bool bAccepted) override;

private:

const CControllerFeature& feature,

unsigned int index);

// implementation of IFeatureButton

private:

enum class STATE

public:

CGUIControllerButton(const CGUIButtonControl& buttonControl, const std::string& label, unsigned int index);

};

}

}

const CControllerFeature& feature,

unsigned int index);

// implementation of CGUIControl via CGUIButtonControl

// partial implementation of IFeatureButton

protected:

bool DoPrompt(const std::string& strPrompt, const std::string& strWarn, const std::string& strFeature, CEvent& waitEvent);

public:

CGUIFeatureGroupTitle(const CGUILabelControl& groupTitleTemplate, const std::string& groupName, unsigned int buttonIndex);

};

class CGUIFeatureSeparator : public CGUIImage

public:

CGUIFeatureSeparator(const CGUIImage& separatorTemplate, unsigned int buttonIndex);

};

}

}

CGUIGameController(int parentID, int controlID, float posX, float posY, float width, float height);

CGUIGameController(const CGUIGameController &from);

// implementation of CGUIControl via CGUIImage

void ActivateController(const ControllerPtr& controller);

const CControllerFeature& feature,

unsigned int index);

// implementation of IFeatureButton

private:

enum class STATE

IConfigurationWizard* wizard,

unsigned int index);

// implementation of IFeatureButton

const CControllerFeature& Feature(void) const override;

bool AllowWizard() const override { return false; }

bool NeedsKey() const override { return m_state == STATE::NEED_KEY; }

void SetKey(const CControllerFeature &key) override;

private:

static CControllerFeature GetFeature();

const CControllerFeature& feature,

unsigned int index);

// implementation of IFeatureButton

private:

enum class STATE

const CControllerFeature& feature,

unsigned int index);

// implementation of IFeatureButton

private:

enum class STATE

public:

CGUIConfigurationWizard();

// implementation of IConfigurationWizard

void RegisterKey(const CControllerFeature &key) override;

void UnregisterKeys() override;

// implementation of IButtonMapper

// implementation of IKeyboardDriverHandler

// implementation of Observer

protected:

// implementation of CThread

private:

void InitializeState(void);

{

public:

CGUIControllerList(CGUIWindow* window, IFeatureList* featureList, GameClientPtr gameClient);

// implementation of IControllerList

private:

bool RefreshControllers(void);

{

public:

CGUIControllerWindow(void);

// implementation of CGUIControl via CGUIDialog

protected:

// implementation of CGUIWindow via CGUIDialog

private:

void OnControllerFocused(unsigned int controllerIndex);

{

public:

CGUIFeatureList(CGUIWindow* window, GameClientPtr gameClient);

// implementation of IFeatureList

private:

IFeatureButton* GetButtonControl(unsigned int buttonIndex);

public:

explicit CInputSink(JOYSTICK::IInputHandler* gameInput);

// Implementation of IInputHandler

private:

// Construction parameters

JOYSTICK::IInputHandler *InputHandler() { return m_gameInput; }

// Implementation of IInputHandler

// Implementation of IKeymapEnvironment

private:

// Construction parameters

const std::string& GetGameClient() const { return m_strGameClient; }

void SetGameClient(const std::string& strGameClient) { m_strGameClient = strGameClient; }

private:

bool m_bLoaded;

public:

explicit CGUIViewStateWindowGames(const CFileItemList& items);

// implementation of CGUIViewState

protected:

// implementation of CGUIViewState

};

}

}

{

public:

CGUIWindowGames();

// implementation of CGUIControl via CGUIMediaWindow

protected:

// implementation of CGUIMediaWindow

bool OnClickMsg(int controlId, int actionId);

void OnItemInfo(int itemNumber);

float GetWidth() const override;

float GetHeight() const override;

virtual float Size() const;

void Process(unsigned int currentTime, CDirtyRegionList &dirtyregions) override;

void Render() override;

CGUITextureGLES(float posX, float posY, float width, float height, const CTextureInfo& texture);

static void DrawQuad(const CRect &coords, UTILS::Color color, CBaseTexture *texture = NULL, const CRect *texCoords = NULL);

protected:

GLubyte m_col[4];

{

public:

CGUIInfoProvider() = default;

void UpdateAVInfo(const AudioStreamInfo& audioInfo, const VideoStreamInfo& videoInfo, const SubtitleStreamInfo& subtitleInfo) override

{ m_audioInfo = audioInfo, m_videoInfo = videoInfo, m_subtitleInfo = subtitleInfo; }

CCustomControllerTranslator() = default;

// implementation of IButtonMapper

bool TranslateCustomControllerString(int windowId, const std::string& controllerName, int buttonId, int& action, std::string& strAction);

void QueueAction(const CAction& action);

// implementation of ISettingCallback

// implementation of IActionListener

void RegisterKeyboardDriverHandler(KODI::KEYBOARD::IKeyboardDriverHandler* handler);

void UnregisterKeyboardDriverHandler(KODI::KEYBOARD::IKeyboardDriverHandler* handler);

{

public:

CJoystickMapper() = default;

// implementation of IButtonMapper

std::vector<std::shared_ptr<const IWindowKeymap>> GetJoystickKeymaps() const;

CKeymap(std::shared_ptr<const IWindowKeymap> keymap, const IKeymapEnvironment *environment);

// implementation of IKeymap

const KODI::JOYSTICK::KeymapActionGroup &GetActions(const std::string& keyName) const override;

private:

class CKeymapEnvironment : public IKeymapEnvironment

{

public:

// implementation of IKeymapEnvironment

private:

int m_windowId = -1;

CTouchTranslator() = default;

// implementation of IButtonMapper

bool TranslateTouchAction(int window, int touchAction, int touchPointers, int &action, std::string &actionString);

explicit CWindowKeymap(const std::string &controllerId);

// implementation of IWindowKeymap

private:

// Construction parameter

{

public:

explicit CJoystickEasterEgg(const std::string& controllerId);

// implementation of IButtonSequence

bool OnButtonPress(const FeatureName& feature) override;

{

public:

// implementation of IInputHandler

private:

/*!

public:

CRumbleGenerator();

std::string ControllerID() const;

protected:

// implementation of CThread

private:

enum RUMBLE_TYPE

{

public:

CGUIDialogNewJoystick();

void ShowAsync();

protected:

// implementation of CThread

};

}

}

*/

CButtonMapping(IButtonMapper* buttonMapper, IButtonMap* buttonMap, IKeymap* keymap);

// implementation of IDriverHandler

// implementation of IKeyboardDriverHandler

bool OnKeyPress(const CKey& key) override;

void OnButtonRelease(MOUSE::BUTTON_ID button) override;

// implementation of IButtonMapCallback

/*!

* \brief Process the primitive mapping command

public:

CDriverReceiving(IDriverReceiver* receiver, IButtonMap* buttonMap);

// implementation of IInputReceiver

private:

IDriverReceiver* const m_receiver;

{

public:

CScalarFeature(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap);

// implementation of CJoystickFeature

private:

bool OnDigitalMotion(bool bPressed);

{

public:

CAxisFeature(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap);

// partial implementation of CJoystickFeature

protected:

CFeatureAxis m_axis;

{

public:

CWheel(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap);

// partial implementation of CJoystickFeature

};

class CThrottle : public CAxisFeature

{

public:

CThrottle(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap);

// partial implementation of CJoystickFeature

};

class CAnalogStick : public CJoystickFeature

{

public:

CAnalogStick(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap);

// implementation of CJoystickFeature

protected:

CFeatureAxis m_vertAxis;

{

public:

CAccelerometer(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap);

// implementation of CJoystickFeature

protected:

CFeatureAxis m_xAxis;

public:

CInputHandling(IInputHandler* handler, IButtonMap* buttonMap);

// implementation of IDriverHandler

private:

bool OnDigitalMotion(const CDriverPrimitive& source, bool bPressed);

public:

CKeyHandler(const std::string &keyName, IActionListener *actionHandler, const IKeymap *keymap, IKeymapHandler *keymapHandler);

// implementation of IKeyHandler

private:

void Reset();

public:

CKeymapHandler(IActionListener *actionHandler, const IKeymap *keymap);

// implementation of IKeymapHandler

// implementation of IInputHandler

protected:

// Keep track of cheat code presses

public:

CKeymapHandling(IInputProvider *inputProvider, bool pPromiscuous, const IKeymapEnvironment *environment);

/*!

* \brief Unregister the input provider

IKeymap *GetKeymap(const std::string &controllerId) const;

// implementation of Observer

private:

void LoadKeymaps();

private:

// private construction, and no assignments; use the provided singleton methods

CGenericTouchInputHandler();

CGenericTouchInputHandler(const CGenericTouchInputHandler&) = delete;

CGenericTouchInputHandler const& operator=(CGenericTouchInputHandler const&) = delete;

bool bHasPath = false;

int iAngle = 0;

#endif

};

uint32_t align;

bool bIsPassword = false;

#endif

// setType() Method

#ifndef SWIG

void sendLabelBind(int tail);

{ return ((actionId == ACTION_SELECT_ITEM) | (actionId == ACTION_MOUSE_LEFT_CLICK)); }

// This is called from AddonWindow.cpp but shouldn't be available

int itemTextOffsetY = 0;

uint32_t alignmentY;

#endif

};

/// @}

std::vector<std::string> vecLabels;

uint32_t align;

ControlFadeLabel() = default;

#endif

std::string strFont;

UTILS::Color textColor;

ControlTextBox() = default;

#endif

int aspectRatio = 0;

UTILS::Color colorDiffuse;

#endif

};

/// @}

int aspectRatio = 0;

UTILS::Color colorDiffuse;

ControlProgress() = default;

#endif

};

#endif

#ifndef SWIG

int textOffsetX = 0;

int textOffsetY = 0;

std::string strTextureFocus;

std::string strTextureNoFocus;

ControlButton() = default;

#endif

ControlGroup(long x, long y, long width, long height);

#ifndef SWIG

inline ControlGroup() = default;

#endif

#endif

#ifndef SWIG

std::string strFont;

std::string strText;

UTILS::Color shadowColor;

UTILS::Color focusedColor;

ControlRadioButton() = default;

#endif

std::string strTextureFoc;

int iOrientation;

inline ControlSlider() = default;

#endif

#endif

#if !defined SWIG && !defined DOXYGEN_SHOULD_SKIP_THIS

#endif

protected:

~WindowDialog() override;

#ifndef SWIG

#endif

};

///@}

#ifndef SWIG

// CGUIWindow

SWIGHIDDENVIRTUAL void AllocResources(bool forceLoad = false);

SWIGHIDDENVIRTUAL void FreeResources(bool forceUnLoad = false);

SWIGHIDDENVIRTUAL bool OnClick(int iItem);

SWIGHIDDENVIRTUAL bool OnDoubleClick(int iItem);

SWIGHIDDENVIRTUAL void Process(unsigned int currentTime, CDirtyRegionList &dirtyregions);

// This method is identical to the Window::OnDeinitWindow method

// except it passes the message on to their respective parents.

~WindowXMLDialog() override;

#ifndef SWIG

friend class DialogJumper;

#endif

, CAndroidJoyStick()

{}

};

{

public:

explicit CJNIMainActivity(const ANativeActivity *nativeActivity);

static CJNIMainActivity* GetAppInstance() { return m_appInstance; }

virtual void onActivityResult(int requestCode, int resultCode, CJNIIntent resultData)=0;

virtual void onVolumeChanged(int volume)=0;

virtual void doFrame(int64_t frameTimeNanos)=0;

virtual void onDisplayAdded(int displayId)=0;

virtual void onDisplayChanged(int displayId)=0;

CJNIXBMCAudioManagerOnAudioFocusChangeListener();

CJNIXBMCAudioManagerOnAudioFocusChangeListener(const CJNIXBMCAudioManagerOnAudioFocusChangeListener& other);

explicit CJNIXBMCAudioManagerOnAudioFocusChangeListener(const jni::jhobject &object) : CJNIBase(object) {}

static void RegisterNatives(JNIEnv* env);

public:

CJNIXBMCFile();

CJNIXBMCFile(const jni::jhobject &object) : CJNIBase(object) {}

static void RegisterNatives(JNIEnv* env);

protected:

static jstring _requestJSON(JNIEnv* env, jobject thiz, jstring request);

{

public:

CJNITransportLayer() = default;

// implementations of JSONRPC::ITransportLayer

bool PrepareDownload(const char *path, CVariant &details, std::string &protocol) override;

class CJNIClient : public JSONRPC::IClient

{

public:

};

};

{

public:

CJNIXBMCMainView(CJNISurfaceHolderCallback* callback);

static void RegisterNatives(JNIEnv* env);

// CJNISurfaceHolderCallback interface

void attach(const jobject& thiz);

bool waitForSurface(unsigned int millis);

CJNIXBMCMediaSession();

CJNIXBMCMediaSession(const CJNIXBMCMediaSession& other);

CJNIXBMCMediaSession(const jni::jhobject &object) : CJNIBase(object) {}

static void RegisterNatives(JNIEnv* env);

CJNIXBMCNsdManagerDiscoveryListener();

CJNIXBMCNsdManagerDiscoveryListener(const CJNIXBMCNsdManagerDiscoveryListener& other);

explicit CJNIXBMCNsdManagerDiscoveryListener(const jni::jhobject &object) : CJNIBase(object) {}

static void RegisterNatives(JNIEnv* env);

// CJNINsdManagerDiscoveryListener interface

public:

protected:

static void _onDiscoveryStarted(JNIEnv* env, jobject thiz, jstring serviceType);

CJNIXBMCNsdManagerRegistrationListener();

CJNIXBMCNsdManagerRegistrationListener(const CJNIXBMCNsdManagerRegistrationListener& other);

explicit CJNIXBMCNsdManagerRegistrationListener(const jni::jhobject &object) : CJNIBase(object) {}

static void RegisterNatives(JNIEnv* env);

CJNIXBMCNsdManagerResolveListener();

CJNIXBMCNsdManagerResolveListener(const CJNIXBMCNsdManagerResolveListener& other);

explicit CJNIXBMCNsdManagerResolveListener(const jni::jhobject &object) : CJNIBase(object) {}

static void RegisterNatives(JNIEnv* env);

// CJNINsdManagerResolveListener interface

protected:

static void _onResolveFailed(JNIEnv* env, jobject thiz, jobject serviceInfo, jint errorCode);

CJNIXBMCSurfaceTextureOnFrameAvailableListener();

CJNIXBMCSurfaceTextureOnFrameAvailableListener(const CJNIXBMCSurfaceTextureOnFrameAvailableListener& other);

CJNIXBMCSurfaceTextureOnFrameAvailableListener(const jni::jhobject &object) : CJNIBase(object) {}

static void RegisterNatives(JNIEnv* env);

protected:

static void _onFrameAvailable(JNIEnv* env, jobject thiz, jobject surface);

{

public:

CJNIXBMCVideoView(const jni::jhobject &object);

static void RegisterNatives(JNIEnv* env);

static CJNIXBMCVideoView* createVideoView(CJNISurfaceHolderCallback* callback);

// CJNISurfaceHolderCallback interface

static void _surfaceChanged(JNIEnv* env, jobject thiz, jobject holder, jint format, jint width, jint height);

static void _surfaceCreated(JNIEnv* env, jobject thiz, jobject holder);

{

public:

explicit CXBMCApp(ANativeActivity *nativeActivity);

static CXBMCApp* get() { return m_xbmcappinstance; }

// IAnnouncer IF

virtual void onAudioFocusChange(int focusChange);

// implementation of CJNIInputManagerInputDeviceListener

void onInputDeviceAdded(int deviceId) override;

{

public:

CAPKDirectory() = default;

};

}

{

public:

CAPKFile();

protected:

CURL m_url;

int m_zip_index;

{

public:

CAndroidAppDirectory() = default;

};

}

public:

/*! \brief Currently only used for retrieving App Icons. */

CFileAndroidApp(void);

/*! \brief Return 32bit rgba raw bitmap. */

virtual unsigned int ReadIcon(unsigned char **lpBuf, unsigned int* width, unsigned int* height);

public:

static void Register();

CMediaDrmCryptoSession(const std::string& UUID, const std::string& cipherAlgo, const std::string& macAlgo);

// Interface methods

XbmcCommons::Buffer GetKeyRequest(const XbmcCommons::Buffer& init, const std::string& mimeType, bool offlineKey, const std::map<std::string, std::string>& parameters) override;

// CNetworkInterface interface

public:

std::string GetHostName();

public:

CNetworkAndroid();

// CNetwork interface

public:

// Ping remote host

using CNetworkBase::PingHost;

protected:

void RetrieveInterfaces();

{

public:

CZeroconfAndroid();

// CZeroconf interface

protected:

private:

jni::CJNINsdManager m_manager;

// CJNINsdManagerDiscoveryListener interface

public:

protected:

CZeroconfBrowserAndroid* m_browser;

// CJNINsdManagerResolveListener interface

public:

CEvent m_resolutionDone;

int m_errorCode;

public:

CZeroconfBrowserAndroid();

// CZeroconfBrowser interface

protected:

void addDiscoveredService(CZeroconfBrowserAndroidDiscover* browser, const CZeroconfBrowser::ZeroconfService& fcr_service);

void removeDiscoveredService(CZeroconfBrowserAndroidDiscover* browser, const CZeroconfBrowser::ZeroconfService& fcr_service);

{

public:

CAndroidPowerSyscall() = default;

static IPowerSyscall* CreateInstance();

static void Register();

};

{

public:

CAndroidStorageProvider();

private:

std::string unescape(const std::string& str);

CPlatformDarwin() = default;

/**\brief D'tor */

void Init() override;

};

void Initialize();

void DeInitialize();

private:

CAnnounceReceiver() = default;

{

public:

CIOSKeyboard();

void fireCallback(const std::string &str);

void invalidateCallback() {m_pCharCallback = nullptr;}

private:

char_callback_t m_pCharCallback;

{

public:

CIOSStorageProvider() {}

};

{

public:

CZeroconfBrowserDarwin();

private:

///implementation if CZeroconfBrowser interface

///@{

///@}

/// browser callback

{

public:

CZeroconfDarwin();

protected:

//implement base CZeroConf interface

bool doPublishService(const std::string& fcr_identifier,

const std::string& fcr_type,

const std::string& fcr_name,

unsigned int f_port,

private:

static void registerCallback(CFNetServiceRef theService, CFStreamError* error, void* info);

public:

static XBMCHelper& GetInstance();

void Start();

void Stop();

{

public:

explicit CPeripheralBusUSB(CPeripherals& manager);

/*!

* @see PeripheralBus::PerformDeviceScan()

*/

protected:

PeripheralScanResults m_scan_results;

{

public:

CCocoaPowerSyscall();

static IPowerSyscall* CreateInstance();

static void Register();

private:

void CreateOSPowerCallBacks(void);

void DeleteOSPowerCallBacks(void);

{

public:

COSXStorageProvider();

static void VolumeMountNotification(const char* label, const char* mountpoint);

static void VolumeUnmountNotification(const char* label, const char* mountpoint);

{

public:

CLibInputHandler();

void Start();

static void SettingOptionsKeyboardLayoutsFiller(std::shared_ptr<const CSetting> setting, std::vector<StringSettingOption> &list, std::string &current, void *data);

CLibInputSettings(CLibInputHandler *handler);

private:

CLibInputHandler *m_libInputHandler{nullptr};

{

public:

CLinuxStorageProvider();

void Initialize() override;

void Stop() override;

CPlatformAndroid() = default;

/**\brief D'tor */

void Init() override;

};

{

public:

CSmartPlaylist();

bool Load(const CURL& url);

bool Load(const std::string &path);

public:

CGLShader(const char *shader, std::string prefix);

CGLShader(const char *vshader, const char *fshader, std::string prefix);

void Free();

GLint GetPosLoc() {return m_hPos;}

public:

CGLESShader( const char *shader, std::string prefix);

CGLESShader(const char *vshader, const char *fshader, std::string prefix);

void Free();

GLint GetPosLoc() { return m_hPos; }

{

public:

CRenderSystemGLES();

bool InitRenderSystem() override;

bool DestroyRenderSystem() override;

private:

CDiscSettings() = default;

};

return true;

}

else if (settingId == CSettings::SETTING_VIDEOSCREEN_BLANKDISPLAYS)

{

auto winSystem = CServiceBroker::GetWinSystem();

#if defined(HAVE_X11)

winSystem->UpdateResolutions();

CGraphicContext& gfxContext = winSystem->GetGfxContext();

gfxContext.SetVideoResolution(gfxContext.GetVideoResolution(), true);

#endif

CBooleanLogicValue(const std::string &value = "", bool negated = false)

: m_value(value), m_negated(negated)

{ }

bool Deserialize(const TiXmlNode *node) override;

explicit CBooleanLogicOperation(BooleanLogicOperation op = BooleanLogicOperationAnd)

: m_operation(op)

{ }

bool Deserialize(const TiXmlNode *node) override;

{

protected:

/* make sure nobody deletes a pointer to this class */

public:

bool Deserialize(const TiXmlNode *node) override;

{

public:

CGBMBufferObject(int format);

bool CreateBufferObject(int width, int height) override;

void DestroyBufferObject() override;

bool lookInFolder);

//! \brief Destructor.

//! \brief Returns whether or not reader has info.

bool HasInfo() const override;

ADDON::ScraperPtr info,

bool lookInFolder);

//! \brief Returns whether or not read has info.

bool HasInfo() const override;

public:

CVideoTagLoaderPlugin(const CFileItem& item, bool forceRefresh);

//! \brief Returns whether or not read has info.

bool HasInfo() const override;

{

public:

CWinEventsX11(CWinSystemX11& winSystem);

bool MessagePump() override;

bool Init(Display *dpy, Window win);

void Quit();

{

public:

CX11DPMSSupport();

protected:

bool EnablePowerSaving(PowerSavingMode mode) override;

{

public:

CAndroidUtils();

bool GetNativeResolution(RESOLUTION_INFO* res) const;

bool SetNativeResolution(const RESOLUTION_INFO& res);

bool ProbeResolutions(std::vector<RESOLUTION_INFO>& resolutions);

CVideoSyncAndroid(void *clock) : CVideoSync(clock), m_LastVBlankTime(0) {}

// CVideoSync interface

// IDispResource interface

// Choreographer callback

void FrameCallback(int64_t frameTimeNanos);

{

public:

CWinEventsAndroid();

void MessagePush(XBMC_Event *newEvent);

void MessagePushRepeat(XBMC_Event *repeatEvent);

private:

size_t GetQueueSize();

// for CThread

CCriticalSection m_eventsCond;

std::list<XBMC_Event> m_events;

{

public:

CWinSystemAndroid();

bool InitWindowSystem() override;

bool DestroyWindowSystem() override;

{

public:

CWinSystemAndroidGLESContext() = default;

// Implementation of CWinSystemBase via CWinSystemAndroid

CRenderSystemBase *GetRenderSystem() override { return this; }

bool ResizeWindow(int newWidth, int newHeight, int newLeft, int newTop) override;

bool SetFullScreen(bool fullScreen, RESOLUTION_INFO& res, bool blankOtherDisplays) override;

float GetFrameLatencyAdjustment() override;

bool IsHDRDisplay() override;

{

public:

CDRMAtomic() = default;

private:

void DrmAtomicCommit(int fb_id, int flags, bool rendered, bool videoLayer);

{

public:

CDRMLegacy() = default;

private:

bool WaitingForFlip();

{

public:

CGBMDPMSSupport();

protected:

bool EnablePowerSaving(PowerSavingMode mode) override;

{

public:

COffScreenModeSetting() = default;

void FlipPage(struct gbm_bo *bo, bool rendered, bool videoLayer) override {}

bool SetVideoMode(const RESOLUTION_INFO& res, struct gbm_bo *bo) override { return false; }

bool SetActive(bool active) override { return false; }

{

public:

CWinSystemGbm();

bool InitWindowSystem() override;

bool DestroyWindowSystem() override;

bool Hide() override;

bool Show(bool raise = true) override;

std::shared_ptr<CVideoLayerBridge> GetVideoLayerBridge() const { return m_videoLayerBridge; };

void RegisterVideoLayerBridge(std::shared_ptr<CVideoLayerBridge> bridge) { m_videoLayerBridge = bridge; };

class CWinSystemGbmEGLContext : public CWinSystemGbm

{

public:

bool DestroyWindowSystem() override;

bool CreateNewWindow(const std::string& name,

{

public:

CWinSystemGbmGLContext();

// Implementation of CWinSystemBase via CWinSystemGbm

CRenderSystemBase *GetRenderSystem() override { return this; }

{

public:

CWinSystemGbmGLESContext();

// Implementation of CWinSystemBase via CWinSystemGbm

CRenderSystemBase *GetRenderSystem() override { return this; }

CVideoSync(clock), m_winSystem(winSystem) {}

// CVideoSync interface

// IDispResource interface

// used in the displaylink callback

void IosVblankHandler();

{

public:

CWinSystemIOS();

int GetDisplayIndexFromSettings();

// Implementation of CWinSystemBase

void Register(IDispResource *resource) override;

void Unregister(IDispResource *resource) override;

bool InitDisplayLink(CVideoSyncIos *syncImpl);

void DeinitDisplayLink(void);

{

public:

CCocoaDPMSSupport();

protected:

bool EnablePowerSaving(PowerSavingMode mode) override;

m_displayReset(false){};

// CVideoSync interface

// IDispResource interface

// used in the displaylink callback

void VblankHandler(int64_t nowtime, uint32_t timebase);

{

public:

CWinEventsOSX() = default;

};

public:

CWinSystemOSX();

// ITimerCallback interface

// CWinSystemBase

void Register(IDispResource *resource) override;

void Unregister(IDispResource *resource) override;

void WindowChangedScreen();

bool MessagePump() override;

protected:

void HandlePossibleRefreshrateChange();

void GetScreenResolution(int* w, int* h, double* fps, int screenIdx);

{

public:

CWinSystemOSXGL() = default;

// Implementation of CWinSystemBase via CWinSystemOSX

CRenderSystemBase *GetRenderSystem() override { return this; }

protected:

};

* .desktop file of the application

*/

CShellSurfaceXdgShell(IShellSurfaceHandler& handler, wayland::display_t& display, wayland::xdg_wm_base_t const& shell, wayland::surface_t const& surface, std::string const& title, std::string const& class_);

static CShellSurfaceXdgShell* TryCreate(IShellSurfaceHandler& handler, CConnection& connection, wayland::surface_t const& surface, std::string const& title, std::string const& class_);

* .desktop file of the application

*/

CShellSurfaceXdgShellUnstableV6(IShellSurfaceHandler& handler, wayland::display_t& display, wayland::zxdg_shell_v6_t const& shell, wayland::surface_t const& surface, std::string const& title, std::string const& class_);

static CShellSurfaceXdgShellUnstableV6* TryCreate(IShellSurfaceHandler& handler, CConnection& connection, wayland::surface_t const& surface, std::string const& title, std::string const& class_);

Create();

}

{

Stop();

// Wait for roundtrip invocation to finish

{

public:

CWinSystemWayland();

bool InitWindowSystem() override;

bool DestroyWindowSystem() override;

{

public:

CWinSystemWaylandEGLContext();

bool CreateNewWindow(const std::string& name,

bool fullScreen,