diff --git a/.gitignore b/.gitignore index 818928340cefa..c5f87f19cdd20 100644 --- a/.gitignore +++ b/.gitignore @@ -117,6 +117,7 @@ cmake_install.cmake /addons/skin.estouchy/media/Textures.xbt /addons/skin.pm3-hd/media/Textures.xbt /addons/audioencoder.* +/addons/web.* /addons/pvr.* /addons/peripheral.* /addons/game.* @@ -257,6 +258,7 @@ cmake_install.cmake /tools/android/packaging/xbmc/strings.xml #/tools/depends +/tools/depends/**/build /tools/depends/**/config.cache /tools/depends/**/config.log /tools/depends/**/config.status diff --git a/CMakeLists.txt b/CMakeLists.txt index ae7e76adf7bc1..b00c833c23feb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -114,6 +114,7 @@ set(INCLUDES ${CMAKE_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/lib ${CMAKE_SOURCE_DIR}/xbmc ${CMAKE_SOURCE_DIR}/xbmc/${PLATFORM_DIR} + ${CMAKE_SOURCE_DIR}/xbmc/addons/kodi-dev-kit ${CMAKE_SOURCE_DIR}/xbmc/cores/VideoPlayer ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR} ${CMAKE_BINARY_DIR}/${CORE_BUILD_DIR}/include) @@ -242,6 +243,9 @@ if(ENABLE_AIRTUNES) endif() endif() +list(APPEND DEP_DEFINES -DDEVKIT_LIBRARY="${DEVKIT_LIBRARY}") +list(APPEND DEP_DEFINES -DDEVKIT_LAUNCH_EXE="${DEVKIT_LAUNCH_EXE}") + # find all folders containing addon.xml.in # used to define ADDON_XML_OUTPUTS, ADDON_XML_DEPENDS and ADDON_INSTALL_DATA # Function defined in ./cmake/scripts/common/Macros.cmake @@ -342,9 +346,9 @@ if(CMAKE_GENERATOR STREQUAL Xcode) ) add_library(lib${APP_NAME_LC} STATIC) add_dependencies(lib${APP_NAME_LC} compileinfo) - target_link_libraries(lib${APP_NAME_LC} PUBLIC compileinfo_obj) + target_link_libraries(lib${APP_NAME_LC} PUBLIC compileinfo_obj $) else() - add_library(lib${APP_NAME_LC} STATIC $) + add_library(lib${APP_NAME_LC} STATIC $ $) endif() add_dependencies(lib${APP_NAME_LC} ${GLOBAL_TARGET_DEPS}) set_target_properties(lib${APP_NAME_LC} PROPERTIES PREFIX "") diff --git a/addons/kodi.binary.devkit/addon.xml.in b/addons/kodi.binary.devkit/addon.xml.in new file mode 100644 index 0000000000000..0fabe408f8023 --- /dev/null +++ b/addons/kodi.binary.devkit/addon.xml.in @@ -0,0 +1,8 @@ + + + + @__KDK_CANARY_XML__@ + + + + diff --git a/addons/kodi.binary.global.audioengine/addon.xml.in b/addons/kodi.binary.global.audioengine/addon.xml.in deleted file mode 100644 index 64301a63fecc4..0000000000000 --- a/addons/kodi.binary.global.audioengine/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.global.filesystem/addon.xml.in b/addons/kodi.binary.global.filesystem/addon.xml.in deleted file mode 100644 index 71955fb741b95..0000000000000 --- a/addons/kodi.binary.global.filesystem/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.global.general/addon.xml.in b/addons/kodi.binary.global.general/addon.xml.in deleted file mode 100644 index 119c803363168..0000000000000 --- a/addons/kodi.binary.global.general/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.global.gui/addon.xml.in b/addons/kodi.binary.global.gui/addon.xml.in deleted file mode 100644 index d3f453f744379..0000000000000 --- a/addons/kodi.binary.global.gui/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.global.main/addon.xml.in b/addons/kodi.binary.global.main/addon.xml.in deleted file mode 100644 index f60bbb5562063..0000000000000 --- a/addons/kodi.binary.global.main/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.global.network/addon.xml.in b/addons/kodi.binary.global.network/addon.xml.in deleted file mode 100644 index dd56be41aa36a..0000000000000 --- a/addons/kodi.binary.global.network/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.global.tools/addon.xml.in b/addons/kodi.binary.global.tools/addon.xml.in deleted file mode 100644 index f96576aff28d9..0000000000000 --- a/addons/kodi.binary.global.tools/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.instance.audiodecoder/addon.xml.in b/addons/kodi.binary.instance.audiodecoder/addon.xml.in deleted file mode 100644 index 50ce7e4264e24..0000000000000 --- a/addons/kodi.binary.instance.audiodecoder/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.instance.audioencoder/addon.xml.in b/addons/kodi.binary.instance.audioencoder/addon.xml.in deleted file mode 100644 index 31d5cf61d6e94..0000000000000 --- a/addons/kodi.binary.instance.audioencoder/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.instance.game/addon.xml.in b/addons/kodi.binary.instance.game/addon.xml.in deleted file mode 100644 index b8b379d2defa6..0000000000000 --- a/addons/kodi.binary.instance.game/addon.xml.in +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - diff --git a/addons/kodi.binary.instance.game/controller.xsd b/addons/kodi.binary.instance.game/controller.xsd deleted file mode 100644 index 13e9e0cf26e67..0000000000000 --- a/addons/kodi.binary.instance.game/controller.xsd +++ /dev/null @@ -1,17 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/addons/kodi.binary.instance.imagedecoder/addon.xml.in b/addons/kodi.binary.instance.imagedecoder/addon.xml.in deleted file mode 100644 index b6eae4e900c2f..0000000000000 --- a/addons/kodi.binary.instance.imagedecoder/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.instance.inputstream/addon.xml.in b/addons/kodi.binary.instance.inputstream/addon.xml.in deleted file mode 100644 index 21f604212dc99..0000000000000 --- a/addons/kodi.binary.instance.inputstream/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.instance.peripheral/addon.xml.in b/addons/kodi.binary.instance.peripheral/addon.xml.in deleted file mode 100644 index 99165f1830666..0000000000000 --- a/addons/kodi.binary.instance.peripheral/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.instance.pvr/addon.xml.in b/addons/kodi.binary.instance.pvr/addon.xml.in deleted file mode 100644 index fce51e6ce8092..0000000000000 --- a/addons/kodi.binary.instance.pvr/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.instance.pvr/icon.png b/addons/kodi.binary.instance.pvr/icon.png deleted file mode 100644 index 154968fc6c741..0000000000000 Binary files a/addons/kodi.binary.instance.pvr/icon.png and /dev/null differ diff --git a/addons/kodi.binary.instance.screensaver/addon.xml.in b/addons/kodi.binary.instance.screensaver/addon.xml.in deleted file mode 100644 index b11831d2526f1..0000000000000 --- a/addons/kodi.binary.instance.screensaver/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.instance.vfs/addon.xml.in b/addons/kodi.binary.instance.vfs/addon.xml.in deleted file mode 100644 index 248bcccd36fe1..0000000000000 --- a/addons/kodi.binary.instance.vfs/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.instance.videocodec/addon.xml.in b/addons/kodi.binary.instance.videocodec/addon.xml.in deleted file mode 100644 index c3b035cc16397..0000000000000 --- a/addons/kodi.binary.instance.videocodec/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/kodi.binary.instance.visualization/addon.xml.in b/addons/kodi.binary.instance.visualization/addon.xml.in deleted file mode 100644 index ab828695725cf..0000000000000 --- a/addons/kodi.binary.instance.visualization/addon.xml.in +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/addons/resource.language.en_gb/resources/strings.po b/addons/resource.language.en_gb/resources/strings.po index a96abc8bed813..69243a0ca2b8d 100644 --- a/addons/resource.language.en_gb/resources/strings.po +++ b/addons/resource.language.en_gb/resources/strings.po @@ -1048,7 +1048,11 @@ msgctxt "#222" msgid "Cancel" msgstr "" -#empty string with id 223 +#. Label for main button in list +#: addons/skin.estuary/xml/Home.xml +msgctxt "#223" +msgid "Internet" +msgstr "" msgctxt "#224" msgid "Speed" @@ -3899,7 +3903,95 @@ msgctxt "#852" msgid "Valid port range is 1024-65535" msgstr "" -#empty strings from id 853 to 996 +#empty strings from id 853 to 910 + +#. Main Window Entry to select web browser +#: xbmc/addons/Skin.cpp +msgctxt "#911" +msgid "Internet" +msgstr "" + +#. Keyboard Header text to write requested URL on fullscreen view +#: xbmc/windows/GUIWindowWebBrowserFullScreen.cpp +msgctxt "#912" +msgid "Enter URL to open" +msgstr "" + +#. Fullscreen browser view context menu entry to select Home URL +#: xbmc/windows/GUIWindowWebBrowserFullScreen.cpp +msgctxt "#913" +msgid "Home" +msgstr "" + +#. Fullscreen browser view context menu entry to reload website +#: xbmc/windows/GUIWindowWebBrowserFullScreen.cpp +msgctxt "#914" +msgid "Reload" +msgstr "" + +#. Fullscreen browser view context menu entry to go one site back +#: xbmc/windows/GUIWindowWebBrowserFullScreen.cpp +msgctxt "#915" +msgid "Go back" +msgstr "" + +#. Fullscreen browser view context menu entry to go one site forward (if possible) +#: xbmc/windows/GUIWindowWebBrowserFullScreen.cpp +msgctxt "#916" +msgid "Go forward" +msgstr "" + +#. Fullscreen browser view context menu entry to close fullscreen view +#: xbmc/windows/GUIWindowWebBrowserFullScreen.cpp +msgctxt "#917" +msgid "Close fullscreen" +msgstr "" + +#. Help of web side control handle time out +#: system/settings/settings.xml +msgctxt "#918" +msgid "Time after opened websites becomes automatically closed" +msgstr "" + +#. Default title of new opened website +#: xbmc/web/windows/GUIWindowWebBase.cpp +msgctxt "#919" +msgid "New side" +msgstr "" + +#. Context button to delete opened website with tab +#: xbmc/web/windows/GUIWindowWebBase.cpp +msgctxt "#920" +msgid "Close" +msgstr "" + +#. Context button to delete opened website with tab +#: xbmc/web/windows/GUIWindowWebBase.cpp +msgctxt "#921" +msgid "Close all others" +msgstr "" + +#. To add opened website over addon to favourites +#: xbmc/web/windows/GUIWindowWebBase.cpp +msgctxt "#922" +msgid "Add to favourites" +msgstr "" + +#empty strings from id 920 to 949 + +msgctxt "#950" +msgid "Invalid port number entered" +msgstr "" + +msgctxt "#951" +msgid "Valid port range is 1-65535" +msgstr "" + +msgctxt "#952" +msgid "Valid port range is 1024-65535" +msgstr "" + +#empty strings from id 953 to 996 #: xbmc/windows/GUIMediaWindow.cpp msgctxt "#997" @@ -4156,7 +4248,17 @@ msgctxt "#1053" msgid "Choose whether requests to the web server require a username and a password, which must be set below if enabled. It is recommended to always leave this setting enabled." msgstr "" -#empty strings from id 1054 to 1179 +#empty strings from id 1054 to 1099 + +msgctxt "#1100" +msgid "Side back" +msgstr "" + +msgctxt "#1101" +msgid "Side forward" +msgstr "" + +#empty strings from id 1102 to 1179 #: system/settings/settings.xml msgctxt "#1180" @@ -4843,7 +4945,105 @@ msgctxt "#2204" msgid "Select this option if you want to passthrough DTS-HD formats as DTS, otherwise, DTS-HD formats will be played via PCM" msgstr "" -#empty strings from id 2205 to 9999 +#empty strings from id 2205 to 2293 + +#. Text viewer header text about add-on crash report to send for report +#: xbmc/addons/interface/GUICrashReporter.cpp +msgctxt "#2294" +msgid "Add-on crash report to send, confirm needed" +msgstr "" + +#. Dialog header text about add-on crash report +#: xbmc/addons/interface/GUICrashReporter.cpp +msgctxt "#2295" +msgid "Add-on crash report" +msgstr "" + +#. Dialog header about add-on crash report +#: xbmc/addons/interface/GUICrashReporter.cpp +msgctxt "#2296" +msgid "Add-on [B]\"{0:s}\"[/B] caused an unwanted crash.[CR]You can either ignore the crash and try again the next time you start Kodi, disable it now or send a crash report in addition to disabling it." +msgstr "" + +#. Dialog button about add-on crash report +#: xbmc/addons/interface/GUICrashReporter.cpp +msgctxt "#2297" +msgid "Ignore" +msgstr "" + +#. Dialog button about add-on crash report +#: xbmc/addons/interface/GUICrashReporter.cpp +msgctxt "#2298" +msgid "Disable" +msgstr "" + +#. Dialog button about add-on crash report +#: xbmc/addons/interface/GUICrashReporter.cpp +msgctxt "#2299" +msgid "Report" +msgstr "" + +#. Used to define based programming language of an add-on +#: xbmc/addons/addoninfo/AddonType.cpp +msgctxt "#2300" +msgid "Unknown" +msgstr "" + +#. Used to define based programming language of an add-on +#: xbmc/addons/addoninfo/AddonType.cpp +msgctxt "#2301" +msgid "C" +msgstr "" + +#. Used to define based programming language of an add-on +#: xbmc/addons/addoninfo/AddonType.cpp +msgctxt "#2302" +msgid "C++" +msgstr "" + +#. Used to define based programming language of an add-on +#: xbmc/addons/addoninfo/AddonType.cpp +msgctxt "#2303" +msgid "Groovy" +msgstr "" + +#. Used to define based programming language of an add-on +#: xbmc/addons/addoninfo/AddonType.cpp +msgctxt "#2304" +msgid "Java" +msgstr "" + +#. Used to define based programming language of an add-on +#: xbmc/addons/addoninfo/AddonType.cpp +msgctxt "#2305" +msgid "JavaScript" +msgstr "" + +#. Used to define based programming language of an add-on +#: xbmc/addons/addoninfo/AddonType.cpp +msgctxt "#2306" +msgid "Python 3" +msgstr "" + +#. Used to define based programming language of an add-on +#: xbmc/addons/addoninfo/AddonType.cpp +msgctxt "#2307" +msgid "Ruby" +msgstr "" + +#. Used to define based programming language of an add-on +#: xbmc/addons/addoninfo/AddonType.cpp +msgctxt "#2308" +msgid "Skin" +msgstr "" + +#. Used to define based programming language of an add-on +#: xbmc/addons/addoninfo/AddonType.cpp +msgctxt "#2309" +msgid "XML" +msgstr "" + +#empty strings from id 2310 to 9999 #: xbmc/guilib/WindowIDs.h msgctxt "#10000" @@ -6602,7 +6802,37 @@ msgctxt "#13253" msgid "Cancel move" msgstr "" -#empty strings from id 13254 to 13269 +#: addons/skin.estuary/xml/SettingsSystemInfo.xml +msgctxt "#13254" +msgid "CPU usage:" +msgstr "" + +#: addons/skin.estuary/xml/SettingsSystemInfo.xml +msgctxt "#13255" +msgid "Physical memory usage:" +msgstr "" + +#: addons/skin.estuary/xml/SettingsSystemInfo.xml +msgctxt "#13256" +msgid "Virtual memory usage:" +msgstr "" + +#: addons/skin.estuary/xml/SettingsSystemInfo.xml +msgctxt "#13257" +msgid "Shared memory usage:" +msgstr "" + +#: addons/skin.estuary/xml/SettingsSystemInfo.xml +msgctxt "#13258" +msgid "Threads:" +msgstr "" + +#: addons/skin.estuary/xml/SettingsSystemInfo.xml +msgctxt "#13259" +msgid "Process ID:" +msgstr "" + +#empty strings from id 13260 to 13269 msgctxt "#13270" msgid "Hardware:" @@ -6651,7 +6881,10 @@ msgctxt "#13281" msgid "Hardware" msgstr "" -#empty string with id 13282 +#: addons/skin.estuary/xml/SettingsSystemInfo.xml +msgctxt "#13282" +msgid "Addons" +msgstr "" #: xbmc/windows/GUIWindowSystemInfo.cpp msgctxt "#13283" @@ -7958,7 +8191,15 @@ msgctxt "#14071" msgid "Allow file renaming and deletion" msgstr "" -#empty strings from id 14072 to 14073 +#: xbmc/web/dialogs/GUIDialogFavourites.cpp +msgctxt "#14072" +msgid "Open favourite" +msgstr "" + +#: xbmc/web/dialogs/GUIDialogFavourites.cpp +msgctxt "#14073" +msgid "Remove all favourites" +msgstr "" msgctxt "#14074" msgid "Set timezone" @@ -7970,6 +8211,7 @@ msgstr "" #: xbmc/windows/GUIMediaWindow.cpp #: xbmc/windows/GUIWindowFileManager.cpp +#: xbmc/web/dialogs/GUIDialogFavourites.cpp msgctxt "#14076" msgid "Add to favourites" msgstr "" @@ -15503,7 +15745,6 @@ msgstr "" #: addons/skin.estuary/xml/DialogAddonInfo.xml msgctxt "#24049" msgid "Add-on has been marked deprecated in repository." -msgstr "" #: unknown msgctxt "#24050" @@ -16852,7 +17093,11 @@ msgctxt "#29985" msgid "If traffic advisory is send from RDS, volume is increased" msgstr "" -#empty string with id 29986 +#. Used to define addon group name in selection folder and to descripe addon +#: xbmc/addons/addoninfo/AddonInfo.cpp +msgctxt "#29986" +msgid "Internet add-ons" +msgstr "" #. Node title for music artist role, plural of #38036 #: system/library/music/musicroles/Remixers.xml diff --git a/addons/skin.estuary/media/DefaultAddonWeb.png b/addons/skin.estuary/media/DefaultAddonWeb.png new file mode 100644 index 0000000000000..511e7c21fed18 Binary files /dev/null and b/addons/skin.estuary/media/DefaultAddonWeb.png differ diff --git a/addons/skin.estuary/media/web/back.png b/addons/skin.estuary/media/web/back.png new file mode 100644 index 0000000000000..5b02eff304118 Binary files /dev/null and b/addons/skin.estuary/media/web/back.png differ diff --git a/addons/skin.estuary/media/web/buttonside-add-fo.png b/addons/skin.estuary/media/web/buttonside-add-fo.png new file mode 100644 index 0000000000000..1a05857bb199a Binary files /dev/null and b/addons/skin.estuary/media/web/buttonside-add-fo.png differ diff --git a/addons/skin.estuary/media/web/buttonside-add-fo.xcf b/addons/skin.estuary/media/web/buttonside-add-fo.xcf new file mode 100644 index 0000000000000..29cd3fa31a626 Binary files /dev/null and b/addons/skin.estuary/media/web/buttonside-add-fo.xcf differ diff --git a/addons/skin.estuary/media/web/buttonside-add-nofo.png b/addons/skin.estuary/media/web/buttonside-add-nofo.png new file mode 100644 index 0000000000000..257bc0892a720 Binary files /dev/null and b/addons/skin.estuary/media/web/buttonside-add-nofo.png differ diff --git a/addons/skin.estuary/media/web/buttonside-add-nofo.xcf b/addons/skin.estuary/media/web/buttonside-add-nofo.xcf new file mode 100644 index 0000000000000..545a73785a9cb Binary files /dev/null and b/addons/skin.estuary/media/web/buttonside-add-nofo.xcf differ diff --git a/addons/skin.estuary/media/web/buttonside-add.png b/addons/skin.estuary/media/web/buttonside-add.png new file mode 100644 index 0000000000000..4d784d7394c14 Binary files /dev/null and b/addons/skin.estuary/media/web/buttonside-add.png differ diff --git a/addons/skin.estuary/media/web/buttonside-add.xcf b/addons/skin.estuary/media/web/buttonside-add.xcf new file mode 100644 index 0000000000000..213c6abf7fa99 Binary files /dev/null and b/addons/skin.estuary/media/web/buttonside-add.xcf differ diff --git a/addons/skin.estuary/media/web/buttonside-fo.png b/addons/skin.estuary/media/web/buttonside-fo.png new file mode 100644 index 0000000000000..4907e0209cc64 Binary files /dev/null and b/addons/skin.estuary/media/web/buttonside-fo.png differ diff --git a/addons/skin.estuary/media/web/buttonside-nofo.png b/addons/skin.estuary/media/web/buttonside-nofo.png new file mode 100644 index 0000000000000..fa8045d6f1956 Binary files /dev/null and b/addons/skin.estuary/media/web/buttonside-nofo.png differ diff --git a/addons/skin.estuary/media/web/buttonside-nofo.xcf b/addons/skin.estuary/media/web/buttonside-nofo.xcf new file mode 100644 index 0000000000000..fb8db8e6b572a Binary files /dev/null and b/addons/skin.estuary/media/web/buttonside-nofo.xcf differ diff --git a/addons/skin.estuary/media/web/control_selected.png b/addons/skin.estuary/media/web/control_selected.png new file mode 100644 index 0000000000000..12b3033016253 Binary files /dev/null and b/addons/skin.estuary/media/web/control_selected.png differ diff --git a/addons/skin.estuary/media/web/download.png b/addons/skin.estuary/media/web/download.png new file mode 100644 index 0000000000000..4ab251567cfa4 Binary files /dev/null and b/addons/skin.estuary/media/web/download.png differ diff --git a/addons/skin.estuary/media/web/favourites.png b/addons/skin.estuary/media/web/favourites.png new file mode 100644 index 0000000000000..f017a4cbd6775 Binary files /dev/null and b/addons/skin.estuary/media/web/favourites.png differ diff --git a/addons/skin.estuary/media/web/forward.png b/addons/skin.estuary/media/web/forward.png new file mode 100644 index 0000000000000..ff20d21eefced Binary files /dev/null and b/addons/skin.estuary/media/web/forward.png differ diff --git a/addons/skin.estuary/media/web/fullscreen.png b/addons/skin.estuary/media/web/fullscreen.png new file mode 100644 index 0000000000000..ef007e151eb21 Binary files /dev/null and b/addons/skin.estuary/media/web/fullscreen.png differ diff --git a/addons/skin.estuary/media/web/home.png b/addons/skin.estuary/media/web/home.png new file mode 100644 index 0000000000000..4a6c61302f1dc Binary files /dev/null and b/addons/skin.estuary/media/web/home.png differ diff --git a/addons/skin.estuary/media/web/menu.png b/addons/skin.estuary/media/web/menu.png new file mode 100644 index 0000000000000..96bd0c4f066cb Binary files /dev/null and b/addons/skin.estuary/media/web/menu.png differ diff --git a/addons/skin.estuary/media/web/note_background.png b/addons/skin.estuary/media/web/note_background.png new file mode 100644 index 0000000000000..57043cc2da634 Binary files /dev/null and b/addons/skin.estuary/media/web/note_background.png differ diff --git a/addons/skin.estuary/media/web/search.png b/addons/skin.estuary/media/web/search.png new file mode 100644 index 0000000000000..915e95293164d Binary files /dev/null and b/addons/skin.estuary/media/web/search.png differ diff --git a/addons/skin.estuary/media/web/update.png b/addons/skin.estuary/media/web/update.png new file mode 100644 index 0000000000000..3600eabbd4e07 Binary files /dev/null and b/addons/skin.estuary/media/web/update.png differ diff --git a/addons/skin.estuary/xml/Custom_1109_TopBarOverlay.xml b/addons/skin.estuary/xml/Custom_1109_TopBarOverlay.xml index 8e48d57e08a89..fa228f2f5e6d8 100644 --- a/addons/skin.estuary/xml/Custom_1109_TopBarOverlay.xml +++ b/addons/skin.estuary/xml/Custom_1109_TopBarOverlay.xml @@ -1,7 +1,7 @@ Skin.TimerStart(1110_topbaroverlay) - Window.IsActive(fullscreenvideo) | Window.IsActive(visualisation) + Window.IsActive(fullscreenvideo) | Window.IsActive(visualisation) | Window.IsActive(webbrowserfullscreen) | Window.IsActive(webbrowser) Window.IsActive(seekbar) | Window.IsActive(pvrosdchannels) | Window.IsActive(pvrchannelguide) DepthOSD Animation_TopSlide diff --git a/addons/skin.estuary/xml/DialogAddonCrashReporter.xml b/addons/skin.estuary/xml/DialogAddonCrashReporter.xml new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/addons/skin.estuary/xml/DialogExtendedProgressBar.xml b/addons/skin.estuary/xml/DialogExtendedProgressBar.xml index 93bb34275598d..333ea2e311e19 100644 --- a/addons/skin.estuary/xml/DialogExtendedProgressBar.xml +++ b/addons/skin.estuary/xml/DialogExtendedProgressBar.xml @@ -10,7 +10,7 @@ 80 0 conditional - conditional + conditional 20 10 diff --git a/addons/skin.estuary/xml/DialogSeekBar.xml b/addons/skin.estuary/xml/DialogSeekBar.xml index 7969f9803d09a..2ab66c4e0c06d 100644 --- a/addons/skin.estuary/xml/DialogSeekBar.xml +++ b/addons/skin.estuary/xml/DialogSeekBar.xml @@ -2,7 +2,7 @@ Player.Seeking | Player.HasPerformedSeek(3) | [Player.Paused + !Player.Caching] | Player.Forwarding | Player.Rewinding | Player.ShowInfo | Window.IsActive(fullscreeninfo) | Player.ShowTime | Window.IsActive(videoosd) | Window.IsActive(musicosd) | Window.IsActive(playerprocessinfo) | !String.IsEmpty(Player.SeekNumeric) | !String.IsEmpty(PVR.ChannelNumberInput) ![Window.IsActive(sliderdialog) | Window.IsActive(pvrosdchannels) | Window.IsActive(pvrchannelguide) | Window.IsActive(pvrguideinfo) | Window.IsActive(1110)] - Window.IsActive(fullscreenvideo) | Window.IsActive(visualisation) + Window.IsActive(fullscreenvideo) | Window.IsActive(visualisation) | Window.IsActive(webbrowserfullscreen) | Window.IsActive(webbrowser) Animation_BottomSlide DepthOSD 0 diff --git a/addons/skin.estuary/xml/DialogVolumeBar.xml b/addons/skin.estuary/xml/DialogVolumeBar.xml index 2ac0aa6e0b205..19037c5db217e 100644 --- a/addons/skin.estuary/xml/DialogVolumeBar.xml +++ b/addons/skin.estuary/xml/DialogVolumeBar.xml @@ -20,7 +20,7 @@ 88 88 osd/buffer-bg.png - Window.IsActive(fullscreenvideo) | Window.IsActive(FullscreenGame) | Window.IsActive(slideshow) + Window.IsActive(fullscreenvideo) | Window.IsActive(FullscreenGame) | Window.IsActive(slideshow) | Window.IsActive(webbrowserfullscreen) | Window.IsActive(webbrowser) 22 diff --git a/addons/skin.estuary/xml/Home.xml b/addons/skin.estuary/xml/Home.xml index 9db8d8990215a..513ae3870151a 100644 --- a/addons/skin.estuary/xml/Home.xml +++ b/addons/skin.estuary/xml/Home.xml @@ -817,6 +817,179 @@ + + String.IsEqual(Container(9000).ListItem.Property(id),web) + + + + + + 0 + 110 + 0 + 363 + 9000 + 9000 + 22200 + 22200 + 500 + horizontal + 30 + left + 22010 + Integer.IsGreater(Container(22100).NumItems,0) | Container(22100).IsUpdating + + + 5 + 60 + + 475 + 268 + dialogs/dialog-bg-nobo.png + overlays/shadow.png + 10 + + + 475 + 268 + + + + + + DepthContentPopout + 5 + 60 + + + + + + + + 475 + 268 + dialogs/dialog-bg-nobo.png + overlays/shadow.png + 10 + + + -4 + -4 + 483 + 276 + colors/grey.png + Animation_FocusTextureFade + + + 475 + 268 + + + + web://sites/running/ + + + + Integer.IsEqual(Container(22100).NumItems,0) + 35 + 80 + + 20 + 40 + center + font35 + text_shadow + + + + + 40 + 40 + 40 + 50 + 9000 + 9000 + 22100 + 22100 + 2 + 500 + 22010 + Integer.IsGreater(Container(22200).NumItems,0) | Container(22200).IsUpdating + + + + + + + + + + + DepthContentPopout + Focus + UnFocus + + + + + + + web://sites/favourites/ + + + + Integer.IsGreater(Container(22100).NumItems,0) + 35 + 410 + + 20 + 40 + center + font35 + text_shadow + + + + + 40 + 40 + 40 + 50 + 9000 + 9000 + 22100 + 22100 + 2 + 500 + 22010 + Integer.IsGreater(Container(22200).NumItems,0) | Container(22200).IsUpdating + + + + + + + + + + + DepthContentPopout + Focus + UnFocus + + + + + + + web://sites/favourites/ + + + + + + DepthContentPanel @@ -996,6 +1169,14 @@ video !Skin.HasSetting(HomeMenuNoVideosButton) + + + ActivateWindow(WebBrowser) + $NUMBER[22000] + icons/sidemenu/internet.png + web + Web.HasAddons + ActivateWindow(favourites) diff --git a/addons/skin.estuary/xml/Includes.xml b/addons/skin.estuary/xml/Includes.xml index 4e1452ddcc47b..0dbcab3d133e6 100644 --- a/addons/skin.estuary/xml/Includes.xml +++ b/addons/skin.estuary/xml/Includes.xml @@ -1196,7 +1196,7 @@ conditional DepthBars WindowClose - WindowOpen + WindowOpen 0 0 diff --git a/addons/skin.estuary/xml/MyWebBrowser.xml b/addons/skin.estuary/xml/MyWebBrowser.xml new file mode 100644 index 0000000000000..78681ad7447c9 --- /dev/null +++ b/addons/skin.estuary/xml/MyWebBrowser.xml @@ -0,0 +1,321 @@ + + + 110 + background + + DefaultBackground + + WindowOpen + WindowClose + + 0 + 150 + + + colors/black.png + + + web browser + 9001 + 121 + 51 + 51 + false + true + browser + FFFFFFFF + + + 645 + 645 + 0 + 16 + web/control_selected.png + Control.HasFocus(2) + + + + + 0 + 0 + 420 + 33 + !String.IsEmpty(WebControl.ToolTip) + + Tooltip + font12 + right + false + web/note_background.png + + + Tooltip string + 360 + font12 + right + true + white + black + + + + + 0 + 150 + 420 + 33 + !String.IsEmpty(WebControl.StatusMessage) + + Status + font12 + false + web/note_background.png + + + Status string + 360 + font12 + true + white + black + + + + + 50 + 9000 + + Back + 80 + 20 + 60 + 60 + 52 + 9002 + WebControlCmd.Message(2,Back) + WebControl.CanGoBack + web/back.png + web/back.png + !WebControl.CanGoBack + web/back.png + web/back.png + center + + + Forward + 80 + 100 + 60 + 60 + 9001 + 110 + WebControlCmd.Message(2,Fwd) + WebControl.CanGoForward + web/forward.png + web/forward.png + !WebControl.CanGoForward + web/forward.png + web/forward.png + + + URL string + SettingsItemCommon + 60 + 170 + 800 + 9002 + 104 + 50 + 9000 + + + Reload + 60 + 60 + 80 + 740 + 110 + 105 + WebControlCmd.Message(2,Reload) + web/update.png + web/update.png + !Control.IsEnabled(104) + web/update.png + + + Favourites + 60 + 60 + 80 + 670 + 104 + 106 + WebControlCmd.Message(2,Favourites) + web/favourites.png + web/favourites.png + + + Home + 60 + 60 + 80 + 600 + 105 + 52 + WebControlCmd.Message(2,Home) + web/home.png + web/home.png + + + + 20 + 80 + 565 + 70 + 5 + 51 + 51 + 50 + 9000 + horizontal + center + + 40 + 60 + web/search.png + web/search.png + + + Search string + 430 + 70 + font12 + 40 + $LOCALIZE[31103] + + + Menu + 30 + 70 + WebControlCmd.Message(2,Settings) + web/menu.png + web/menu.png + + + 40 + 70 + ActivateWindow(WebBrowserFullScreen) + web/fullscreen.png + web/fullscreen.png + + + + 20 + 10 + 1320 + 70 + 0 + 51 + 50 + 51 + 52 + horizontal + + + String.IsEqual(ListItem.Property(type),website) + 10 + + -50 + 480 + 60 + web/buttonside-nofo.png + + + 5 + 5 + 48 + 48 + $INFO[listitem.icon] + + + 60 + 9 + 330 + font13 + center + green + left + ListItem.Label + + + + String.IsEqual(ListItem.Property(type),add) + 10 + + -50 + 100 + 60 + web/buttonside-nofo.png + + + + + + String.IsEqual(ListItem.Property(type),website) + 10 + + -50 + 480 + 60 + web/buttonside-fo.png + + + 5 + 5 + 48 + 48 + $INFO[listitem.icon] + + + 60 + 9 + 330 + font13 + center + green + left + ListItem.Label + + + + String.IsEqual(ListItem.Property(type),add) + 10 + + -50 + 100 + 60 + web/buttonside-fo.png + + + + + + 20 + 500 + 80 + 40 + right + conditional + + OpenClose_Right + + + 15 + 15 + 50 + 50 + $INFO[WebControl.IconURL] + + + + diff --git a/addons/skin.estuary/xml/PlayerControls.xml b/addons/skin.estuary/xml/PlayerControls.xml index bf1aca89f4485..16904fc2309da 100644 --- a/addons/skin.estuary/xml/PlayerControls.xml +++ b/addons/skin.estuary/xml/PlayerControls.xml @@ -1,7 +1,7 @@ 201 - Player.HasMedia + Window.IsActive(PlayerControls) + !Window.IsActive(FullscreenVideo) + !Window.IsActive(FullscreenGame) + !Window.IsActive(Visualisation) + Player.HasMedia + Window.IsActive(PlayerControls) + !Window.IsActive(FullscreenVideo) + !Window.IsActive(FullscreenGame) + !Window.IsActive(Visualisation) + !Window.IsActive(webbrowserfullscreen) + !Window.IsActive(webbrowser) Animation_DialogPopupOpenClose diff --git a/addons/skin.estuary/xml/SettingsSystemInfo.xml b/addons/skin.estuary/xml/SettingsSystemInfo.xml index a0bec86593e57..d8e91f37e8f58 100644 --- a/addons/skin.estuary/xml/SettingsSystemInfo.xml +++ b/addons/skin.estuary/xml/SettingsSystemInfo.xml @@ -80,29 +80,271 @@ Mono26 - - 420 - 50 - 30 - 347 - 60 - !Control.HasFocus(60) + + + 420 + 50 + 30 + 347 + 60 + !Control.HasFocus(60) + + + 0 + 0 + 12 + 340 + vertical + + conditional + 30 + 9000 + Control.IsVisible(30) + Visible + Hidden + WindowOpen + WindowClose + - - 0 - 0 - 12 - 340 - vertical - - conditional - 9000 - 9000 - Control.IsVisible(30) - Visible - Hidden - WindowOpen - WindowClose + + + 420 + 40 + 30 + 347 + 9000 + 61 + 61 + vertical + + + 10 + 10 + 100 + 100 + $INFO[ListItem.Art(icon)] + + + 130 + 10 + 20 + 35 + center + white + green + ListItem.Label + + + CPU Text + 130 + 50 + auto + 35 + + center + black + font12 + System.SupportsCPUUsage + + + Threads Text + 110 + 50 + 610 + 35 + + center + right + black + font12 + System.SupportsCPUUsage + + + CPU BAR + 120 + 85 + 610 + 16 + ListItem.Property(cpuusage) + System.SupportsCPUUsage + + + Physical Memory Text + 800 + 10 + auto + 35 + + center + black + font12 + System.SupportsCPUUsage + + + Virtual Memory Text + 800 + 45 + auto + 35 + + center + black + font12 + System.SupportsCPUUsage + + + Shared Memory Text + 800 + 80 + auto + 35 + + center + black + font12 + System.SupportsCPUUsage + + + Addon Process Id + 230 + 10 + auto + 35 + + center + right + black + font12 + System.SupportsCPUUsage + + + + + 0 + 0 + 0 + 0 + lists/focus.png + Control.HasFocus(29) + + + 10 + 10 + 100 + 100 + $INFO[ListItem.Art(icon)] + + + 130 + 10 + 20 + 35 + center + white + green + ListItem.Label + + + CPU Text + 130 + 50 + auto + 35 + + center + black + font12 + System.SupportsCPUUsage + + + Threads Text + 110 + 50 + 610 + 35 + + center + right + black + font12 + System.SupportsCPUUsage + + + CPU BAR + 120 + 85 + 610 + 16 + ListItem.Property(cpuusage) + System.SupportsCPUUsage + + + Physical Memory Text + 800 + 10 + auto + 35 + + center + black + font12 + System.SupportsCPUUsage + + + Virtual Memory Text + 800 + 45 + auto + 35 + + center + black + font12 + System.SupportsCPUUsage + + + Shared Memory Text + 800 + 80 + auto + 35 + + center + black + font12 + System.SupportsCPUUsage + + + Addon Process Id + 230 + 10 + auto + 35 + + center + right + black + font12 + System.SupportsCPUUsage + + + + + 0 + 0 + 12 + 340 + vertical + + conditional + 29 + 9000 + Control.IsVisible(29) + Visible + Hidden + WindowOpen + WindowClose + 380 @@ -168,6 +410,15 @@ 420 + + Button Addons + 29 + + + + 420 + + Button PVR diff --git a/addons/skin.estuary/xml/View_54_InfoWall.xml b/addons/skin.estuary/xml/View_54_InfoWall.xml index f014a5c6d9731..2f19505fcd0e6 100644 --- a/addons/skin.estuary/xml/View_54_InfoWall.xml +++ b/addons/skin.estuary/xml/View_54_InfoWall.xml @@ -43,6 +43,51 @@ + + DefaultFolder.png + false + + + 0 + 300 + 330 + dialogs/dialog-bg-nobo.png + overlays/shadow.png + 20 + + + -4 + -4 + 308 + 338 + colors/grey.png + overlays/shadow.png + 20 + $PARAM[focused] + Animation_FocusTextureFade + + + 20 + 20 + 258 + 258 + $VAR[InfoWallThumbVar] + keep + 20 + + + 0 + 270 + 298 + 20 + 20 + center + center + font12 + + + + DefaultFolder.png $INFO[ListItem.Artist] diff --git a/cmake/FindSWIG.cmake b/cmake/FindSWIG.cmake new file mode 100644 index 0000000000000..fba544baa2979 --- /dev/null +++ b/cmake/FindSWIG.cmake @@ -0,0 +1,29 @@ +#.rst: +# FindSWIG +# -------- +# Finds the SWIG executable +# +# This will define the following variables:: +# +# SWIG_FOUND - system has SWIG +# SWIG_EXECUTABLE - the SWIG executable + +find_program(SWIG_EXECUTABLE NAMES swig4.0 swig3.0 swig2.0 swig + PATH_SUFFIXES swig) +if(SWIG_EXECUTABLE) + execute_process(COMMAND ${SWIG_EXECUTABLE} -swiglib + OUTPUT_VARIABLE SWIG_DIR + ERROR_VARIABLE SWIG_swiglib_error + RESULT_VARIABLE SWIG_swiglib_result) + execute_process(COMMAND ${SWIG_EXECUTABLE} -version + OUTPUT_VARIABLE SWIG_version_output + ERROR_VARIABLE SWIG_version_output + RESULT_VARIABLE SWIG_version_result) + string(REGEX REPLACE ".*SWIG Version[^0-9.]*\([0-9.]+\).*" "\\1" + SWIG_VERSION "${SWIG_version_output}") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(SWIG + REQUIRED_VARS SWIG_EXECUTABLE SWIG_DIR + VERSION_VAR SWIG_VERSION) diff --git a/cmake/addons/bootstrap/repositories/binary-addons.txt b/cmake/addons/bootstrap/repositories/binary-addons.txt index d286ad7b02a80..c5e0f066fa1c5 100644 --- a/cmake/addons/bootstrap/repositories/binary-addons.txt +++ b/cmake/addons/bootstrap/repositories/binary-addons.txt @@ -1 +1 @@ -binary-addons https://github.com/xbmc/repo-binary-addons.git Nexus +binary-addons https://github.com/AlwinEsch/repo-binary-addons.git master diff --git a/cmake/installdata/common/addons.txt b/cmake/installdata/common/addons.txt index 263e57bb66cbd..b694aa33d6603 100644 --- a/cmake/installdata/common/addons.txt +++ b/cmake/installdata/common/addons.txt @@ -33,6 +33,7 @@ addons/script.module.pil/* addons/script.module.pycryptodome/* addons/service.xbmc.versioncheck/* addons/webinterface.default/* +addons/kodi.web/* addons/xbmc.addon/metadata.xsd addons/xbmc.addon/repository.xsd addons/xbmc.audioencoder/* diff --git a/cmake/modules/UseSWIG.cmake b/cmake/modules/UseSWIG.cmake new file mode 100644 index 0000000000000..b47a8cb055ddc --- /dev/null +++ b/cmake/modules/UseSWIG.cmake @@ -0,0 +1,873 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +UseSWIG +------- + +This file provides support for ``SWIG``. It is assumed that :module:`FindSWIG` +module has already been loaded. + +Defines the following command for use with ``SWIG``: + +.. command:: swig_add_library + + Define swig module with given name and specified language:: + + swig_add_library( + [TYPE ] + LANGUAGE + [NO_PROXY] + [OUTPUT_DIR ] + [OUTFILE_DIR ] + SOURCES ... + ) + + Targets created with the ``swig_add_library`` command have the same + capabilities as targets created with the :command:`add_library` command, so + those targets can be used with any command expecting a target (e.g. + :command:`target_link_libraries`). + + .. note:: + + This command creates a target with the specified ```` when + policy :policy:`CMP0078` is set to ``NEW``. Otherwise, the legacy + behavior will choose a different target name and store it in the + ``SWIG_MODULE__REAL_NAME`` variable. + + .. note:: + + For multi-config generators, this module does not support + configuration-specific files generated by ``SWIG``. All build + configurations must result in the same generated source file. + + .. note:: + + For Make-based generators, ``swig_add_library`` does not track file + dependencies, so depending on the ``_swig_compilation`` custom target + is required for targets which require the ``swig``-generated files to + exist. Other generators may depend on the source files that would be + generated by SWIG. + + ``TYPE`` + ``SHARED``, ``MODULE`` and ``STATIC`` have the same semantic as for the + :command:`add_library` command. If ``USE_BUILD_SHARED_LIBS`` is specified, + the library type will be ``STATIC`` or ``SHARED`` based on whether the + current value of the :variable:`BUILD_SHARED_LIBS` variable is ``ON``. If + no type is specified, ``MODULE`` will be used. + + ``LANGUAGE`` + Specify the target language. + + ``NO_PROXY`` + Prevent the generation of the wrapper layer (swig ``-noproxy`` option). + + ``OUTPUT_DIR`` + Specify where to write the language specific files (swig ``-outdir`` + option). If not given, the ``CMAKE_SWIG_OUTDIR`` variable will be used. + If neither is specified, the default depends on the value of the + ``UseSWIG_MODULE_VERSION`` variable as follows: + + * If ``UseSWIG_MODULE_VERSION`` is 1 or is undefined, output is written to + the :variable:`CMAKE_CURRENT_BINARY_DIR` directory. + * If ``UseSWIG_MODULE_VERSION`` is 2, a dedicated directory will be used. + The path of this directory can be retrieved from the + ``SWIG_SUPPORT_FILES_DIRECTORY`` target property. + + ``OUTFILE_DIR`` + Specify an output directory name where the generated source file will be + placed (swig -o option). If not specified, the ``SWIG_OUTFILE_DIR`` variable + will be used. If neither is specified, ``OUTPUT_DIR`` or + ``CMAKE_SWIG_OUTDIR`` is used instead. + + ``SOURCES`` + List of sources for the library. Files with extension ``.i`` will be + identified as sources for the ``SWIG`` tool. Other files will be handled in + the standard way. This behavior can be overriden by specifying the variable + ``SWIG_SOURCE_FILE_EXTENSIONS``. + + .. note:: + + If ``UseSWIG_MODULE_VERSION`` is set to 2, it is **strongly** recommended + to use a dedicated directory unique to the target when either the + ``OUTPUT_DIR`` option or the ``CMAKE_SWIG_OUTDIR`` variable are specified. + The output directory contents are erased as part of the target build, so + to prevent interference between targets or losing other important files, + each target should have its own dedicated output directory. + +.. command:: swig_link_libraries + + Link libraries to swig module:: + + swig_link_libraries( ...) + + This command has same capabilities as :command:`target_link_libraries` + command. + + .. note:: + + If variable ``UseSWIG_TARGET_NAME_PREFERENCE`` is set to ``STANDARD``, this + command is deprecated and :command:`target_link_libraries` command must be + used instead. + +Source file properties on module files **must** be set before the invocation +of the ``swig_add_library`` command to specify special behavior of SWIG and +ensure generated files will receive the required settings. + +``CPLUSPLUS`` + Call SWIG in c++ mode. For example: + + .. code-block:: cmake + + set_property(SOURCE mymod.i PROPERTY CPLUSPLUS ON) + swig_add_library(mymod LANGUAGE python SOURCES mymod.i) + +``INCLUDE_DIRECTORIES``, ``COMPILE_DEFINITIONS`` and ``COMPILE_OPTIONS`` + Add custom flags to SWIG compiler and have same semantic as properties + :prop_sf:`INCLUDE_DIRECTORIES`, :prop_sf:`COMPILE_DEFINITIONS` and + :prop_sf:`COMPILE_OPTIONS`. + +``USE_TARGET_INCLUDE_DIRECTORIES`` + If set to ``TRUE``, contents of target property + :prop_tgt:`INCLUDE_DIRECTORIES` will be forwarded to ``SWIG`` compiler. + If set to ``FALSE`` target property :prop_tgt:`INCLUDE_DIRECTORIES` will be + ignored. If not set, target property ``SWIG_USE_TARGET_INCLUDE_DIRECTORIES`` + will be considered. + +``GENERATED_INCLUDE_DIRECTORIES``, ``GENERATED_COMPILE_DEFINITIONS`` and ``GENERATED_COMPILE_OPTIONS`` + Add custom flags to the C/C++ generated source. They will fill, respectively, + properties :prop_sf:`INCLUDE_DIRECTORIES`, :prop_sf:`COMPILE_DEFINITIONS` and + :prop_sf:`COMPILE_OPTIONS` of generated C/C++ file. + +``DEPENDS`` + Specify additional dependencies to the source file. + +``SWIG_MODULE_NAME`` + Specify the actual import name of the module in the target language. + This is required if it cannot be scanned automatically from source + or different from the module file basename. For example: + + .. code-block:: cmake + + set_property(SOURCE mymod.i PROPERTY SWIG_MODULE_NAME mymod_realname) + + .. note:: + + If policy :policy:`CMP0086` is set to ``NEW``, ``-module `` + is passed to ``SWIG`` compiler. + +Target library properties can be set to apply same configuration to all SWIG +input files. + +``SWIG_INCLUDE_DIRECTORIES``, ``SWIG_COMPILE_DEFINITIONS`` and ``SWIG_COMPILE_OPTIONS`` + These properties will be applied to all SWIG input files and have same + semantic as target properties :prop_tgt:`INCLUDE_DIRECTORIES`, + :prop_tgt:`COMPILE_DEFINITIONS` and :prop_tgt:`COMPILE_OPTIONS`. + + .. code-block:: cmake + + set (UseSWIG_TARGET_NAME_PREFERENCE STANDARD) + swig_add_library(mymod LANGUAGE python SOURCES mymod.i) + set_property(TARGET mymod PROPERTY SWIG_COMPILE_DEFINITIONS MY_DEF1 MY_DEF2) + set_property(TARGET mymod PROPERTY SWIG_COMPILE_OPTIONS -bla -blb) + +``SWIG_USE_TARGET_INCLUDE_DIRECTORIES`` + If set to ``TRUE``, contents of target property + :prop_tgt:`INCLUDE_DIRECTORIES` will be forwarded to ``SWIG`` compiler. + If set to ``FALSE`` or not defined, target property + :prop_tgt:`INCLUDE_DIRECTORIES` will be ignored. This behavior can be + overridden by specifying source property ``USE_TARGET_INCLUDE_DIRECTORIES``. + +``SWIG_GENERATED_INCLUDE_DIRECTORIES``, ``SWIG_GENERATED_COMPILE_DEFINITIONS`` and ``SWIG_GENERATED_COMPILE_OPTIONS`` + These properties will populate, respectively, properties + :prop_sf:`INCLUDE_DIRECTORIES`, :prop_sf:`COMPILE_DEFINITIONS` and + :prop_sf:`COMPILE_FLAGS` of all generated C/C++ files. + +``SWIG_DEPENDS`` + Add dependencies to all SWIG input files. + +The following target properties are output properties and can be used to get +information about support files generated by ``SWIG`` interface compilation. + +``SWIG_SUPPORT_FILES`` + This output property list of wrapper files generated during SWIG compilation. + + .. code-block:: cmake + + set (UseSWIG_TARGET_NAME_PREFERENCE STANDARD) + swig_add_library(mymod LANGUAGE python SOURCES mymod.i) + get_property(support_files TARGET mymod PROPERTY SWIG_SUPPORT_FILES) + + .. note:: + + Only most principal support files are listed. In case some advanced + features of ``SWIG`` are used (for example ``%template``), associated + support files may not be listed. Prefer to use the + ``SWIG_SUPPORT_FILES_DIRECTORY`` property to handle support files. + +``SWIG_SUPPORT_FILES_DIRECTORY`` + This output property specifies the directory where support files will be + generated. + +Some variables can be set to customize the behavior of ``swig_add_library`` +as well as ``SWIG``: + +``UseSWIG_MODULE_VERSION`` + Specify different behaviors for ``UseSWIG`` module. + + * Set to 1 or undefined: Legacy behavior is applied. + * Set to 2: A new strategy is applied regarding support files: the output + directory of support files is erased before ``SWIG`` interface compilation. + +``CMAKE_SWIG_FLAGS`` + Add flags to all swig calls. + +``CMAKE_SWIG_OUTDIR`` + Specify where to write the language specific files (swig ``-outdir`` option). + +``SWIG_OUTFILE_DIR`` + Specify an output directory name where the generated source file will be + placed. If not specified, ``CMAKE_SWIG_OUTDIR`` is used. + +``SWIG_MODULE__EXTRA_DEPS`` + Specify extra dependencies for the generated module for ````. + +``SWIG_SOURCE_FILE_EXTENSIONS`` + Specify a list of source file extensions to override the default + behavior of considering only ``.i`` files as sources for the ``SWIG`` + tool. For example: + + .. code-block:: cmake + + set(SWIG_SOURCE_FILE_EXTENSIONS ".i" ".swg") +#]=======================================================================] + +cmake_policy(GET CMP0078 target_name_policy) +cmake_policy(GET CMP0086 module_name_policy) + +cmake_policy (VERSION 3.12) +if (target_name_policy) + # respect user choice regarding CMP0078 policy + cmake_policy(SET CMP0078 ${target_name_policy}) +endif() +if (module_name_policy) + # respect user choice regarding CMP0086 policy + cmake_policy(SET CMP0086 ${module_name_policy}) +endif() +unset(target_name_policy) +unset(module_name_policy) + +set(SWIG_CXX_EXTENSION "cxx") +set(SWIG_EXTRA_LIBRARIES "") + +set(SWIG_PYTHON_EXTRA_FILE_EXTENSIONS ".py") +set(SWIG_JAVA_EXTRA_FILE_EXTENSIONS ".java" "JNI.java") +set(SWIG_CSHARP_EXTRA_FILE_EXTENSIONS ".cs" "PINVOKE.cs") + +set(SWIG_MANAGE_SUPPORT_FILES_SCRIPT "${CMAKE_CURRENT_LIST_DIR}/UseSWIG/ManageSupportFiles.cmake") + +## +## PRIVATE functions +## +function (__SWIG_COMPUTE_TIMESTAMP name language infile workingdir __timestamp) + get_filename_component(filename "${infile}" NAME_WE) + set(${__timestamp} + "${workingdir}/${filename}${language}.stamp" PARENT_SCOPE) + # get_filename_component(filename "${infile}" ABSOLUTE) + # string(UUID uuid NAMESPACE 9735D882-D2F8-4E1D-88C9-A0A4F1F6ECA4 + # NAME ${name}-${language}-${filename} TYPE SHA1) + # set(${__timestamp} "${workingdir}/${uuid}.stamp" PARENT_SCOPE) +endfunction() + +# +# For given swig module initialize variables associated with it +# +macro(SWIG_MODULE_INITIALIZE name language) + string(TOUPPER "${language}" SWIG_MODULE_${name}_LANGUAGE) + string(TOLOWER "${language}" SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG) + + if (NOT DEFINED SWIG_MODULE_${name}_NOPROXY) + set (SWIG_MODULE_${name}_NOPROXY FALSE) + endif() + if ("-noproxy" IN_LIST CMAKE_SWIG_FLAGS) + set (SWIG_MODULE_${name}_NOPROXY TRUE) + endif () + + if (SWIG_MODULE_${name}_NOPROXY AND + NOT ("-noproxy" IN_LIST CMAKE_SWIG_FLAGS OR "-noproxy" IN_LIST SWIG_MODULE_${name}_EXTRA_FLAGS)) + list (APPEND SWIG_MODULE_${name}_EXTRA_FLAGS "-noproxy") + endif() + if(SWIG_MODULE_${name}_LANGUAGE STREQUAL "UNKNOWN") + message(FATAL_ERROR "SWIG Error: Language \"${language}\" not found") + elseif(SWIG_MODULE_${name}_LANGUAGE STREQUAL "PERL" AND + NOT "-shadow" IN_LIST SWIG_MODULE_${name}_EXTRA_FLAGS) + list(APPEND SWIG_MODULE_${name}_EXTRA_FLAGS "-shadow") + endif() +endmacro() + +# +# For a given language, input file, and output file, determine extra files that +# will be generated. This is internal swig macro. +# + +function(SWIG_GET_EXTRA_OUTPUT_FILES language outfiles generatedpath infile) + set(files) + get_source_file_property(module_basename + "${infile}" SWIG_MODULE_NAME) + if(NOT module_basename) + + # try to get module name from "%module foo" syntax + if ( EXISTS "${infile}" ) + file ( STRINGS "${infile}" module_basename REGEX "[ ]*%module[ ]*[a-zA-Z0-9_]+.*" ) + endif () + if ( module_basename ) + string ( REGEX REPLACE "[ ]*%module[ ]*([a-zA-Z0-9_]+).*" "\\1" module_basename "${module_basename}" ) + + else () + # try to get module name from "%module (options=...) foo" syntax + if ( EXISTS "${infile}" ) + file ( STRINGS "${infile}" module_basename REGEX "[ ]*%module[ ]*\\(.*\\)[ ]*[a-zA-Z0-9_]+.*" ) + endif () + if ( module_basename ) + string ( REGEX REPLACE "[ ]*%module[ ]*\\(.*\\)[ ]*([a-zA-Z0-9_]+).*" "\\1" module_basename "${module_basename}" ) + + else () + # fallback to file basename + get_filename_component(module_basename "${infile}" NAME_WE) + endif () + endif () + + endif() + foreach(it ${SWIG_${language}_EXTRA_FILE_EXTENSIONS}) + set(extra_file "${generatedpath}/${module_basename}${it}") + if (extra_file MATCHES "\\.cs$" AND CMAKE_CSharp_COMPILER_LOADED) + set_source_files_properties(${extra_file} PROPERTIES LANGUAGE "CSharp") + else() + # Treat extra outputs as plain files regardless of language. + set_source_files_properties(${extra_file} PROPERTIES LANGUAGE "") + endif() + list(APPEND files "${extra_file}") + endforeach() + + if (language STREQUAL "FORTRAN" AND CMAKE_Fortran_COMPILER_LOADED) + # Process possible user-supplied extension in flags (obtained via parent + # scope variable) to determine the source file name. + list(FIND SWIG_COMPILATION_FLAGS "-fext" fext_idx) + if (fext_idx EQUAL -1) + # Default Fortran generated extension + set(fext "f90") + else() + # Get extension from user-provided flag + math(EXPR fext_idx "${fext_idx} + 1") + list(GET SWIG_COMPILATION_FLAGS "${fext_idx}" fext) + endif() + set(extra_file "${generatedpath}/${module_basename}.${fext}") + set_source_files_properties("${extra_file}" PROPERTIES LANGUAGE "Fortran") + list(APPEND files "${extra_file}") + endif() + + set (${outfiles} ${files} PARENT_SCOPE) +endfunction() + +# +# Take swig (*.i) file and add proper custom commands for it +# +function(SWIG_ADD_SOURCE_TO_MODULE name outfiles infile) + get_filename_component(swig_source_file_name_we "${infile}" NAME_WE) + get_source_file_property(swig_source_file_cplusplus "${infile}" CPLUSPLUS) + + # If CMAKE_SWIG_OUTDIR was specified then pass it to -outdir + if(CMAKE_SWIG_OUTDIR) + set(outdir ${CMAKE_SWIG_OUTDIR}) + else() + set(outdir ${CMAKE_CURRENT_BINARY_DIR}) + endif() + + if(SWIG_OUTFILE_DIR) + set(outfiledir ${SWIG_OUTFILE_DIR}) + else() + set(outfiledir ${outdir}) + endif() + + if(SWIG_WORKING_DIR) + set (workingdir "${SWIG_WORKING_DIR}") + else() + set(workingdir "${outdir}") + endif() + + if(SWIG_TARGET_NAME) + set(target_name ${SWIG_TARGET_NAME}) + else() + set(target_name ${name}) + endif() + + set (swig_source_file_flags ${CMAKE_SWIG_FLAGS}) + # handle various swig compile flags properties + get_source_file_property (include_directories "${infile}" INCLUDE_DIRECTORIES) + if (include_directories) + list (APPEND swig_source_file_flags "$<$:-I$-I>>") + endif() + set (property "$") + list (APPEND swig_source_file_flags "$<$:-I$,$-I>>") + set (property "$") + get_source_file_property(use_target_include_dirs "${infile}" USE_TARGET_INCLUDE_DIRECTORIES) + if (use_target_include_dirs) + list (APPEND swig_source_file_flags "$<$:-I$-I>>") + elseif(use_target_include_dirs STREQUAL "NOTFOUND") + # not defined at source level, rely on target level + list (APPEND swig_source_file_flags "$<$>,$>:-I$-I>>") + endif() + + set (property "$") + list (APPEND swig_source_file_flags "$<$:-D$,$-D>>") + get_source_file_property (compile_definitions "${infile}" COMPILE_DEFINITIONS) + if (compile_definitions) + list (APPEND swig_source_file_flags "$<$:-D$-D>>") + endif() + + list (APPEND swig_source_file_flags "$>") + get_source_file_property (compile_options "${infile}" COMPILE_OPTIONS) + if (compile_options) + list (APPEND swig_source_file_flags ${compile_options}) + endif() + + # legacy support + get_source_file_property (swig_flags "${infile}" SWIG_FLAGS) + if (swig_flags) + list (APPEND swig_source_file_flags ${swig_flags}) + endif() + + get_filename_component(swig_source_file_fullname "${infile}" ABSOLUTE) + + if (NOT SWIG_MODULE_${name}_NOPROXY) + set(SWIG_COMPILATION_FLAGS ${swig_source_file_flags}) + SWIG_GET_EXTRA_OUTPUT_FILES(${SWIG_MODULE_${name}_LANGUAGE} + swig_extra_generated_files + "${outdir}" + "${swig_source_file_fullname}") + endif() + set(swig_generated_file_fullname + "${outfiledir}/${swig_source_file_name_we}") + # add the language into the name of the file (i.e. TCL_wrap) + # this allows for the same .i file to be wrapped into different languages + string(APPEND swig_generated_file_fullname + "${SWIG_MODULE_${name}_LANGUAGE}_wrap") + + if(swig_source_file_cplusplus) + string(APPEND swig_generated_file_fullname + ".${SWIG_CXX_EXTENSION}") + else() + string(APPEND swig_generated_file_fullname + ".c") + endif() + + get_directory_property (cmake_include_directories INCLUDE_DIRECTORIES) + list (REMOVE_DUPLICATES cmake_include_directories) + set (swig_include_dirs) + if (cmake_include_directories) + set (swig_include_dirs "$<$:-I$-I>>") + endif() + + set(swig_special_flags) + # default is c, so add c++ flag if it is c++ + if(swig_source_file_cplusplus) + list (APPEND swig_special_flags "-c++") + endif() + + cmake_policy(GET CMP0086 module_name_policy) + if (module_name_policy STREQUAL "NEW") + get_source_file_property(module_name "${infile}" SWIG_MODULE_NAME) + if (module_name) + list (APPEND swig_special_flags "-module" "${module_name}") + endif() + else() + if (NOT module_name_policy) + cmake_policy(GET_WARNING CMP0086 _cmp0086_warning) + message(AUTHOR_WARNING "${_cmp0086_warning}\n") + endif() + endif() + + set (swig_extra_flags) + if(SWIG_MODULE_${name}_LANGUAGE STREQUAL "CSHARP") + if(NOT ("-dllimport" IN_LIST swig_source_file_flags OR "-dllimport" IN_LIST SWIG_MODULE_${name}_EXTRA_FLAGS)) + # This makes sure that the name used in the generated DllImport + # matches the library name created by CMake + list (APPEND SWIG_MODULE_${name}_EXTRA_FLAGS "-dllimport" "$$") + endif() + endif() + if (SWIG_MODULE_${name}_LANGUAGE STREQUAL "PYTHON" AND NOT SWIG_MODULE_${name}_NOPROXY) + if(SWIG_USE_INTERFACE AND + NOT ("-interface" IN_LIST swig_source_file_flags OR "-interface" IN_LIST SWIG_MODULE_${name}_EXTRA_FLAGS)) + # This makes sure that the name used in the proxy code + # matches the library name created by CMake + list (APPEND SWIG_MODULE_${name}_EXTRA_FLAGS "-interface" "$$") + endif() + endif() + list (APPEND swig_extra_flags ${SWIG_MODULE_${name}_EXTRA_FLAGS}) + + # dependencies + set (swig_dependencies ${SWIG_MODULE_${name}_EXTRA_DEPS} $) + get_source_file_property(file_depends "${infile}" DEPENDS) + if (file_depends) + list (APPEND swig_dependencies ${file_depends}) + endif() + + if (UseSWIG_MODULE_VERSION VERSION_GREATER 1) + # as part of custom command, start by removing old generated files + # to ensure obsolete files do not stay + set (swig_file_outdir "${workingdir}/${swig_source_file_name_we}.files") + set (swig_cleanup_command COMMAND "${CMAKE_COMMAND}" "-DSUPPORT_FILES_WORKING_DIRECTORY=${swig_file_outdir}" "-DSUPPORT_FILES_OUTPUT_DIRECTORY=${outdir}" -DACTION=CLEAN -P "${SWIG_MANAGE_SUPPORT_FILES_SCRIPT}") + set (swig_copy_command COMMAND "${CMAKE_COMMAND}" "-DSUPPORT_FILES_WORKING_DIRECTORY=${swig_file_outdir}" "-DSUPPORT_FILES_OUTPUT_DIRECTORY=${outdir}" -DACTION=COPY -P "${SWIG_MANAGE_SUPPORT_FILES_SCRIPT}") + else() + set (swig_file_outdir "${outdir}") + unset (swig_cleanup_command) + unset (swig_copy_command) + endif() + + # IMPLICIT_DEPENDS below can not handle situations where a dependent file is + # removed. We need an extra step with timestamp and custom target, see #16830 + # As this is needed only for Makefile generator do it conditionally + if(CMAKE_GENERATOR MATCHES "Make") + __swig_compute_timestamp(${name} ${SWIG_MODULE_${name}_LANGUAGE} + "${infile}" "${workingdir}" swig_generated_timestamp) + set(swig_custom_output "${swig_generated_timestamp}") + set(swig_custom_products + BYPRODUCTS "${swig_generated_file_fullname}" ${swig_extra_generated_files}) + set(swig_timestamp_command + COMMAND ${CMAKE_COMMAND} -E touch "${swig_generated_timestamp}") + else() + set(swig_custom_output + "${swig_generated_file_fullname}" ${swig_extra_generated_files}) + set(swig_custom_products) + set(swig_timestamp_command) + endif() + add_custom_command( + OUTPUT ${swig_custom_output} + ${swig_custom_products} + ${swig_cleanup_command} + # Let's create the ${outdir} at execution time, in case dir contains $(OutDir) + COMMAND "${CMAKE_COMMAND}" -E make_directory ${outdir} ${outfiledir} + ${swig_timestamp_command} + COMMAND "${CMAKE_COMMAND}" -E env "SWIG_LIB=${SWIG_DIR}" "${SWIG_EXECUTABLE}" + "-${SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG}" + "${swig_source_file_flags}" + -outdir "${swig_file_outdir}" + ${swig_special_flags} + ${swig_extra_flags} + "${swig_include_dirs}" + -o "${swig_generated_file_fullname}" + "${swig_source_file_fullname}" + ${swig_copy_command} + MAIN_DEPENDENCY "${swig_source_file_fullname}" + DEPENDS ${swig_dependencies} + IMPLICIT_DEPENDS CXX "${swig_source_file_fullname}" + COMMENT "Swig compile ${infile} for ${SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG}" + COMMAND_EXPAND_LISTS) + set_source_files_properties("${swig_generated_file_fullname}" ${swig_extra_generated_files} + PROPERTIES GENERATED 1) + + ## add all properties for generated file to various properties + get_property (include_directories SOURCE "${infile}" PROPERTY GENERATED_INCLUDE_DIRECTORIES) + set_property (SOURCE "${swig_generated_file_fullname}" PROPERTY INCLUDE_DIRECTORIES ${include_directories} $>) + + get_property (compile_definitions SOURCE "${infile}" PROPERTY GENERATED_COMPILE_DEFINITIONS) + set_property (SOURCE "${swig_generated_file_fullname}" PROPERTY COMPILE_DEFINITIONS $> ${compile_definitions}) + + get_property (compile_options SOURCE "${infile}" PROPERTY GENERATED_COMPILE_OPTIONS) + set_property (SOURCE "${swig_generated_file_fullname}" PROPERTY COMPILE_OPTIONS $> ${compile_options}) + + if (SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG MATCHES "php") + set_property (SOURCE "${swig_generated_file_fullname}" APPEND PROPERTY INCLUDE_DIRECTORIES "${outdir}") + endif() + + set(${outfiles} "${swig_generated_file_fullname}" ${swig_extra_generated_files} PARENT_SCOPE) + + # legacy support + set (swig_generated_file_fullname "${swig_generated_file_fullname}" PARENT_SCOPE) +endfunction() + +# +# Create Swig module +# +macro(SWIG_ADD_MODULE name language) + message(DEPRECATION "SWIG_ADD_MODULE is deprecated. Use SWIG_ADD_LIBRARY instead.") + swig_add_library(${name} + LANGUAGE ${language} + TYPE MODULE + SOURCES ${ARGN}) +endmacro() + + +function(SWIG_ADD_LIBRARY name) + set(options NO_PROXY) + set(oneValueArgs LANGUAGE + TYPE + OUTPUT_DIR + OUTFILE_DIR) + set(multiValueArgs SOURCES) + cmake_parse_arguments(_SAM "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if (_SAM_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "SWIG_ADD_LIBRARY: ${_SAM_UNPARSED_ARGUMENTS}: unexpected arguments") + endif() + + if(NOT DEFINED _SAM_LANGUAGE) + message(FATAL_ERROR "SWIG_ADD_LIBRARY: Missing LANGUAGE argument") + endif() + + if(NOT DEFINED _SAM_SOURCES) + message(FATAL_ERROR "SWIG_ADD_LIBRARY: Missing SOURCES argument") + endif() + + if(NOT DEFINED _SAM_TYPE) + set(_SAM_TYPE MODULE) + elseif(_SAM_TYPE STREQUAL "USE_BUILD_SHARED_LIBS") + unset(_SAM_TYPE) + endif() + + cmake_policy(GET CMP0078 target_name_policy) + if (target_name_policy STREQUAL "NEW") + set (UseSWIG_TARGET_NAME_PREFERENCE STANDARD) + else() + if (NOT target_name_policy) + cmake_policy(GET_WARNING CMP0078 _cmp0078_warning) + message(AUTHOR_WARNING "${_cmp0078_warning}\n") + endif() + if (NOT DEFINED UseSWIG_TARGET_NAME_PREFERENCE) + set (UseSWIG_TARGET_NAME_PREFERENCE LEGACY) + elseif (NOT UseSWIG_TARGET_NAME_PREFERENCE MATCHES "^(LEGACY|STANDARD)$") + message (FATAL_ERROR "UseSWIG_TARGET_NAME_PREFERENCE: ${UseSWIG_TARGET_NAME_PREFERENCE}: invalid value. 'LEGACY' or 'STANDARD' is expected.") + endif() + endif() + + if (NOT DEFINED UseSWIG_MODULE_VERSION) + set (UseSWIG_MODULE_VERSION 1) + elseif (NOT UseSWIG_MODULE_VERSION MATCHES "^(1|2)$") + message (FATAL_ERROR "UseSWIG_MODULE_VERSION: ${UseSWIG_MODULE_VERSION}: invalid value. 1 or 2 is expected.") + endif() + + set (SWIG_MODULE_${name}_NOPROXY ${_SAM_NO_PROXY}) + swig_module_initialize(${name} ${_SAM_LANGUAGE}) + + # compute real target name. + if (UseSWIG_TARGET_NAME_PREFERENCE STREQUAL "LEGACY" AND + SWIG_MODULE_${name}_LANGUAGE STREQUAL "PYTHON" AND NOT SWIG_MODULE_${name}_NOPROXY) + # swig will produce a module.py containing an 'import _modulename' statement, + # which implies having a corresponding _modulename.so (*NIX), _modulename.pyd (Win32), + # unless the -noproxy flag is used + set(target_name "_${name}") + else() + set(target_name "${name}") + endif() + + if (TARGET ${target_name}) + # a target with same name is already defined. + # call NOW add_library command to raise the most useful error message + add_library(${target_name}) + return() + endif() + + set (workingdir "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${target_name}.dir") + # set special variable to pass extra information to command SWIG_ADD_SOURCE_TO_MODULE + # which cannot be changed due to legacy compatibility + set (SWIG_WORKING_DIR "${workingdir}") + set (SWIG_TARGET_NAME "${target_name}") + + set (outputdir "${_SAM_OUTPUT_DIR}") + if (NOT _SAM_OUTPUT_DIR) + if (CMAKE_SWIG_OUTDIR) + set (outputdir "${CMAKE_SWIG_OUTDIR}") + else() + if (UseSWIG_MODULE_VERSION VERSION_GREATER 1) + set (outputdir "${workingdir}/${_SAM_LANGUAGE}.files") + else() + set (outputdir "${CMAKE_CURRENT_BINARY_DIR}") + endif() + endif() + endif() + + set (outfiledir "${_SAM_OUTFILE_DIR}") + if(NOT _SAM_OUTFILE_DIR) + if (SWIG_OUTFILE_DIR) + set (outfiledir "${SWIG_OUTFILE_DIR}") + else() + if (_SAM_OUTPUT_DIR OR CMAKE_SWIG_OUTDIR) + set (outfiledir "${outputdir}") + else() + set (outfiledir "${workingdir}") + endif() + endif() + endif() + # set again, locally, predefined variables to ensure compatibility + # with command SWIG_ADD_SOURCE_TO_MODULE + set(CMAKE_SWIG_OUTDIR "${outputdir}") + set(SWIG_OUTFILE_DIR "${outfiledir}") + + # See if the user has specified source extensions for swig files? + if (NOT DEFINED SWIG_SOURCE_FILE_EXTENSIONS) + # Assume the default (*.i) file extension for Swig source files + set(SWIG_SOURCE_FILE_EXTENSIONS ".i") + endif() + + # Generate a regex out of file extensions. + string(REGEX REPLACE "([$^.*+?|()-])" "\\\\\\1" swig_source_ext_regex "${SWIG_SOURCE_FILE_EXTENSIONS}") + list (JOIN swig_source_ext_regex "|" swig_source_ext_regex) + string (PREPEND swig_source_ext_regex "(") + string (APPEND swig_source_ext_regex ")$") + + set(swig_dot_i_sources ${_SAM_SOURCES}) + list(FILTER swig_dot_i_sources INCLUDE REGEX ${swig_source_ext_regex}) + if (NOT swig_dot_i_sources) + message(FATAL_ERROR "SWIG_ADD_LIBRARY: no SWIG interface files specified") + endif() + set(swig_other_sources ${_SAM_SOURCES}) + list(REMOVE_ITEM swig_other_sources ${swig_dot_i_sources}) + + set(swig_generated_sources) + set(swig_generated_timestamps) + list(LENGTH swig_dot_i_sources swig_sources_count) + if (swig_sources_count GREATER "1") + # option -interface cannot be used + set(SWIG_USE_INTERFACE FALSE) + else() + set(SWIG_USE_INTERFACE TRUE) + endif() + foreach(swig_it IN LISTS swig_dot_i_sources) + SWIG_ADD_SOURCE_TO_MODULE(${name} swig_generated_source "${swig_it}") + list (APPEND swig_generated_sources "${swig_generated_source}") + if(CMAKE_GENERATOR MATCHES "Make") + __swig_compute_timestamp(${name} ${SWIG_MODULE_${name}_LANGUAGE} "${swig_it}" + "${workingdir}" swig_timestamp) + list (APPEND swig_generated_timestamps "${swig_timestamp}") + endif() + endforeach() + set_property (DIRECTORY APPEND PROPERTY + ADDITIONAL_CLEAN_FILES ${swig_generated_sources} ${swig_generated_timestamps}) + if (UseSWIG_MODULE_VERSION VERSION_GREATER 1) + set_property (DIRECTORY APPEND PROPERTY ADDITIONAL_CLEAN_FILES "${outputdir}") + endif() + + add_library(${target_name} + ${_SAM_TYPE} + ${swig_generated_sources} + ${swig_other_sources}) + if(CMAKE_GENERATOR MATCHES "Make") + # see IMPLICIT_DEPENDS above + add_custom_target(${name}_swig_compilation DEPENDS ${swig_generated_timestamps}) + add_dependencies(${target_name} ${name}_swig_compilation) + endif() + if(_SAM_TYPE STREQUAL "MODULE") + set_target_properties(${target_name} PROPERTIES NO_SONAME ON) + endif() + string(TOLOWER "${_SAM_LANGUAGE}" swig_lowercase_language) + if (swig_lowercase_language STREQUAL "octave") + set_target_properties(${target_name} PROPERTIES PREFIX "") + set_target_properties(${target_name} PROPERTIES SUFFIX ".oct") + elseif (swig_lowercase_language STREQUAL "go") + set_target_properties(${target_name} PROPERTIES PREFIX "") + elseif (swig_lowercase_language STREQUAL "java") + # In java you want: + # System.loadLibrary("LIBRARY"); + # then JNI will look for a library whose name is platform dependent, namely + # MacOS : libLIBRARY.jnilib + # Windows: LIBRARY.dll + # Linux : libLIBRARY.so + if (APPLE) + set_target_properties (${target_name} PROPERTIES SUFFIX ".jnilib") + endif() + if ((WIN32 AND MINGW) OR CYGWIN OR CMAKE_SYSTEM_NAME STREQUAL MSYS) + set_target_properties(${target_name} PROPERTIES PREFIX "") + endif() + elseif (swig_lowercase_language STREQUAL "lua") + if(_SAM_TYPE STREQUAL "MODULE") + set_target_properties(${target_name} PROPERTIES PREFIX "") + endif() + elseif (swig_lowercase_language STREQUAL "python") + if (UseSWIG_TARGET_NAME_PREFERENCE STREQUAL "STANDARD" AND NOT SWIG_MODULE_${name}_NOPROXY) + # swig will produce a module.py containing an 'import _modulename' statement, + # which implies having a corresponding _modulename.so (*NIX), _modulename.pyd (Win32), + # unless the -noproxy flag is used + set_target_properties(${target_name} PROPERTIES PREFIX "_") + else() + set_target_properties(${target_name} PROPERTIES PREFIX "") + endif() + # Python extension modules on Windows must have the extension ".pyd" + # instead of ".dll" as of Python 2.5. Older python versions do support + # this suffix. + # http://docs.python.org/whatsnew/ports.html#SECTION0001510000000000000000 + # + # Windows: .dll is no longer supported as a filename extension for extension modules. + # .pyd is now the only filename extension that will be searched for. + # + if(WIN32 AND NOT CYGWIN) + set_target_properties(${target_name} PROPERTIES SUFFIX ".pyd") + endif() + elseif (swig_lowercase_language STREQUAL "r") + set_target_properties(${target_name} PROPERTIES PREFIX "") + elseif (swig_lowercase_language STREQUAL "ruby") + # In ruby you want: + # require 'LIBRARY' + # then ruby will look for a library whose name is platform dependent, namely + # MacOS : LIBRARY.bundle + # Windows: LIBRARY.dll + # Linux : LIBRARY.so + set_target_properties (${target_name} PROPERTIES PREFIX "") + if (APPLE) + set_target_properties (${target_name} PROPERTIES SUFFIX ".bundle") + endif () + elseif (swig_lowercase_language STREQUAL "perl") + # assume empty prefix because we expect the module to be dynamically loaded + set_target_properties (${target_name} PROPERTIES PREFIX "") + if (APPLE) + set_target_properties (${target_name} PROPERTIES SUFFIX ".dylib") + endif () + elseif (swig_lowercase_language STREQUAL "fortran") + # Do *not* override the target's library prefix + else() + # assume empty prefix because we expect the module to be dynamically loaded + set_target_properties (${target_name} PROPERTIES PREFIX "") + endif () + + # target property SWIG_SUPPORT_FILES_DIRECTORY specify output directory of support files + set_property (TARGET ${target_name} PROPERTY SWIG_SUPPORT_FILES_DIRECTORY "${outputdir}") + # target property SWIG_SUPPORT_FILES lists principal proxy support files + if (NOT SWIG_MODULE_${name}_NOPROXY) + string(TOUPPER "${_SAM_LANGUAGE}" swig_uppercase_language) + set(swig_all_support_files) + foreach (swig_it IN LISTS SWIG_${swig_uppercase_language}_EXTRA_FILE_EXTENSIONS) + set (swig_support_files ${swig_generated_sources}) + list (FILTER swig_support_files INCLUDE REGEX ".*${swig_it}$") + list(APPEND swig_all_support_files ${swig_support_files}) + endforeach() + if (swig_all_support_files) + list(REMOVE_DUPLICATES swig_all_support_files) + endif() + set_property (TARGET ${target_name} PROPERTY SWIG_SUPPORT_FILES ${swig_all_support_files}) + endif() + + # to ensure legacy behavior, export some variables + set (SWIG_MODULE_${name}_LANGUAGE "${SWIG_MODULE_${name}_LANGUAGE}" PARENT_SCOPE) + set (SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG "${SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG}" PARENT_SCOPE) + set (SWIG_MODULE_${name}_REAL_NAME "${target_name}" PARENT_SCOPE) + set (SWIG_MODULE_${name}_NOPROXY "${SWIG_MODULE_${name}_NOPROXY}" PARENT_SCOPE) + set (SWIG_MODULE_${name}_EXTRA_FLAGS "${SWIG_MODULE_${name}_EXTRA_FLAGS}" PARENT_SCOPE) + # the last one is a bit crazy but it is documented, so... + # NOTA: works as expected if only ONE input file is specified + set (swig_generated_file_fullname "${swig_generated_file_fullname}" PARENT_SCOPE) +endfunction() + +# +# Like TARGET_LINK_LIBRARIES but for swig modules +# +function(SWIG_LINK_LIBRARIES name) + if (UseSWIG_TARGET_NAME_PREFERENCE STREQUAL "STANDARD") + message(DEPRECATION "SWIG_LINK_LIBRARIES is deprecated. Use TARGET_LINK_LIBRARIES instead.") + target_link_libraries(${name} ${ARGN}) + else() + if(SWIG_MODULE_${name}_REAL_NAME) + target_link_libraries(${SWIG_MODULE_${name}_REAL_NAME} ${ARGN}) + else() + message(SEND_ERROR "Cannot find Swig library \"${name}\".") + endif() + endif() +endfunction() diff --git a/cmake/modules/UseSWIG/ManageSupportFiles.cmake b/cmake/modules/UseSWIG/ManageSupportFiles.cmake new file mode 100644 index 0000000000000..4a03900b7fc78 --- /dev/null +++ b/cmake/modules/UseSWIG/ManageSupportFiles.cmake @@ -0,0 +1,31 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + + +if (ACTION STREQUAL "CLEAN") + # Collect current list of generated files + file (GLOB files LIST_DIRECTORIES FALSE RELATIVE "${SUPPORT_FILES_WORKING_DIRECTORY}" "${SUPPORT_FILES_WORKING_DIRECTORY}/*") + + if (files) + # clean-up the output directory + ## compute full paths + list (TRANSFORM files PREPEND "${SUPPORT_FILES_OUTPUT_DIRECTORY}/") + ## remove generated files from the output directory + file (REMOVE ${files}) + + # clean-up working directory + file (REMOVE_RECURSE "${SUPPORT_FILES_WORKING_DIRECTORY}") + endif() + + file (MAKE_DIRECTORY "${SUPPORT_FILES_WORKING_DIRECTORY}") +endif() + +if (ACTION STREQUAL "COPY") + # Collect current list of generated files + file (GLOB files LIST_DIRECTORIES FALSE "${SUPPORT_FILES_WORKING_DIRECTORY}/*") + + if (files) + # copy files to the output directory + file (COPY ${files} DESTINATION "${SUPPORT_FILES_OUTPUT_DIRECTORY}") + endif() +endif() diff --git a/cmake/modules/buildtools/FindSWIG.cmake b/cmake/modules/buildtools/FindSWIG.cmake index fba544baa2979..3a7584b6303a4 100644 --- a/cmake/modules/buildtools/FindSWIG.cmake +++ b/cmake/modules/buildtools/FindSWIG.cmake @@ -1,29 +1,110 @@ -#.rst: -# FindSWIG -# -------- -# Finds the SWIG executable -# -# This will define the following variables:: -# -# SWIG_FOUND - system has SWIG -# SWIG_EXECUTABLE - the SWIG executable - -find_program(SWIG_EXECUTABLE NAMES swig4.0 swig3.0 swig2.0 swig - PATH_SUFFIXES swig) +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindSWIG +-------- + +Find the Simplified Wrapper and Interface Generator (SWIG_) executable. + + +This module finds an installed SWIG and determines its version. If a +``COMPONENTS`` or ``OPTIONAL_COMPONENTS`` argument is given to ``find_package``, +it will also determine supported target languages. The module sents the +following variables: + +``SWIG_FOUND`` + Whether SWIG and any required components were found on the system. +``SWIG_EXECUTABLE`` + Path to the SWIG executable. +``SWIG_DIR`` + Path to the installed SWIG ``Lib`` directory (result of ``swig -swiglib``). +``SWIG_VERSION`` + SWIG executable version (result of ``swig -version``). +``SWIG__FOUND`` + If ``COMPONENTS`` or ``OPTIONAL_COMPONENTS`` are requested, each available + target language ```` (lowercase) will be set to TRUE. + +Any ``COMPONENTS`` given to ``find_package`` should be the names of supported +target languages as provided to the LANGUAGE argument of ``swig_add_library``, +such as ``python`` or ``perl5``. Language names *must* be lowercase. + +All information is collected from the ``SWIG_EXECUTABLE``, so the version +to be found can be changed from the command line by means of setting +``SWIG_EXECUTABLE``. + +Example usage requiring SWIG 4.0 or higher and Python language support, with +optional Fortran support: + +.. code-block:: cmake + + find_package(SWIG 4.0 COMPONENTS python OPTIONAL_COMPONENTS fortran) + if(SWIG_FOUND) + message("SWIG found: ${SWIG_EXECUTABLE}") + if(NOT SWIG_fortran_FOUND) + message(WARNING "SWIG Fortran bindings cannot be generated") + endif() + endif() + +.. _`SWIG`: http://swig.org + +#]=======================================================================] + +find_program(SWIG_EXECUTABLE NAMES swig4.0 swig3.0 swig2.0 swig) + if(SWIG_EXECUTABLE) execute_process(COMMAND ${SWIG_EXECUTABLE} -swiglib - OUTPUT_VARIABLE SWIG_DIR + OUTPUT_VARIABLE SWIG_swiglib_output ERROR_VARIABLE SWIG_swiglib_error RESULT_VARIABLE SWIG_swiglib_result) - execute_process(COMMAND ${SWIG_EXECUTABLE} -version - OUTPUT_VARIABLE SWIG_version_output - ERROR_VARIABLE SWIG_version_output - RESULT_VARIABLE SWIG_version_result) - string(REGEX REPLACE ".*SWIG Version[^0-9.]*\([0-9.]+\).*" "\\1" - SWIG_VERSION "${SWIG_version_output}") + + if(SWIG_swiglib_result) + if(SWIG_FIND_REQUIRED) + message(SEND_ERROR "Command \"${SWIG_EXECUTABLE} -swiglib\" failed with output:\n${SWIG_swiglib_error}") + else() + message(STATUS "Command \"${SWIG_EXECUTABLE} -swiglib\" failed with output:\n${SWIG_swiglib_error}") + endif() + else() + string(REGEX REPLACE "[\n\r]+" ";" SWIG_swiglib_output ${SWIG_swiglib_output}) + find_path(SWIG_DIR swig.swg PATHS ${SWIG_swiglib_output} NO_CMAKE_FIND_ROOT_PATH) + if(SWIG_DIR) + set(SWIG_USE_FILE ${CMAKE_CURRENT_LIST_DIR}/UseSWIG.cmake) + execute_process(COMMAND ${SWIG_EXECUTABLE} -version + OUTPUT_VARIABLE SWIG_version_output + ERROR_VARIABLE SWIG_version_output + RESULT_VARIABLE SWIG_version_result) + if(SWIG_version_result) + message(SEND_ERROR "Command \"${SWIG_EXECUTABLE} -version\" failed with output:\n${SWIG_version_output}") + else() + string(REGEX REPLACE ".*SWIG Version[^0-9.]*\([0-9.]+\).*" "\\1" + SWIG_version_output "${SWIG_version_output}") + set(SWIG_VERSION ${SWIG_version_output} CACHE STRING "Swig version" FORCE) + endif() + endif() + endif() + + if(SWIG_FIND_COMPONENTS) + execute_process(COMMAND ${SWIG_EXECUTABLE} -help + OUTPUT_VARIABLE SWIG_swighelp_output + ERROR_VARIABLE SWIG_swighelp_error + RESULT_VARIABLE SWIG_swighelp_result) + if(SWIG_swighelp_result) + message(SEND_ERROR "Command \"${SWIG_EXECUTABLE} -help\" failed with output:\n${SWIG_swiglib_error}") + else() + string(REPLACE "\n" ";" SWIG_swighelp_output "${SWIG_swighelp_output}") + foreach(SWIG_line IN LISTS SWIG_swighelp_output) + if(SWIG_line MATCHES "-([A-Za-z0-9_]+) +- *Generate.*wrappers") + set(SWIG_${CMAKE_MATCH_1}_FOUND TRUE) + endif() + endforeach() + endif() + endif() endif() include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(SWIG - REQUIRED_VARS SWIG_EXECUTABLE SWIG_DIR - VERSION_VAR SWIG_VERSION) +find_package_handle_standard_args( + SWIG HANDLE_COMPONENTS + REQUIRED_VARS SWIG_EXECUTABLE SWIG_DIR + VERSION_VAR SWIG_VERSION) + +mark_as_advanced(SWIG_DIR SWIG_VERSION SWIG_EXECUTABLE) diff --git a/cmake/scripts/common/AddonHelpers.cmake b/cmake/scripts/common/AddonHelpers.cmake index c541ad702e77c..c345ea58aedea 100644 --- a/cmake/scripts/common/AddonHelpers.cmake +++ b/cmake/scripts/common/AddonHelpers.cmake @@ -92,66 +92,60 @@ macro (build_addon target prefix libs) endforeach() endif() - message(STATUS "Addon dependency check ...") - # Set defines used in addon.xml.in and read from versions.h to set add-on + message(STATUS "Addon API check ...") + # Set defines used in addon.xml.in and read from version.h to set add-on # version parts automatically - file(STRINGS ${KODI_INCLUDE_DIR}/versions.h BIN_ADDON_PARTS) + file(STRINGS ${KODI_INCLUDE_DIR}/c-api/version.h BIN_ADDON_PARTS) + set(__KDK_API_OLDEST__ 10000) foreach(loop_var ${BIN_ADDON_PARTS}) - # Only pass strings with "#define ADDON_" from versions.h - if(loop_var MATCHES "#define ADDON_") - string(REGEX REPLACE "\\\n" " " loop_var ${loop_var}) # remove header line breaks - string(REGEX REPLACE "#define " "" loop_var ${loop_var}) # remove the #define name from string - string(REGEX MATCHALL "[//a-zA-Z0-9._-]+" loop_var "${loop_var}") # separate the define values to a list - - # Get the definition name + string(FIND "${loop_var}" "#define __KDK_MAJOR__" matchres) + if("${matchres}" EQUAL 0) + string(REGEX MATCHALL "[A-Z0-9._]+|[A-Z0-9._]+$" loop_var "${loop_var}") list(GET loop_var 0 include_name) - # Check definition are depends who is a bigger list - if("${include_name}" MATCHES "_DEPENDS") - # Use start definition name as base for other value type - list(GET loop_var 0 list_name) - string(REPLACE "_DEPENDS" "_MIN" depends_minver ${list_name}) - string(REPLACE "_DEPENDS" "" depends_ver ${list_name}) - string(REPLACE "_DEPENDS" "_XML_ID" xml_entry_name ${list_name}) - string(REPLACE "_DEPENDS" "_USED" used_type_name ${list_name}) - - # remove the first value, not needed and wrong on "for" loop - list(REMOVE_AT loop_var 0) - - foreach(depend_header ${loop_var}) - string(STRIP ${depend_header} depend_header) - foreach(src_file ${USED_SOURCES}) - file(STRINGS ${src_file} BIN_ADDON_SRC_PARTS) - foreach(loop_var ${BIN_ADDON_SRC_PARTS}) - string(REGEX MATCH "^[ \t]*#[ \t]*(include|import)[ \t]*[<\"](kodi\/)?(.+)[\">]" include_name "${loop_var}") - if(include_name AND CMAKE_MATCH_3 MATCHES ^${depend_header}) - get_directory_property(CURRENT_DEFS COMPILE_DEFINITIONS) - if(NOT used_type_name IN_LIST CURRENT_DEFS) - set(ADDON_DEPENDS "${ADDON_DEPENDS}\n") - # Inform with them the addon header about used type, if not present before - add_definitions(-D${used_type_name}) - message(STATUS " - Added API usage definition: ${used_type_name} (Version: \"${${depends_ver}}\", Min. Version: \"${${depends_minver}}\")") - set(FOUND_HEADER_USAGE 1) - endif() - endif() - endforeach() - if(FOUND_HEADER_USAGE EQUAL 1) # break this loop if found but not unset, needed in parts where includes muddled up on addon - break() - endif() - endforeach() - # type is found and round becomes broken for next round with other type - if(FOUND_HEADER_USAGE EQUAL 1) - unset(FOUND_HEADER_USAGE) - break() - endif() - endforeach() + list(GET loop_var 1 include_value) + string(REGEX REPLACE ".*\"(.*)\"" "\\1" ${include_name} ${include_value}) + endif() + string(FIND "${loop_var}" "#define __KDK_MINOR__" matchres) + if("${matchres}" EQUAL 0) + string(REGEX MATCHALL "[A-Z0-9._]+|[A-Z0-9._]+$" loop_var "${loop_var}") + list(GET loop_var 0 include_name) + list(GET loop_var 1 include_value) + string(REGEX REPLACE ".*\"(.*)\"" "\\1" ${include_name} ${include_value}) + endif() + string(FIND "${loop_var}" "#define __KDK_BETA__" matchres) + if("${matchres}" EQUAL 0) + string(REGEX MATCHALL "[A-Z0-9._]+|[A-Z0-9._]+$" loop_var "${loop_var}") + list(GET loop_var 0 include_name) + list(GET loop_var 1 include_value) + string(REGEX REPLACE ".*\"(.*)\"" "\\1" ${include_name} ${include_value}) + endif() + string(FIND "${loop_var}" "#define __KDK_CANARY__" matchres) + if("${matchres}" EQUAL 0) + string(REGEX MATCHALL "[A-Z0-9._]+|[A-Z0-9._]+$" loop_var "${loop_var}") + list(GET loop_var 0 include_name) + list(GET loop_var 1 include_value) + string(REGEX REPLACE ".*\"(.*)\"" "\\1" ${include_name} ${include_value}) + if(__KDK_CANARY__ EQUAL 1) + set(__KDK_CANARY_XML__ "true") else() - # read the definition values and make it by the on version.h defined names public - list(GET loop_var 1 include_variable) - string(REGEX REPLACE ".*\"(.*)\"" "\\1" ${include_name} ${include_variable}) - set(${include_name} ${${include_name}}) + set(__KDK_CANARY_XML__ "false") endif() endif() - endforeach() + string(FIND "${loop_var}" "#define __KODI_API_" matchres) + if("${matchres}" EQUAL 0) + string(REGEX MATCHALL "[A-Z0-9._]+|[A-Z0-9._]+$" loop_var "${loop_var}") + list(GET loop_var 0 include_name) + list(GET loop_var 1 include_value) + if(include_value LESS ${__KDK_API_OLDEST__}) + set(__KDK_API_OLDEST__ ${include_value}) + endif() + endif() + endforeach(loop_var) + add_definitions(-D__KDK_MAJOR__=${__KDK_MAJOR__}) + add_definitions(-D__KDK_MINOR__=${__KDK_MINOR__}) + add_definitions(-D__KDK_BETA__=${__KDK_BETA__}) + add_definitions(-D__KDK_CANARY__=${__KDK_CANARY__}) + add_definitions(-D__KDK_API_OLDEST__=${__KDK_API_OLDEST__}) add_library(${target} ${${prefix}_SOURCES} ${${prefix}_HEADERS}) target_link_libraries(${target} ${${libs}}) @@ -273,7 +267,7 @@ macro (build_addon target prefix libs) COMPONENT ${target}-${${prefix}_VERSION}-${PLATFORM_TAG}) endif() if(${prefix}_ADDITIONAL_BINARY) - install(FILES ${${prefix}_ADDITIONAL_BINARY} DESTINATION ${target} + install(PROGRAMS ${${prefix}_ADDITIONAL_BINARY} DESTINATION ${target} COMPONENT ${target}-${${prefix}_VERSION}-${PLATFORM_TAG}) endif() if(${prefix}_ADDITIONAL_BINARY_EXE) @@ -305,7 +299,7 @@ macro (build_addon target prefix libs) COMPONENT ${target}-${${prefix}_VERSION}-${PLATFORM_TAG}) endif() if(${prefix}_ADDITIONAL_BINARY) - install(FILES ${${prefix}_ADDITIONAL_BINARY} DESTINATION ${target} + install(PROGRAMS ${${prefix}_ADDITIONAL_BINARY} DESTINATION ${target} COMPONENT ${target}-${${prefix}_VERSION}-${PLATFORM_TAG}) endif() if(${prefix}_ADDITIONAL_BINARY_EXE) @@ -361,7 +355,7 @@ macro (build_addon target prefix libs) install(DIRECTORY ${${prefix}_CUSTOM_DATA} DESTINATION ${CMAKE_INSTALL_DATADIR}/addons/${target}/resources) endif() if(${prefix}_ADDITIONAL_BINARY) - install(FILES ${${prefix}_ADDITIONAL_BINARY} DESTINATION ${CMAKE_INSTALL_LIBDIR}/addons/${target}) + install(PROGRAMS ${${prefix}_ADDITIONAL_BINARY} DESTINATION ${CMAKE_INSTALL_LIBDIR}/addons/${target}) endif() if(${prefix}_ADDITIONAL_BINARY_EXE) install(PROGRAMS ${${prefix}_ADDITIONAL_BINARY_EXE} DESTINATION ${CMAKE_INSTALL_LIBDIR}/addons/${target}) diff --git a/cmake/scripts/common/HandleDepends.cmake b/cmake/scripts/common/HandleDepends.cmake index dc022bab64108..2db266acb19ea 100644 --- a/cmake/scripts/common/HandleDepends.cmake +++ b/cmake/scripts/common/HandleDepends.cmake @@ -179,7 +179,7 @@ function(add_addon_depends addon searchpath) "${extraflags}" -P ${PROJECT_SOURCE_DIR}/install.cmake) elseif(EXISTS ${dir}/noinstall.txt) - set(INSTALL_COMMAND INSTALL_COMMAND "") + set(INSTALL_COMMAND INSTALL_COMMAND ${CMAKE_COMMAND} -E true) endif() # check if there's a platform-specific or generic deps.txt containing dependencies on other libraries diff --git a/cmake/scripts/common/Macros.cmake b/cmake/scripts/common/Macros.cmake index 49198a1c437c9..2de421f53aeb9 100644 --- a/cmake/scripts/common/Macros.cmake +++ b/cmake/scripts/common/Macros.cmake @@ -717,15 +717,51 @@ macro(core_find_versions) # Set defines used in addon.xml.in and read from versions.h to set add-on # version parts automatically - # This part is nearly identical to "AddonHelpers.cmake", except location of versions.h - file(STRINGS ${CORE_SOURCE_DIR}/xbmc/addons/kodi-dev-kit/include/kodi/versions.h BIN_ADDON_PARTS) + # This part is nearly identical to "AddonHelpers.cmake", except location of version.h + file(STRINGS ${CORE_SOURCE_DIR}/xbmc/addons/kodi-dev-kit/include/kodi/c-api/version.h BIN_ADDON_PARTS) + set(__KDK_API_OLDEST__ 10000) foreach(loop_var ${BIN_ADDON_PARTS}) - string(FIND "${loop_var}" "#define ADDON_" matchres) + string(FIND "${loop_var}" "#define __KDK_MAJOR__" matchres) if("${matchres}" EQUAL 0) string(REGEX MATCHALL "[A-Z0-9._]+|[A-Z0-9._]+$" loop_var "${loop_var}") list(GET loop_var 0 include_name) - list(GET loop_var 1 include_version) - string(REGEX REPLACE ".*\"(.*)\"" "\\1" ${include_name} ${include_version}) + list(GET loop_var 1 include_value) + string(REGEX REPLACE ".*\"(.*)\"" "\\1" ${include_name} ${include_value}) + endif() + string(FIND "${loop_var}" "#define __KDK_MINOR__" matchres) + if("${matchres}" EQUAL 0) + string(REGEX MATCHALL "[A-Z0-9._]+|[A-Z0-9._]+$" loop_var "${loop_var}") + list(GET loop_var 0 include_name) + list(GET loop_var 1 include_value) + string(REGEX REPLACE ".*\"(.*)\"" "\\1" ${include_name} ${include_value}) + endif() + string(FIND "${loop_var}" "#define __KDK_BETA__" matchres) + if("${matchres}" EQUAL 0) + string(REGEX MATCHALL "[A-Z0-9._]+|[A-Z0-9._]+$" loop_var "${loop_var}") + list(GET loop_var 0 include_name) + list(GET loop_var 1 include_value) + string(REGEX REPLACE ".*\"(.*)\"" "\\1" ${include_name} ${include_value}) + endif() + string(FIND "${loop_var}" "#define __KDK_CANARY__" matchres) + if("${matchres}" EQUAL 0) + string(REGEX MATCHALL "[A-Z0-9._]+|[A-Z0-9._]+$" loop_var "${loop_var}") + list(GET loop_var 0 include_name) + list(GET loop_var 1 include_value) + string(REGEX REPLACE ".*\"(.*)\"" "\\1" ${include_name} ${include_value}) + if(__KDK_CANARY__ EQUAL 1) + set(__KDK_CANARY_XML__ "true") + else() + set(__KDK_CANARY_XML__ "false") + endif() + endif() + string(FIND "${loop_var}" "#define __KODI_API_" matchres) + if("${matchres}" EQUAL 0) + string(REGEX MATCHALL "[A-Z0-9._]+|[A-Z0-9._]+$" loop_var "${loop_var}") + list(GET loop_var 0 include_name) + list(GET loop_var 1 include_value) + if(include_value LESS ${__KDK_API_OLDEST__}) + set(__KDK_API_OLDEST__ ${include_value}) + endif() endif() endforeach(loop_var) @@ -785,5 +821,5 @@ macro(find_addon_xml_in_files) endforeach() # Append also versions.h to depends - list(APPEND ADDON_XML_DEPENDS "${CORE_SOURCE_DIR}/xbmc/addons/kodi-dev-kit/include/kodi/versions.h") + list(APPEND ADDON_XML_DEPENDS "${CORE_SOURCE_DIR}/xbmc/addons/kodi-dev-kit/include/kodi/c-api/version.h") endmacro() diff --git a/cmake/scripts/linux/ArchSetup.cmake b/cmake/scripts/linux/ArchSetup.cmake index 848723af1fa50..0d9519cd9330c 100644 --- a/cmake/scripts/linux/ArchSetup.cmake +++ b/cmake/scripts/linux/ArchSetup.cmake @@ -202,3 +202,6 @@ endif() # Atomic library list(APPEND PLATFORM_REQUIRED_DEPS Atomic) + +# Additional libraries +list(APPEND DEPLIBS rt) # Shared dev kit interface diff --git a/cmake/treedata/common/addon_dev_kit.txt b/cmake/treedata/common/addon_dev_kit.txt index ba39702d99038..c626a06e86146 100644 --- a/cmake/treedata/common/addon_dev_kit.txt +++ b/cmake/treedata/common/addon_dev_kit.txt @@ -3,6 +3,7 @@ xbmc/addons/kodi-dev-kit/include/kodi addons_kodi-dev-kit_include_kodi xbmc/addons/kodi-dev-kit/include/kodi/c-api addons_kodi-dev-kit_include_kodi_c-api +xbmc/addons/kodi-dev-kit/include/kodi/c-api/dl addons_kodi-dev-kit_include_kodi_c-api_dl xbmc/addons/kodi-dev-kit/include/kodi/c-api/platform addons_kodi-dev-kit_include_kodi_c-api_platform xbmc/addons/kodi-dev-kit/include/kodi/c-api/platform/android addons_kodi-dev-kit_include_kodi_c-api_platform_android xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance addons_kodi-dev-kit_include_kodi_c-api_addon-instance @@ -24,3 +25,6 @@ xbmc/addons/kodi-dev-kit/include/kodi/gui/controls addons_kodi-dev-kit_include_k xbmc/addons/kodi-dev-kit/include/kodi/gui/input addons_kodi-dev-kit_include_kodi_gui_input xbmc/addons/kodi-dev-kit/include/kodi/gui/gl addons_kodi-dev-kit_include_kodi_gui_gl xbmc/addons/kodi-dev-kit/include/kodi/tools addons_kodi-dev-kit_include_kodi_tools +xbmc/addons/kodi-dev-kit/src/shared devkit_shared # Hardcoded entry, edit script for change! +xbmc/addons/kodi-dev-kit/src/addon kodidevkit # Hardcoded entry, edit script for change! +xbmc/addons/kodi-dev-kit/src/addon_runner addon_runner # Hardcoded entry, edit script for change! diff --git a/cmake/treedata/common/addon_interface.txt b/cmake/treedata/common/addon_interface.txt new file mode 100644 index 0000000000000..0245bf040fe3e --- /dev/null +++ b/cmake/treedata/common/addon_interface.txt @@ -0,0 +1,14 @@ +# Auto generated cmake/treedata/common/addon_interface.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +xbmc/addons/interface addons_interface +xbmc/addons/interface/renderer addons_interface_renderer +xbmc/addons/interface/gui addons_interface_gui +xbmc/addons/interface/tools addons_interface_tools +xbmc/addons/interface/api addons_interface_api +xbmc/addons/interface/api/addon-instance addons_interface_api_addon-instance +xbmc/addons/interface/api/gui addons_interface_api_gui +xbmc/addons/interface/api/gui/dialogs addons_interface_api_gui_dialogs +xbmc/addons/interface/api/gui/controls addons_interface_api_gui_controls +xbmc/addons/interface/launcher addons_interface_launcher +xbmc/addons/interface/processinfo addons_interface_processinfo diff --git a/cmake/treedata/common/subdirs.txt b/cmake/treedata/common/subdirs.txt index 006c7ab4f7716..0ce81c68e471d 100644 --- a/cmake/treedata/common/subdirs.txt +++ b/cmake/treedata/common/subdirs.txt @@ -1,13 +1,8 @@ xbmc xbmc xbmc/addons addons xbmc/addons/addoninfo addons_addoninfo -xbmc/addons/binary-addons addons_binary-addons xbmc/addons/gui addons_gui xbmc/addons/gui/skin addons_gui_skin -xbmc/addons/interfaces addons_interfaces -xbmc/addons/interfaces/gui addons_interfaces_gui -xbmc/addons/interfaces/gui/controls addons_interfaces_gui_controls -xbmc/addons/interfaces/gui/dialogs addons_interfaces_gui_dialogs xbmc/addons/settings addons_settings xbmc/application application xbmc/commons commons @@ -42,5 +37,8 @@ xbmc/threads threads xbmc/utils utils xbmc/view view xbmc/weather weather +xbmc/web webaddons +xbmc/web/dialogs webaddons_dialogs +xbmc/web/windows webaddons_windows xbmc/windowing windowing xbmc/windows windows diff --git a/kodiInstance b/kodiInstance new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/system/addon-manifest.xml b/system/addon-manifest.xml index 7df13a6d6f5ad..fcb27a349bac0 100644 --- a/system/addon-manifest.xml +++ b/system/addon-manifest.xml @@ -5,24 +5,7 @@ game.controller.keyboard game.controller.mouse game.controller.snes - kodi.binary.global.audioengine - kodi.binary.global.filesystem - kodi.binary.global.general - kodi.binary.global.gui - kodi.binary.global.main - kodi.binary.global.network - kodi.binary.global.tools - kodi.binary.instance.audiodecoder - kodi.binary.instance.audioencoder - kodi.binary.instance.game - kodi.binary.instance.imagedecoder - kodi.binary.instance.inputstream - kodi.binary.instance.peripheral - kodi.binary.instance.pvr - kodi.binary.instance.screensaver - kodi.binary.instance.vfs - kodi.binary.instance.videocodec - kodi.binary.instance.visualization + kodi.binary.devkit kodi.resource metadata.album.universal metadata.artists.universal diff --git a/system/keymaps/Keymap.xml b/system/keymaps/Keymap.xml new file mode 100644 index 0000000000000..7765e9d87b691 --- /dev/null +++ b/system/keymaps/Keymap.xml @@ -0,0 +1,12 @@ + + + + + ActivateWindow(WebBrowserFullScreen) + ActivateWindow(WebBrowser) + XBMC.ReloadSkin() + Skin.ToggleSetting(DebugGrid) + Notification(Testing 123,Hello world) + + + diff --git a/system/keymaps/keyboard.xml b/system/keymaps/keyboard.xml index 1c64413d7c16b..7dc71b617c968 100644 --- a/system/keymaps/keyboard.xml +++ b/system/keymaps/keyboard.xml @@ -828,4 +828,18 @@ ToggleFont + + + ZoomIn + ZoomOut + ActivateWindow(Home) + + + + + ZoomIn + ZoomOut + PreviousMenu + + diff --git a/system/shaders/GL/1.2/gl_shader_frag_addon_backend.glsl b/system/shaders/GL/1.2/gl_shader_frag_addon_backend.glsl new file mode 100644 index 0000000000000..c4499623256e5 --- /dev/null +++ b/system/shaders/GL/1.2/gl_shader_frag_addon_backend.glsl @@ -0,0 +1,15 @@ +// uniforms +uniform sampler2D u_sampler; +uniform bool u_clearColor; +uniform vec4 u_backgroundColor; + +// varyings +varying vec2 v_coord; + +void main() +{ + if (u_clearColor) + gl_FragColor = u_backgroundColor; + else + gl_FragColor = vec4(texture2D(u_sampler, v_coord)); +} diff --git a/system/shaders/GL/1.2/gl_shader_vert_addon_backend.glsl b/system/shaders/GL/1.2/gl_shader_vert_addon_backend.glsl new file mode 100644 index 0000000000000..3e3bcd354a6bc --- /dev/null +++ b/system/shaders/GL/1.2/gl_shader_vert_addon_backend.glsl @@ -0,0 +1,15 @@ +// uniforms +uniform mat4 u_modelProjMatrix; + +// attributes +attribute vec4 a_position; +attribute vec2 a_coord; + +// varyings +varying vec2 v_coord; + +void main() +{ + gl_Position = u_modelProjMatrix * a_position; + v_coord = a_coord; +} diff --git a/system/shaders/GL/1.5/gl_shader_frag_addon_backend.glsl b/system/shaders/GL/1.5/gl_shader_frag_addon_backend.glsl new file mode 100644 index 0000000000000..566b70bcd5489 --- /dev/null +++ b/system/shaders/GL/1.5/gl_shader_frag_addon_backend.glsl @@ -0,0 +1,12 @@ +#version 150 + +out vec4 FragColor; + +in vec2 TexCoords; + +uniform sampler2D Texture1; + +void main() +{ + FragColor = texture(Texture1, TexCoords); +} diff --git a/system/shaders/GL/1.5/gl_shader_vert_addon_backend.glsl b/system/shaders/GL/1.5/gl_shader_vert_addon_backend.glsl new file mode 100644 index 0000000000000..704d4e929e3fd --- /dev/null +++ b/system/shaders/GL/1.5/gl_shader_vert_addon_backend.glsl @@ -0,0 +1,12 @@ +#version 150 + +in vec3 aPos; +in vec2 aTexCoords; + +out vec2 TexCoords; + +void main() +{ + TexCoords = aTexCoords; + gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0); +} diff --git a/system/shaders/GLES/2.0/gles_shader_frag_addon_backend.glsl b/system/shaders/GLES/2.0/gles_shader_frag_addon_backend.glsl new file mode 100644 index 0000000000000..4d9c2ae84eb40 --- /dev/null +++ b/system/shaders/GLES/2.0/gles_shader_frag_addon_backend.glsl @@ -0,0 +1,17 @@ +#version 100 + +// uniforms +uniform sampler2D u_sampler; +uniform bool u_clearColor; +uniform vec4 u_backgroundColor; + +// varyings +varying vec2 v_coord; + +void main() +{ + if (u_clearColor) + gl_FragColor = u_backgroundColor; + else + gl_FragColor = vec4(texture2D(u_sampler, v_coord)); +} diff --git a/system/shaders/GLES/2.0/gles_shader_vert_addon_backend.glsl b/system/shaders/GLES/2.0/gles_shader_vert_addon_backend.glsl new file mode 100644 index 0000000000000..4b31d68db6e07 --- /dev/null +++ b/system/shaders/GLES/2.0/gles_shader_vert_addon_backend.glsl @@ -0,0 +1,17 @@ +#version 100 + +// uniforms +uniform mat4 u_modelProjMatrix; + +// attributes +attribute vec4 a_position; +attribute vec2 a_coord; + +// varyings +varying vec2 v_coord; + +void main() +{ + gl_Position = u_modelProjMatrix * a_position; + v_coord = a_coord; +} diff --git a/toKodi- b/toKodi- new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/xbmc/AppParamParser.cpp b/xbmc/AppParamParser.cpp index 66b1324aba1a2..696808d34a5ab 100644 --- a/xbmc/AppParamParser.cpp +++ b/xbmc/AppParamParser.cpp @@ -40,6 +40,8 @@ constexpr const char* helpText = --debug Enable debug logging --version Print version information --test Enable test mode. [FILE] required. + -ns or --nosandbox If set, do not run the installed addons in independent processes. They are then + performed within Kodi itself. --settings= Loads specified file after advancedsettings.xml replacing any settings specified specified file must exist in special://xbmc/system/ )"""; @@ -92,6 +94,8 @@ void CAppParamParser::ParseArg(const std::string &arg) { if (arg == "-fs" || arg == "--fullscreen") m_params->SetStartFullScreen(true); + else if (arg == "-ns" || arg == "--nosandbox") + m_params->SetNoSandbox(true); else if (arg == "-h" || arg == "--help") { DisplayHelp(); diff --git a/xbmc/AppParams.h b/xbmc/AppParams.h index 4452cd7383d8b..25dfcda338c62 100644 --- a/xbmc/AppParams.h +++ b/xbmc/AppParams.h @@ -28,6 +28,9 @@ class CAppParams bool IsStartFullScreen() const { return m_startFullScreen; } void SetStartFullScreen(bool startFullScreen) { m_startFullScreen = startFullScreen; } + bool IsNoSandbox() const { return m_noSandbox; } + void SetNoSandbox(bool noSandbox) { m_noSandbox = noSandbox; } + bool IsStandAlone() const { return m_standAlone; } void SetStandAlone(bool standAlone) { m_standAlone = standAlone; } @@ -74,6 +77,11 @@ class CAppParams int m_logLevel{LOG_LEVEL_NORMAL}; bool m_startFullScreen{false}; +#ifndef KODI_INHIBIT_SHARED + bool m_noSandbox{false}; +#else + bool m_noSandbox{true}; +#endif bool m_standAlone{false}; bool m_platformDirectories{true}; bool m_testmode{false}; diff --git a/xbmc/Application.cpp b/xbmc/Application.cpp index d053d60cdd1cb..2dbc6617bf8e8 100644 --- a/xbmc/Application.cpp +++ b/xbmc/Application.cpp @@ -19,6 +19,7 @@ #include "Util.h" #include "addons/Skin.h" #include "addons/VFSEntry.h" +#include "addons/interface/Controller.h" #include "cores/AudioEngine/Engines/ActiveAE/ActiveAE.h" #include "cores/IPlayer.h" #include "cores/playercorefactory/PlayerCoreFactory.h" @@ -137,14 +138,16 @@ #include "pvr/PVRManager.h" #include "pvr/guilib/PVRGUIActions.h" -#include "dialogs/GUIDialogCache.h" -#include "utils/URIUtils.h" -#include "utils/XMLUtils.h" +#include "CompileInfo.h" #include "addons/AddonInstaller.h" #include "addons/AddonManager.h" #include "addons/RepositoryUpdater.h" +#include "dialogs/GUIDialogCache.h" #include "music/tags/MusicInfoTag.h" -#include "CompileInfo.h" +#include "utils/URIUtils.h" +#include "utils/XMLUtils.h" +#include "video/dialogs/GUIDialogFullScreenInfo.h" +#include "web/WebManager.h" #ifdef TARGET_WINDOWS #include "win32util.h" @@ -2001,6 +2004,9 @@ bool CApplication::Stop(int exitCode) bool success = true; + CLog::Log(LOGINFO, "Stopping webbrowser"); + CServiceBroker::GetWEBManager().Deinit(); + CLog::Log(LOGINFO, "Stopping player"); m_appPlayer.ClosePlayer(); @@ -2871,14 +2877,17 @@ bool CApplication::ExecuteXBMCAction(std::string actionStr, const CGUIListItemPt return true; } CFileItem item(actionStr, false); + if (item.IsWeb()) + { + CServiceBroker::GetWEBManager().ExecuteItem(item); + } #ifdef HAS_PYTHON - if (item.IsPythonScript()) + else if (item.IsPythonScript()) { // a python script CScriptInvocationManager::GetInstance().ExecuteAsync(item.GetPath()); } - else #endif - if (item.IsAudio() || item.IsVideo() || item.IsGame()) + else if (item.IsAudio() || item.IsVideo() || item.IsGame()) { // an audio or video file PlayFile(item, ""); } @@ -2997,6 +3006,15 @@ void CApplication::Process() m_frameMoveGuard.lock(); } + // The Chromium-based web browser addon needs the main thread in all + // circumstances, without massive error messages and uncontrollable + // crashes. Furthermore, processing the render information between + // different threads causes further problems. + // + // Unfortunately, this is due to the Chromium system, which was not + // constructed directly as a library, but as an independent exe. + CServiceBroker::GetWEBManager().MainLoop(); + // process messages, even if a movie is playing CServiceBroker::GetAppMessenger()->ProcessMessages(); if (m_bStop) return; //we're done, everything has been unloaded diff --git a/xbmc/DatabaseManager.cpp b/xbmc/DatabaseManager.cpp index 5398ff3175e88..ce68eadc498b3 100644 --- a/xbmc/DatabaseManager.cpp +++ b/xbmc/DatabaseManager.cpp @@ -19,6 +19,7 @@ #include "utils/log.h" #include "video/VideoDatabase.h" #include "view/ViewDatabase.h" +#include "web/WebDatabase.h" #include @@ -56,6 +57,10 @@ void CDatabaseManager::Initialize() { CVideoDatabase db; UpdateDatabase(db, &advancedSettings->m_databaseVideo); } { CPVRDatabase db; UpdateDatabase(db, &advancedSettings->m_databaseTV); } { CPVREpgDatabase db; UpdateDatabase(db, &advancedSettings->m_databaseEpg); } + { + KODI::WEB::CWebDatabase db; + UpdateDatabase(db, &advancedSettings->m_databaseWeb); + } CLog::Log(LOGDEBUG, "{}, updating databases... DONE", __FUNCTION__); diff --git a/xbmc/FileItem.cpp b/xbmc/FileItem.cpp index 4afeb5f84de49..128867fb37bf9 100644 --- a/xbmc/FileItem.cpp +++ b/xbmc/FileItem.cpp @@ -1126,7 +1126,7 @@ bool CFileItem::IsFileFolder(EFileFolderType types) const return true; } - if (CServiceBroker::IsBinaryAddonCacheUp() && + if (CServiceBroker::IsAddonInterfaceUp() && IsType(CServiceBroker::GetFileExtensionProvider().GetFileFolderExtensions().c_str()) && CServiceBroker::GetFileExtensionProvider().CanOperateExtension(m_strPath)) return true; @@ -1258,6 +1258,11 @@ bool CFileItem::IsAndroidApp() const return URIUtils::IsAndroidApp(m_strPath); } +bool CFileItem::IsWeb() const +{ + return URIUtils::IsWeb(m_strPath); +} + bool CFileItem::IsStack() const { return URIUtils::IsStack(m_strPath); diff --git a/xbmc/FileItem.h b/xbmc/FileItem.h index 881eb05b01fc3..2b861e097465a 100644 --- a/xbmc/FileItem.h +++ b/xbmc/FileItem.h @@ -255,6 +255,7 @@ class CFileItem : bool IsLiveTV() const; bool IsRSS() const; bool IsAndroidApp() const; + bool IsWeb() const; void RemoveExtension(); void CleanString(); diff --git a/xbmc/GUIInfoManager.cpp b/xbmc/GUIInfoManager.cpp index 2a2706ae90e9e..729e475989455 100644 --- a/xbmc/GUIInfoManager.cpp +++ b/xbmc/GUIInfoManager.cpp @@ -1291,6 +1291,12 @@ const infomap weather[] = {{ "isfetched", WEATHER_IS_FETCHED }, /// @return **True** if Kodi is running in standalone mode. ///

/// } +/// \table_row3{ `System.IsNoSandbox`, +/// \anchor System_IsNoSandbox +/// _boolean_, +/// @return **True** if do not run the installed addons in independent processes. +///

+/// } /// \table_row3{ `System.IsFullscreen`, /// \anchor System_IsFullscreen /// _boolean_, @@ -1884,6 +1890,7 @@ const infomap system_labels[] = { {"ismaster", SYSTEM_ISMASTER}, {"isfullscreen", SYSTEM_ISFULLSCREEN}, {"isstandalone", SYSTEM_ISSTANDALONE}, + {"isnosandbox", SYSTEM_ISNOSANDBOX}, {"loggedon", SYSTEM_LOGGEDON}, {"showexitbutton", SYSTEM_SHOW_EXIT_BUTTON}, {"canpowerdown", SYSTEM_CAN_POWERDOWN}, @@ -4697,12 +4704,20 @@ const infomap container_str[] = {{ "property", CONTAINER_PROPERTY }, /// @skinning_v19 **[New Boolean Condition]** \link ListItem_Property_AddonIsUpdate `ListItem.Property(Addon.IsUpdate)`\endlink ///

/// } +/// \table_row3{ `ListItem.Property(Addon.ProgrammingLanguage)`, +/// \anchor ListItem_Property_AddonProgrammingLanguage +/// _string_, +/// @return The programming language of the selected add-on. +///

+/// @skinning_v19 **[New Infolabel]** \link ListItem_Property_ProgrammingLanguage `ListItem.Property(Addon.ProgrammingLanguage)`\endlink +///

+/// } /// \table_row3{ `ListItem.Property(Addon.ValidUpdateOrigin)`, /// \anchor ListItem_Property_ValidUpdateOrigin /// _string_, /// @return The origin string of a valid update for the addon. Empty string if there is no valid update available. ///

-/// @skinning_v19 **[New Infolabel]** \link ListItem_Property_ValidUpdateOrigin `ListItem.Property(Addon.ValidUpdateOrigin)`\endlink +/// @skinning_v20 **[New Infolabel]** \link ListItem_Property_ValidUpdateOrigin `ListItem.Property(Addon.ValidUpdateOrigin)`\endlink ///

/// } /// \table_row3{ `ListItem.Property(Addon.ValidUpdateVersion)`, @@ -7518,6 +7533,96 @@ const infomap playlist[] = {{ "length", PLAYLIST_LENGTH }, { "isrepeat", PLAYLIST_ISREPEAT }, { "isrepeatone", PLAYLIST_ISREPEATONE }}; +// clang-format off +/// \page modules__infolabels_boolean_conditions +/// \subsection modules__infolabels_boolean_conditions_Web Web +/// \table_start +/// \table_h3{ Labels, Type, Description } +/// \table_row3{ `Web.HasAddons`, +/// \anchor Web_HasAddons +/// _integer_, +/// @return **True** when the system is have a internet related addon present. +///

+/// } +/// \table_row3{ `Web.HasBrowser`, +/// \anchor Web_HasBrowser +/// _integer_, +/// @return **True** when the system is have a web browser addon present. +///

+/// } +/// \table_end +/// +/// ----------------------------------------------------------------------------- +const infomap web[] = {{ "hasaddons", WEB_HAS_ADDONS }, + { "hasbrowser", WEB_HAS_BROWSER }}; +// clang-format on + +// clang-format off +/// \page modules__infolabels_boolean_conditions +/// \subsection modules__infolabels_boolean_conditions_WebControl Web GUI control +/// \table_start +/// \table_h3{ Labels, Type, Description } +/// \table_row3{ `WebControl.OpenedAddress`, +/// \anchor WebControl_OpenedAddress +/// _integer_, +/// @return The currently on shown web control opened website address. +///

+/// } +/// \table_row3{ `WebControl.OpenedTitle`, +/// \anchor WebControl_OpenedTitle +/// _integer_, +/// @return The currently on shown web control opened website title. +///

+/// } +/// \table_row3{ `WebControl.IconURL`, +/// \anchor WebControl_IconURL +/// _integer_, +/// @return The icon URL of currently opened website. +///

+/// } +/// \table_row3{ `WebControl.IsLoading`, +/// \anchor WebControl_IsLoading +/// _integer_, +/// @return **True** when the focused web control is loading. +///

+/// } +/// \table_row3{ `WebControl.CanGoBack`, +/// \anchor WebControl_CanGoBack +/// _integer_, +/// @return **True** when the focused web site allow to go back. +///

+/// } +/// \table_row3{ `WebControl.CanGoForward`, +/// \anchor WebControl_CanGoForward +/// _integer_, +/// @return **True** when the focused web site allow to go forward. +///

+/// } +/// \table_row3{ `WebControl.ToolTip`, +/// \anchor WebControl_ToolTip +/// _integer_, +/// @return The website tooltip of currently focused website content. +///

+/// } +/// \table_row3{ `WebControl.StatusMessage`, +/// \anchor WebControl_StatusMessage +/// _integer_, +/// @return The website status message of currently opened website. +///

+/// } +/// \table_end +/// +/// ----------------------------------------------------------------------------- +const infomap webcontrol[] = {{ "openedaddress", WEB_CONTROL_OPENED_ADDRESS }, + { "openedtitle", WEB_CONTROL_OPENED_TITLE }, + { "iconurl", WEB_CONTROL_ICONURL }, + { "isloading", WEB_CONTROL_IS_LOADING }, + { "cangoback", WEB_CONTROL_CAN_GO_BACK }, + { "cangoforward", WEB_CONTROL_CAN_GO_FORWARD }, + { "tooltip", WEB_CONTROL_TOOLTIP }, + { "statusmessage", WEB_CONTROL_STATUS_MESSAGE }}; +// clang-format on + /// \page modules__infolabels_boolean_conditions /// \subsection modules__infolabels_boolean_conditions_Pvr Pvr /// \table_start @@ -10398,6 +10503,22 @@ int CGUIInfoManager::TranslateSingleString(const std::string &strCondition, bool return rd.val; } } + else if (cat.name == "web") + { + for (const infomap& i : web) + { + if (prop.name == i.str) + return i.val; + } + } + else if (cat.name == "webcontrol") + { + for (const infomap& i : webcontrol) + { + if (prop.name == i.str) + return i.val; + } + } } else if (info.size() == 3 || info.size() == 4) { diff --git a/xbmc/GUIUserMessages.h b/xbmc/GUIUserMessages.h index 2662bb1af7305..c1a5a2a00e785 100644 --- a/xbmc/GUIUserMessages.h +++ b/xbmc/GUIUserMessages.h @@ -140,3 +140,28 @@ constexpr const int GUI_MSG_PLAYBACK_AVSTARTED = GUI_MSG_USER + 44; // Sent to notify system sleep/wake constexpr const int GUI_MSG_SYSTEM_SLEEP = GUI_MSG_USER + 45; constexpr const int GUI_MSG_SYSTEM_WAKE = GUI_MSG_USER + 46; + +/*! Web control messages */ +//@{ +// Sent to tell that web addon control is ready and related processes can be done +constexpr const int GUI_MSG_WEB_ADDON_READY = GUI_MSG_USER + 50; +// Sent to tell that control is already open and was only inactive +constexpr const int GUI_MSG_WEB_CONTROL_REOPEN = GUI_MSG_USER + 51; +// Sent to change on URL entry field the active string +constexpr const int GUI_MSG_WEB_UPDATE_ADDRESS = GUI_MSG_USER + 52; +constexpr const int GUI_MSG_WEB_UPDATE_NAME = GUI_MSG_USER + 53; +constexpr const int GUI_MSG_WEB_UPDATE_ICON = GUI_MSG_USER + 54; +constexpr const int GUI_MSG_WEB_NEW_TAB = GUI_MSG_USER + 55; +constexpr const int GUI_MSG_WEB_OPEN_TAB = GUI_MSG_USER + 56; + +/*! + * GUI messages send to add-on to handle steps inside control + */ +constexpr const int GUI_MSG_WEB_CONTROL_GO_BACK = GUI_MSG_USER + 60; +constexpr const int GUI_MSG_WEB_CONTROL_GO_FWD = GUI_MSG_USER + 61; +constexpr const int GUI_MSG_WEB_CONTROL_LOAD = GUI_MSG_USER + 62; +constexpr const int GUI_MSG_WEB_CONTROL_RELOAD = GUI_MSG_USER + 63; +constexpr const int GUI_MSG_WEB_CONTROL_HOME = GUI_MSG_USER + 64; +constexpr const int GUI_MSG_WEB_CONTROL_SETTINGS = GUI_MSG_USER + 65; +constexpr const int GUI_MSG_WEB_CONTROL_ADD_TO_FAVOURITES = GUI_MSG_USER + 66; +//@} diff --git a/xbmc/LangInfo.cpp b/xbmc/LangInfo.cpp index 1db7f79084065..4682e5cd3484e 100644 --- a/xbmc/LangInfo.cpp +++ b/xbmc/LangInfo.cpp @@ -29,6 +29,7 @@ #include "utils/XMLUtils.h" #include "utils/log.h" #include "weather/WeatherManager.h" +#include "web/WebManager.h" #include #include @@ -771,6 +772,7 @@ bool CLangInfo::SetLanguage(std::string language /* = "" */, bool reloadServices // also tell our weather and skin to reload as these are localized CServiceBroker::GetWeatherManager().Refresh(); CServiceBroker::GetPVRManager().LocalizationChanged(); + CServiceBroker::GetWEBManager().SetLanguage(language); CServiceBroker::GetAppMessenger()->PostMsg(TMSG_EXECUTE_BUILT_IN, -1, -1, nullptr, "ReloadSkin"); } diff --git a/xbmc/ServiceBroker.cpp b/xbmc/ServiceBroker.cpp index e0011a9bcd06c..c481e6afd4d18 100644 --- a/xbmc/ServiceBroker.cpp +++ b/xbmc/ServiceBroker.cpp @@ -82,14 +82,9 @@ ADDON::CAddonMgr& CServiceBroker::GetAddonMgr() return g_application.m_ServiceManager->GetAddonMgr(); } -ADDON::CBinaryAddonManager& CServiceBroker::GetBinaryAddonManager() +KODI::ADDONS::INTERFACE::CController& CServiceBroker::GetAddonIfcCtrl() { - return g_application.m_ServiceManager->GetBinaryAddonManager(); -} - -ADDON::CBinaryAddonCache& CServiceBroker::GetBinaryAddonCache() -{ - return g_application.m_ServiceManager->GetBinaryAddonCache(); + return g_application.m_ServiceManager->GetAddonIfcCtrl(); } ADDONS::CExtsMimeSupportList& CServiceBroker::GetExtsMimeSupportList() @@ -213,7 +208,12 @@ CNetworkBase& CServiceBroker::GetNetwork() return g_application.m_ServiceManager->GetNetwork(); } -bool CServiceBroker::IsBinaryAddonCacheUp() +WEB::CWebManager& CServiceBroker::GetWEBManager() +{ + return g_application.m_ServiceManager->GetWEBManager(); +} + +bool CServiceBroker::IsAddonInterfaceUp() { return g_application.m_ServiceManager && g_application.m_ServiceManager->init_level > 1; } diff --git a/xbmc/ServiceBroker.h b/xbmc/ServiceBroker.h index 332d71b4f03ec..145db338bb57e 100644 --- a/xbmc/ServiceBroker.h +++ b/xbmc/ServiceBroker.h @@ -15,8 +15,6 @@ namespace ADDON { class CAddonMgr; -class CBinaryAddonManager; -class CBinaryAddonCache; class CVFSAddonCache; class CServiceAddonManager; class CRepositoryUpdater; @@ -52,6 +50,7 @@ class CApplicationMessenger; class CAppParams; class CContextMenuManager; + class XBPython; class CDataCacheCore; class IAE; @@ -85,10 +84,19 @@ class IWSDiscovery; namespace KODI { + namespace ADDONS { + class CExtsMimeSupportList; -} + +namespace INTERFACE +{ +class CController; +} /* namespace INTERFACE */ + +} /* namespace ADDONS */ + namespace GAME { @@ -100,6 +108,12 @@ namespace RETRO { class CGUIGameRenderManager; } + +namespace WEB +{ +class CWebManager; +} + } // namespace KODI namespace PERIPHERALS @@ -132,10 +146,9 @@ class CServiceBroker static void UnregisterAnnouncementManager(); static ADDON::CAddonMgr& GetAddonMgr(); - static ADDON::CBinaryAddonManager& GetBinaryAddonManager(); - static ADDON::CBinaryAddonCache& GetBinaryAddonCache(); static KODI::ADDONS::CExtsMimeSupportList& GetExtsMimeSupportList(); static ADDON::CVFSAddonCache& GetVFSAddonCache(); + static KODI::ADDONS::INTERFACE::CController& GetAddonIfcCtrl(); static XBPython& GetXBPython(); static WSDiscovery::IWSDiscovery& GetWSDiscovery(); static MEDIA_DETECT::CDetectDVDMedia& GetDetectDVDMedia(); @@ -153,7 +166,8 @@ class CServiceBroker static ADDON::CRepositoryUpdater& GetRepositoryUpdater(); static CInputManager& GetInputManager(); static CFileExtensionProvider& GetFileExtensionProvider(); - static bool IsBinaryAddonCacheUp(); + static KODI::WEB::CWebManager& GetWEBManager(); + static bool IsAddonInterfaceUp(); static bool IsServiceManagerUp(); static CNetworkBase& GetNetwork(); static CPowerManager& GetPowerManager(); diff --git a/xbmc/ServiceManager.cpp b/xbmc/ServiceManager.cpp index 72ae65c2eee84..250aa72a5a230 100644 --- a/xbmc/ServiceManager.cpp +++ b/xbmc/ServiceManager.cpp @@ -12,11 +12,10 @@ #include "DatabaseManager.h" #include "PlayListPlayer.h" #include "addons/AudioDecoder.h" -#include "addons/BinaryAddonCache.h" #include "addons/ExtsMimeSupportList.h" #include "addons/RepositoryUpdater.h" #include "addons/VFSEntry.h" -#include "addons/binary-addons/BinaryAddonManager.h" +#include "addons/interface/Controller.h" #include "cores/DataCacheCore.h" #include "cores/RetroPlayer/guibridge/GUIGameRenderManager.h" #include "cores/playercorefactory/PlayerCoreFactory.h" @@ -46,6 +45,7 @@ #include "utils/FileExtensionProvider.h" #include "utils/log.h" #include "weather/WeatherManager.h" +#include "web/WebManager.h" using namespace KODI; @@ -67,13 +67,19 @@ bool CServiceManager::InitForTesting() m_databaseManager.reset(new CDatabaseManager); - m_binaryAddonManager.reset(new ADDON::CBinaryAddonManager()); m_addonMgr.reset(new ADDON::CAddonMgr()); if (!m_addonMgr->Init()) { CLog::Log(LOGFATAL, "CServiceManager::{}: Unable to start CAddonMgr", __FUNCTION__); return false; } + m_addonIfcCtrl.reset(new KODI::ADDONS::INTERFACE::CController(*m_addonMgr)); + if (!m_addonIfcCtrl->Init()) + { + CLog::Log(LOGFATAL, "CServiceManager::{}: Unable to start KODI::ADDONS::INTERFACE::CController", + __func__); + return false; + } m_extsMimeSupportList.reset(new ADDONS::CExtsMimeSupportList(*m_addonMgr)); m_fileExtensionProvider.reset(new CFileExtensionProvider(*m_addonMgr)); @@ -87,7 +93,6 @@ void CServiceManager::DeinitTesting() init_level = 0; m_fileExtensionProvider.reset(); m_extsMimeSupportList.reset(); - m_binaryAddonManager.reset(); m_addonMgr.reset(); m_databaseManager.reset(); m_network.reset(); @@ -118,9 +123,6 @@ bool CServiceManager::InitStageTwo(const std::string& profilesUserDataFolder) // Initialize the addon database (must be before the addon manager is init'd) m_databaseManager.reset(new CDatabaseManager); - m_binaryAddonManager.reset( - new ADDON:: - CBinaryAddonManager()); /* Need to constructed before, GetRunningInstance() of binary CAddonDll need to call them */ m_addonMgr.reset(new ADDON::CAddonMgr()); if (!m_addonMgr->Init()) { @@ -128,6 +130,14 @@ bool CServiceManager::InitStageTwo(const std::string& profilesUserDataFolder) return false; } + m_addonIfcCtrl.reset(new KODI::ADDONS::INTERFACE::CController(*m_addonMgr)); + if (!m_addonIfcCtrl->Init()) + { + CLog::Log(LOGFATAL, "CServiceManager::{}: Unable to start KODI::ADDONS::INTERFACE::CController", + __func__); + return false; + } + m_repositoryUpdater.reset(new ADDON::CRepositoryUpdater(*m_addonMgr)); m_extsMimeSupportList.reset(new ADDONS::CExtsMimeSupportList(*m_addonMgr)); @@ -139,8 +149,7 @@ bool CServiceManager::InitStageTwo(const std::string& profilesUserDataFolder) m_dataCacheCore.reset(new CDataCacheCore()); - m_binaryAddonCache.reset(new ADDON::CBinaryAddonCache()); - m_binaryAddonCache->Init(); + m_webManager.reset(new WEB::CWebManager()); m_favouritesService.reset(new CFavouritesService(profilesUserDataFolder)); @@ -193,12 +202,16 @@ bool CServiceManager::InitStageThree(const std::shared_ptr& pro m_gameServices.reset(new GAME::CGameServices(*m_gameControllerManager, *m_gameRenderManager, *m_peripherals, *profileManager)); + m_gameServices->Init(); m_contextMenuManager->Init(); // Init PVR manager after login, not already on login screen if (!profileManager->UsingLoginScreen()) + { m_PVRManager->Init(); + m_webManager->Init(); + } m_playerCoreFactory.reset(new CPlayerCoreFactory(*profileManager)); @@ -233,6 +246,8 @@ void CServiceManager::DeinitStageTwo() m_WSDiscovery.reset(); #endif + m_webManager->Deinit(); + m_weatherManager.reset(); m_powerManager.reset(); m_fileExtensionProvider.reset(); @@ -243,13 +258,13 @@ void CServiceManager::DeinitStageTwo() m_contextMenuManager.reset(); m_serviceAddons.reset(); m_favouritesService.reset(); - m_binaryAddonCache.reset(); m_dataCacheCore.reset(); + m_webManager.reset(); m_PVRManager.reset(); m_extsMimeSupportList.reset(); m_vfsAddonCache.reset(); m_repositoryUpdater.reset(); - m_binaryAddonManager.reset(); + m_addonIfcCtrl.reset(); m_addonMgr.reset(); m_databaseManager.reset(); @@ -291,16 +306,6 @@ ADDONS::CExtsMimeSupportList& CServiceManager::GetExtsMimeSupportList() return *m_extsMimeSupportList; } -ADDON::CBinaryAddonCache& CServiceManager::GetBinaryAddonCache() -{ - return *m_binaryAddonCache; -} - -ADDON::CBinaryAddonManager& CServiceManager::GetBinaryAddonManager() -{ - return *m_binaryAddonManager; -} - ADDON::CVFSAddonCache& CServiceManager::GetVFSAddonCache() { return *m_vfsAddonCache; @@ -316,6 +321,11 @@ ADDON::CRepositoryUpdater& CServiceManager::GetRepositoryUpdater() return *m_repositoryUpdater; } +KODI::ADDONS::INTERFACE::CController& CServiceManager::GetAddonIfcCtrl() +{ + return *m_addonIfcCtrl; +} + #ifdef HAS_PYTHON XBPython& CServiceManager::GetXBPython() { @@ -395,6 +405,11 @@ CPowerManager& CServiceManager::GetPowerManager() return *m_powerManager; } +WEB::CWebManager& CServiceManager::GetWEBManager() +{ + return *m_webManager; +} + // deleters for unique_ptr void CServiceManager::delete_dataCacheCore::operator()(CDataCacheCore* p) const { diff --git a/xbmc/ServiceManager.h b/xbmc/ServiceManager.h index 9c99811a4068b..5dc60155cb34b 100644 --- a/xbmc/ServiceManager.h +++ b/xbmc/ServiceManager.h @@ -15,8 +15,6 @@ namespace ADDON { class CAddonMgr; -class CBinaryAddonManager; -class CBinaryAddonCache; class CVFSAddonCache; class CServiceAddonManager; class CRepositoryUpdater; @@ -51,10 +49,18 @@ class CWeatherManager; namespace KODI { + namespace ADDONS { + class CExtsMimeSupportList; -} + +namespace INTERFACE +{ +class CController; +} /* namespace INTERFACE */ + +} /* namespace ADDONS */ namespace GAME { @@ -66,6 +72,12 @@ namespace RETRO { class CGUIGameRenderManager; } + +namespace WEB +{ +class CWebManager; +} + } // namespace KODI namespace MEDIA_DETECT @@ -102,12 +114,11 @@ class CServiceManager void DeinitStageOne(); ADDON::CAddonMgr& GetAddonMgr(); - ADDON::CBinaryAddonManager& GetBinaryAddonManager(); - ADDON::CBinaryAddonCache& GetBinaryAddonCache(); KODI::ADDONS::CExtsMimeSupportList& GetExtsMimeSupportList(); ADDON::CVFSAddonCache& GetVFSAddonCache(); ADDON::CServiceAddonManager& GetServiceAddons(); ADDON::CRepositoryUpdater& GetRepositoryUpdater(); + KODI::ADDONS::INTERFACE::CController& GetAddonIfcCtrl(); CNetworkBase& GetNetwork(); #ifdef HAS_PYTHON XBPython& GetXBPython(); @@ -125,6 +136,7 @@ class CServiceManager KODI::GAME::CGameServices& GetGameServices(); KODI::RETRO::CGUIGameRenderManager& GetGameRenderManager(); PERIPHERALS::CPeripherals& GetPeripherals(); + KODI::WEB::CWebManager& GetWEBManager(); PLAYLIST::CPlayListPlayer& GetPlaylistPlayer(); int init_level = 0; @@ -164,12 +176,11 @@ class CServiceManager }; std::unique_ptr m_addonMgr; - std::unique_ptr m_binaryAddonManager; - std::unique_ptr m_binaryAddonCache; std::unique_ptr m_extsMimeSupportList; std::unique_ptr m_vfsAddonCache; std::unique_ptr m_serviceAddons; std::unique_ptr m_repositoryUpdater; + std::unique_ptr m_addonIfcCtrl; #if defined(HAS_FILESYSTEM_SMB) std::unique_ptr m_WSDiscovery; #endif @@ -194,6 +205,7 @@ class CServiceManager std::unique_ptr m_playerCoreFactory; std::unique_ptr m_databaseManager; std::unique_ptr m_mediaManager; + std::unique_ptr m_webManager; #if !defined(TARGET_WINDOWS) && defined(HAS_DVD_DRIVE) std::unique_ptr m_DetectDVDType; #endif diff --git a/xbmc/URL.cpp b/xbmc/URL.cpp index f4a66d0e802ed..62de53dac77dd 100644 --- a/xbmc/URL.cpp +++ b/xbmc/URL.cpp @@ -159,18 +159,10 @@ void CURL::Parse(const std::string& strURL1) //! @todo fix all Addon paths std::string strProtocol2 = GetTranslatedProtocol(); - if(IsProtocol("rss") || - IsProtocol("rsss") || - IsProtocol("rar") || - IsProtocol("apk") || - IsProtocol("xbt") || - IsProtocol("zip") || - IsProtocol("addons") || - IsProtocol("image") || - IsProtocol("videodb") || - IsProtocol("musicdb") || - IsProtocol("androidapp") || - IsProtocol("pvr")) + if (IsProtocol("rss") || IsProtocol("rsss") || IsProtocol("rar") || IsProtocol("apk") || + IsProtocol("xbt") || IsProtocol("zip") || IsProtocol("addons") || IsProtocol("image") || + IsProtocol("videodb") || IsProtocol("musicdb") || IsProtocol("androidapp") || + IsProtocol("pvr") || IsProtocol("web")) sep = "?"; else if( IsProtocolEqual(strProtocol2, "http") @@ -279,7 +271,8 @@ void CURL::Parse(const std::string& strURL1) m_strFileName = strURL.substr(iPos, iEnd - iPos); } - if (IsProtocol("musicdb") || IsProtocol("videodb") || IsProtocol("sources") || IsProtocol("pvr")) + if (IsProtocol("musicdb") || IsProtocol("videodb") || IsProtocol("sources") || + IsProtocol("pvr") || IsProtocol("web")) { if (m_strHostName != "" && m_strFileName != "") { diff --git a/xbmc/Util.cpp b/xbmc/Util.cpp index c30768c746b7c..721af2132e747 100644 --- a/xbmc/Util.cpp +++ b/xbmc/Util.cpp @@ -1487,7 +1487,7 @@ bool CUtil::SupportsWriteFileOperations(const std::string& strPath) return CMultiPathDirectory::SupportsWriteFileOperations(strPath); - if (CServiceBroker::IsBinaryAddonCacheUp()) + if (CServiceBroker::IsAddonInterfaceUp()) { CURL url(strPath); for (const auto& addon : CServiceBroker::GetVFSAddonCache().GetAddonInstances()) diff --git a/xbmc/addons/Addon.h b/xbmc/addons/Addon.h index 21cea8a011fe5..93210bdcf2c12 100644 --- a/xbmc/addons/Addon.h +++ b/xbmc/addons/Addon.h @@ -90,7 +90,7 @@ class CAddon : public IAddon * ~~~~~~~~~~~~~ * */ - const CAddonType* Type(TYPE type) const { return m_addonInfo->Type(type); } + const CAddonType* Type(TYPE type) const override { return m_addonInfo->Type(type); } std::string ID() const override { return m_addonInfo->ID(); } std::string Name() const override { return m_addonInfo->Name(); } @@ -397,6 +397,8 @@ class CAddon : public IAddon void OnPreUnInstall() override{}; void OnPostUnInstall() override{}; + AddonInfoPtr GetAddonInfo() override { return m_addonInfo; } + protected: /*! * \brief Whether or not the settings have been initialized. diff --git a/xbmc/addons/AddonBuilder.cpp b/xbmc/addons/AddonBuilder.cpp index 39dd3c9eed8e2..9b85931939522 100644 --- a/xbmc/addons/AddonBuilder.cpp +++ b/xbmc/addons/AddonBuilder.cpp @@ -21,7 +21,6 @@ #include "addons/Skin.h" #include "addons/UISoundsResource.h" #include "addons/Webinterface.h" -#include "games/addons/GameClient.h" #include "games/controllers/Controller.h" #include "pvr/addons/PVRClient.h" #include "utils/StringUtils.h" @@ -55,13 +54,14 @@ AddonPtr CAddonBuilder::Generate(const AddonInfoPtr& info, TYPE type) { // built in audio encoder if (StringUtils::StartsWithNoCase(info->ID(), "audioencoder.kodi.builtin.")) - return std::make_shared(info, type); + return std::make_shared(info, type); } switch (type) { case ADDON_AUDIODECODER: case ADDON_AUDIOENCODER: + case ADDON_GAMEDLL: case ADDON_IMAGEDECODER: case ADDON_INPUTSTREAM: case ADDON_PERIPHERALDLL: @@ -69,9 +69,8 @@ AddonPtr CAddonBuilder::Generate(const AddonInfoPtr& info, TYPE type) case ADDON_VFS: case ADDON_VIZ: case ADDON_SCREENSAVER: - return std::make_shared(info, type); - case ADDON_GAMEDLL: - return std::make_shared(info); + case ADDON_WEB_MANAGER: + return std::make_shared(info, type); case ADDON_PLUGIN: case ADDON_SCRIPT: return std::make_shared(info, type); diff --git a/xbmc/addons/AddonDatabase.cpp b/xbmc/addons/AddonDatabase.cpp index 9b0d3ff9f51f5..ffad7b1f1702a 100644 --- a/xbmc/addons/AddonDatabase.cpp +++ b/xbmc/addons/AddonDatabase.cpp @@ -46,6 +46,8 @@ std::string CAddonDatabaseSerializer::SerializeMetadata(const CAddonInfo& addon) for (const auto& item : addon.Screenshots()) variant["screenshots"].push_back(item); + variant["language"] = addon.Type(addon.MainType())->LanguageName(); + variant["extensions"] = CVariant(CVariant::VariantTypeArray); variant["extensions"].push_back(SerializeExtensions(*addon.Type(addon.MainType()))); @@ -135,9 +137,10 @@ void CAddonDatabaseSerializer::DeserializeMetadata(const std::string& document, screenshots.push_back(it->asString()); builder.SetScreenshots(std::move(screenshots)); - CAddonType addonType; + CAddonType addonType(ADDON_UNKNOWN, AddonLanguage::Unknown); DeserializeExtensions(variant["extensions"][0], addonType); - addonType.m_type = CAddonInfo::TranslateType(addonType.m_point); + addonType.SetType(CAddonInfo::TranslateType(addonType.m_point)); + addonType.SetLanguage(variant["language"].asString()); builder.SetExtensions(std::move(addonType)); { diff --git a/xbmc/addons/AddonProvider.h b/xbmc/addons/AddonProvider.h index 2a1e7af3fb79e..08130f94b9039 100644 --- a/xbmc/addons/AddonProvider.h +++ b/xbmc/addons/AddonProvider.h @@ -8,7 +8,7 @@ #pragma once -#include "addons/kodi-dev-kit/include/kodi/AddonBase.h" +#include "addons/kodi-dev-kit/include/kodi/c-api/addon_base.h" #include diff --git a/xbmc/addons/AddonStatusHandler.h b/xbmc/addons/AddonStatusHandler.h index 43f396561d318..d30310b33db7d 100644 --- a/xbmc/addons/AddonStatusHandler.h +++ b/xbmc/addons/AddonStatusHandler.h @@ -9,7 +9,7 @@ #pragma once #include "IAddon.h" -#include "addons/kodi-dev-kit/include/kodi/AddonBase.h" +#include "addons/kodi-dev-kit/include/kodi/c-api/addon_base.h" #include "threads/CriticalSection.h" #include "threads/Thread.h" diff --git a/xbmc/addons/AudioDecoder.cpp b/xbmc/addons/AudioDecoder.cpp index c0b2b516872c3..e2428439a056d 100644 --- a/xbmc/addons/AudioDecoder.cpp +++ b/xbmc/addons/AudioDecoder.cpp @@ -7,7 +7,13 @@ #include "AudioDecoder.h" -#include "addons/interfaces/AudioEngine.h" +// Devkit API interface +#include "interface/api/audio_engine.h" + +// Kodi +#include "FileItem.h" +#include "ServiceBroker.h" +#include "addons/AddonManager.h" #include "cores/AudioEngine/Utils/AEUtil.h" #include "filesystem/File.h" #include "music/tags/MusicInfoTag.h" @@ -18,53 +24,38 @@ using namespace ADDON; using namespace KODI::ADDONS; +using namespace KODI::ADDONS::INTERFACE; CAudioDecoder::CAudioDecoder(const AddonInfoPtr& addonInfo) - : IAddonInstanceHandler(ADDON_INSTANCE_AUDIODECODER, addonInfo) + : IInstanceHandler(this, ADDON_INSTANCE_AUDIODECODER, addonInfo) { m_CodecName = addonInfo->Type(ADDON_AUDIODECODER)->GetValue("@name").asString(); m_strExt = m_CodecName + KODI_ADDON_AUDIODECODER_TRACK_EXT; m_hasTags = addonInfo->Type(ADDON_AUDIODECODER)->GetValue("@tags").asBoolean(); - - // Create all interface parts independent to make API changes easier if - // something is added - m_ifc.audiodecoder = new AddonInstance_AudioDecoder; - m_ifc.audiodecoder->toAddon = new KodiToAddonFuncTable_AudioDecoder(); - m_ifc.audiodecoder->toKodi = new AddonToKodiFuncTable_AudioDecoder(); - m_ifc.audiodecoder->toKodi->kodiInstance = this; } CAudioDecoder::~CAudioDecoder() { DestroyInstance(); - - delete m_ifc.audiodecoder->toKodi; - delete m_ifc.audiodecoder->toAddon; - delete m_ifc.audiodecoder; } bool CAudioDecoder::CreateDecoder() { - if (CreateInstance() != ADDON_STATUS_OK) - return false; - - return true; + return CreateInstance() == ADDON_STATUS_OK; } bool CAudioDecoder::SupportsFile(const std::string& filename) { // Create in case not available, possible as this done by IAddonSupportCheck - if ((!m_ifc.hdl && !CreateDecoder()) || !m_ifc.audiodecoder->toAddon->supports_file) + if ((!m_instance && !CreateDecoder())) return false; - return m_ifc.audiodecoder->toAddon->supports_file(m_ifc.hdl, filename.c_str()); + const auto ifc = m_ifc->kodi_addoninstance_audiodecoder_h; + return ifc->kodi_addon_audiodecoder_supports_file_v1(m_instance, filename.c_str()); } bool CAudioDecoder::Init(const CFileItem& file, unsigned int filecache) { - if (!m_ifc.audiodecoder->toAddon->init) - return false; - /// for replaygain /// @todo About audio decoder in most cases Kodi's one not work, add fallback /// to use addon if this fails. Need API change about addons music info tag! @@ -76,9 +67,10 @@ bool CAudioDecoder::Init(const CFileItem& file, unsigned int filecache) AudioEngineDataFormat addonFormat = AUDIOENGINE_FMT_INVALID; AudioEngineChannel channelList[AUDIOENGINE_CH_MAX] = {AUDIOENGINE_CH_NULL}; - bool ret = m_ifc.audiodecoder->toAddon->init(m_ifc.hdl, file.GetDynPath().c_str(), filecache, - &channels, &sampleRate, &m_bitsPerSample, - &m_TotalTime, &m_bitRate, &addonFormat, channelList); + const auto ifc = m_ifc->kodi_addoninstance_audiodecoder_h; + bool ret = ifc->kodi_addon_audiodecoder_init_v1( + m_instance, file.GetDynPath().c_str(), filecache, &channels, &sampleRate, &m_bitsPerSample, + &m_TotalTime, &m_bitRate, &addonFormat, channelList); if (ret) { if (channels <= 0 || sampleRate <= 0 || addonFormat == AUDIOENGINE_FMT_INVALID) @@ -89,7 +81,7 @@ bool CAudioDecoder::Init(const CFileItem& file, unsigned int filecache) return false; } - m_format.m_dataFormat = Interface_AudioEngine::TranslateAEFormatToKodi(addonFormat); + m_format.m_dataFormat = TranslateAEFormatToKodi(addonFormat); m_format.m_sampleRate = sampleRate; if (channelList[0] != AUDIOENGINE_CH_NULL) { @@ -98,7 +90,7 @@ bool CAudioDecoder::Init(const CFileItem& file, unsigned int filecache) { if (channel == AUDIOENGINE_CH_NULL) break; - layout += Interface_AudioEngine::TranslateAEChannelToKodi(channel); + layout += TranslateAEChannelToKodi(channel); } m_format.m_channelLayout = layout; @@ -112,18 +104,14 @@ bool CAudioDecoder::Init(const CFileItem& file, unsigned int filecache) int CAudioDecoder::ReadPCM(uint8_t* buffer, size_t size, size_t* actualsize) { - if (!m_ifc.audiodecoder->toAddon->read_pcm) - return 0; - - return m_ifc.audiodecoder->toAddon->read_pcm(m_ifc.hdl, buffer, size, actualsize); + const auto ifc = m_ifc->kodi_addoninstance_audiodecoder_h; + return ifc->kodi_addon_audiodecoder_read_pcm_v1(m_instance, buffer, size, actualsize); } bool CAudioDecoder::Seek(int64_t time) { - if (!m_ifc.audiodecoder->toAddon->seek) - return false; - - m_ifc.audiodecoder->toAddon->seek(m_ifc.hdl, time); + const auto ifc = m_ifc->kodi_addoninstance_audiodecoder_h; + ifc->kodi_addon_audiodecoder_seek_v1(m_instance, time); return true; } @@ -131,11 +119,9 @@ bool CAudioDecoder::Load(const std::string& fileName, MUSIC_INFO::CMusicInfoTag& tag, EmbeddedArt* art) { - if (!m_ifc.audiodecoder->toAddon->read_tag) - return false; - KODI_ADDON_AUDIODECODER_INFO_TAG ifcTag = {}; - bool ret = m_ifc.audiodecoder->toAddon->read_tag(m_ifc.hdl, fileName.c_str(), &ifcTag); + const auto ifc = m_ifc->kodi_addoninstance_audiodecoder_h; + bool ret = ifc->kodi_addon_audiodecoder_read_tag_v1(m_instance, fileName.c_str(), &ifcTag); if (ret) { if (ifcTag.title) @@ -234,11 +220,8 @@ bool CAudioDecoder::Load(const std::string& fileName, int CAudioDecoder::GetTrackCount(const std::string& strPath) { - if (!m_ifc.audiodecoder->toAddon->track_count) - return 0; - - int result = m_ifc.audiodecoder->toAddon->track_count(m_ifc.hdl, strPath.c_str()); - + const auto ifc = m_ifc->kodi_addoninstance_audiodecoder_h; + int result = ifc->kodi_addon_audiodecoder_track_count_v1(m_instance, strPath.c_str()); if (result > 1) { if (m_hasTags) diff --git a/xbmc/addons/AudioDecoder.h b/xbmc/addons/AudioDecoder.h index 7e2424e0d6d74..ab04e9105cc73 100644 --- a/xbmc/addons/AudioDecoder.h +++ b/xbmc/addons/AudioDecoder.h @@ -7,12 +7,14 @@ #pragma once +// Devkit API interface +#include "addons/AddonEvents.h" #include "addons/IAddonSupportCheck.h" #include "addons/IAddonSupportList.h" -#include "addons/binary-addons/AddonInstanceHandler.h" -#include "addons/kodi-dev-kit/include/kodi/addon-instance/AudioDecoder.h" +#include "addons/interface/InstanceHandler.h" #include "cores/paplayer/ICodec.h" #include "filesystem/MusicFileDirectory.h" +#include "interface/api/addon-instance/audiodecoder.h" #include "music/tags/ImusicInfoTagLoader.h" namespace KODI @@ -20,8 +22,8 @@ namespace KODI namespace ADDONS { -class CAudioDecoder : public ADDON::IAddonInstanceHandler, - public IAddonSupportCheck, +class CAudioDecoder : public KODI::ADDONS::INTERFACE::IInstanceHandler, + public KODI::ADDONS::IAddonSupportCheck, public ICodec, public MUSIC_INFO::IMusicInfoTagLoader, public XFILE::CMusicFileDirectory diff --git a/xbmc/addons/BinaryAddonCache.cpp b/xbmc/addons/BinaryAddonCache.cpp deleted file mode 100644 index 52acf3df8a490..0000000000000 --- a/xbmc/addons/BinaryAddonCache.cpp +++ /dev/null @@ -1,131 +0,0 @@ -/* - * Copyright (C) 2016-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "BinaryAddonCache.h" - -#include "AddonManager.h" -#include "ServiceBroker.h" - -#include - -namespace ADDON -{ - -const std::vector ADDONS_TO_CACHE = {ADDON_GAMEDLL}; - -CBinaryAddonCache::~CBinaryAddonCache() -{ - Deinit(); -} - -void CBinaryAddonCache::Init() -{ - CServiceBroker::GetAddonMgr().Events().Subscribe(this, &CBinaryAddonCache::OnEvent); - Update(); -} - -void CBinaryAddonCache::Deinit() -{ - CServiceBroker::GetAddonMgr().Events().Unsubscribe(this); -} - -void CBinaryAddonCache::GetAddons(VECADDONS& addons, const TYPE& type) -{ - VECADDONS myAddons; - GetInstalledAddons(myAddons, type); - - for (auto &addon : myAddons) - { - if (!CServiceBroker::GetAddonMgr().IsAddonDisabled(addon->ID())) - addons.emplace_back(std::move(addon)); - } -} - -void CBinaryAddonCache::GetDisabledAddons(VECADDONS& addons, const TYPE& type) -{ - VECADDONS myAddons; - GetInstalledAddons(myAddons, type); - - for (auto &addon : myAddons) - { - if (CServiceBroker::GetAddonMgr().IsAddonDisabled(addon->ID())) - addons.emplace_back(std::move(addon)); - } -} - -void CBinaryAddonCache::GetInstalledAddons(VECADDONS& addons, const TYPE& type) -{ - std::unique_lock lock(m_critSection); - auto it = m_addons.find(type); - if (it != m_addons.end()) - addons = it->second; -} - -AddonPtr CBinaryAddonCache::GetAddonInstance(const std::string& strId, TYPE type) -{ - AddonPtr addon; - - std::unique_lock lock(m_critSection); - - auto it = m_addons.find(type); - if (it != m_addons.end()) - { - VECADDONS& addons = it->second; - auto itAddon = std::find_if(addons.begin(), addons.end(), - [&strId](const AddonPtr& addon) - { - return addon->ID() == strId; - }); - - if (itAddon != addons.end()) - addon = *itAddon; - } - - return addon; -} - -void CBinaryAddonCache::OnEvent(const AddonEvent& event) -{ - if (typeid(event) == typeid(AddonEvents::Enabled) || - typeid(event) == typeid(AddonEvents::Disabled) || - typeid(event) == typeid(AddonEvents::ReInstalled)) - { - for (auto &type : ADDONS_TO_CACHE) - { - if (CServiceBroker::GetAddonMgr().HasType(event.addonId, type)) - { - Update(); - break; - } - } - } - else if (typeid(event) == typeid(AddonEvents::UnInstalled)) - { - Update(); - } -} - -void CBinaryAddonCache::Update() -{ - using AddonMap = std::multimap; - AddonMap addonmap; - - for (auto &addonType : ADDONS_TO_CACHE) - { - VECADDONS addons; - CServiceBroker::GetAddonMgr().GetInstalledAddons(addons, addonType); - addonmap.insert(AddonMap::value_type(addonType, addons)); - } - - { - std::unique_lock lock(m_critSection); - m_addons = std::move(addonmap); - } -} - -} diff --git a/xbmc/addons/BinaryAddonCache.h b/xbmc/addons/BinaryAddonCache.h deleted file mode 100644 index 344cc5f05a35a..0000000000000 --- a/xbmc/addons/BinaryAddonCache.h +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (C) 2016-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "Addon.h" -#include "AddonEvents.h" -#include "threads/CriticalSection.h" - -#include -#include - -namespace ADDON { - -class CBinaryAddonCache -{ -public: - virtual ~CBinaryAddonCache(); - void Init(); - void Deinit(); - void GetAddons(VECADDONS& addons, const TYPE& type); - void GetDisabledAddons(VECADDONS& addons, const TYPE& type); - void GetInstalledAddons(VECADDONS& addons, const TYPE& type); - AddonPtr GetAddonInstance(const std::string& strId, TYPE type); - -protected: - void Update(); - void OnEvent(const AddonEvent& event); - - CCriticalSection m_critSection; - std::multimap m_addons; -}; - -} diff --git a/xbmc/addons/CMakeLists.txt b/xbmc/addons/CMakeLists.txt index 0f24a6cea3733..8181e71fb5cbf 100644 --- a/xbmc/addons/CMakeLists.txt +++ b/xbmc/addons/CMakeLists.txt @@ -1,6 +1,5 @@ set(SOURCES Addon.cpp AddonBuilder.cpp - BinaryAddonCache.cpp AddonDatabase.cpp AddonInstaller.cpp AddonManager.cpp @@ -35,7 +34,6 @@ set(HEADERS Addon.h AddonBuilder.h AddonEvents.h AddonRepoInfo.h - BinaryAddonCache.h AddonDatabase.h AddonInstaller.h AddonManager.h diff --git a/xbmc/addons/IAddon.h b/xbmc/addons/IAddon.h index 43a0f7b8ea7de..d25e6a1b208b5 100644 --- a/xbmc/addons/IAddon.h +++ b/xbmc/addons/IAddon.h @@ -66,10 +66,12 @@ class IAddon : public std::enable_shared_from_this { public: virtual ~IAddon() = default; + virtual AddonInfoPtr GetAddonInfo() = 0; virtual TYPE MainType() const = 0; virtual TYPE Type() const = 0; virtual bool HasType(TYPE type) const = 0; virtual bool HasMainType(TYPE type) const = 0; + virtual const CAddonType* Type(TYPE type) const = 0; virtual std::string ID() const = 0; virtual std::string Name() const = 0; virtual bool IsInUse() const = 0; diff --git a/xbmc/addons/ImageDecoder.cpp b/xbmc/addons/ImageDecoder.cpp index 2db12d66944a4..94ae9ae7cdd8f 100644 --- a/xbmc/addons/ImageDecoder.cpp +++ b/xbmc/addons/ImageDecoder.cpp @@ -7,6 +7,10 @@ #include "ImageDecoder.h" +// Devkit API interface +#include "interface/api/addon-instance/imagedecoder.h" + +// Kodi #include "guilib/TextureFormats.h" #include "pictures/PictureInfoTag.h" @@ -25,14 +29,8 @@ constexpr std::array, 4> KodiToA } /* namespace */ CImageDecoder::CImageDecoder(const AddonInfoPtr& addonInfo, const std::string& mimetype) - : IAddonInstanceHandler(ADDON_INSTANCE_IMAGEDECODER, addonInfo), m_mimetype(mimetype) + : IInstanceHandler(this, ADDON_INSTANCE_IMAGEDECODER, addonInfo), m_mimetype(mimetype) { - // Create all interface parts independent to make API changes easier if - // something is added - m_ifc.imagedecoder = new AddonInstance_ImageDecoder; - m_ifc.imagedecoder->toAddon = new KodiToAddonFuncTable_ImageDecoder(); - m_ifc.imagedecoder->toKodi = new AddonToKodiFuncTable_ImageDecoder(); - if (CreateInstance() != ADDON_STATUS_OK) return; @@ -42,28 +40,26 @@ CImageDecoder::CImageDecoder(const AddonInfoPtr& addonInfo, const std::string& m CImageDecoder::~CImageDecoder() { DestroyInstance(); - - delete m_ifc.imagedecoder->toKodi; - delete m_ifc.imagedecoder->toAddon; - delete m_ifc.imagedecoder; } bool CImageDecoder::SupportsFile(const std::string& filename) { // Create in case not available, possible as this done by IAddonSupportCheck - if (!m_created || !m_ifc.imagedecoder->toAddon->supports_file) + if (!m_created) return false; - return m_ifc.imagedecoder->toAddon->supports_file(m_ifc.hdl, filename.c_str()); + return m_ifc->kodi_addoninstance_imagedecoder_h->kodi_addon_imagedecoder_supports_file_v1( + m_instance, filename.c_str()); } bool CImageDecoder::LoadInfoTag(const std::string& fileName, CPictureInfoTag* tag) { - if (!m_created || !m_ifc.imagedecoder->toAddon->read_tag || !tag) + if (!m_created || !tag) return false; KODI_ADDON_IMAGEDECODER_INFO_TAG ifcTag = {}; - bool ret = m_ifc.imagedecoder->toAddon->read_tag(m_ifc.hdl, fileName.c_str(), &ifcTag); + bool ret = m_ifc->kodi_addoninstance_imagedecoder_h->kodi_addon_imagedecoder_read_tag_v1( + m_instance, fileName.c_str(), &ifcTag); if (ret) { /*! @@ -178,13 +174,14 @@ bool CImageDecoder::LoadImageFromMemory(unsigned char* buffer, unsigned int width, unsigned int height) { - if (!m_created || !m_ifc.imagedecoder->toAddon->load_image_from_memory) + if (!m_created) return false; m_width = width; m_height = height; - return m_ifc.imagedecoder->toAddon->load_image_from_memory(m_ifc.hdl, m_mimetype.c_str(), buffer, - bufSize, &m_width, &m_height); + return m_ifc->kodi_addoninstance_imagedecoder_h + ->kodi_addon_imagedecoder_load_image_from_memory_v1(m_instance, m_mimetype.c_str(), buffer, + bufSize, &m_width, &m_height); } bool CImageDecoder::Decode(unsigned char* const pixels, @@ -193,7 +190,7 @@ bool CImageDecoder::Decode(unsigned char* const pixels, unsigned int pitch, unsigned int format) { - if (!m_created || !m_ifc.imagedecoder->toAddon->decode) + if (!m_created) return false; const auto it = std::find_if(KodiToAddonFormat.begin(), KodiToAddonFormat.end(), @@ -203,8 +200,8 @@ bool CImageDecoder::Decode(unsigned char* const pixels, const ADDON_IMG_FMT addonFmt = std::get<1>(*it); const size_t size = width * height * std::get<2>(*it); - const bool result = - m_ifc.imagedecoder->toAddon->decode(m_ifc.hdl, pixels, size, width, height, pitch, addonFmt); + const bool result = m_ifc->kodi_addoninstance_imagedecoder_h->kodi_addon_imagedecoder_decode_v1( + m_instance, pixels, size, width, height, pitch, addonFmt); m_width = width; m_height = height; diff --git a/xbmc/addons/ImageDecoder.h b/xbmc/addons/ImageDecoder.h index 038c601e62838..adc05cd358aa4 100644 --- a/xbmc/addons/ImageDecoder.h +++ b/xbmc/addons/ImageDecoder.h @@ -8,9 +8,8 @@ #pragma once #include "addons/IAddonSupportCheck.h" -#include "addons/binary-addons/AddonInstanceHandler.h" -#include "addons/kodi-dev-kit/include/kodi/addon-instance/ImageDecoder.h" #include "guilib/iimage.h" +#include "interface/InstanceHandler.h" class CPictureInfoTag; @@ -19,7 +18,7 @@ namespace KODI namespace ADDONS { -class CImageDecoder : public ADDON::IAddonInstanceHandler, +class CImageDecoder : public KODI::ADDONS::INTERFACE::IInstanceHandler, public KODI::ADDONS::IAddonSupportCheck, public IImage { diff --git a/xbmc/addons/ScreenSaver.cpp b/xbmc/addons/ScreenSaver.cpp index 06e1afdd233f0..79b14f84e109b 100644 --- a/xbmc/addons/ScreenSaver.cpp +++ b/xbmc/addons/ScreenSaver.cpp @@ -8,6 +8,7 @@ #include "ScreenSaver.h" +#include "addons/interface/api/addon-instance/screensaver.h" #include "filesystem/SpecialProtocol.h" #include "utils/log.h" #include "windowing/GraphicContext.h" @@ -16,24 +17,9 @@ using namespace ADDON; using namespace KODI::ADDONS; -namespace -{ -void get_properties(const KODI_HANDLE hdl, struct KODI_ADDON_SCREENSAVER_PROPS* props) -{ - if (hdl) - static_cast(hdl)->GetProperties(props); -} -} // namespace - CScreenSaver::CScreenSaver(const AddonInfoPtr& addonInfo) - : IAddonInstanceHandler(ADDON_INSTANCE_SCREENSAVER, addonInfo) + : IInstanceHandler(this, ADDON_INSTANCE_SCREENSAVER, addonInfo) { - m_ifc.screensaver = new AddonInstance_Screensaver; - m_ifc.screensaver->toAddon = new KodiToAddonFuncTable_Screensaver(); - m_ifc.screensaver->toKodi = new AddonToKodiFuncTable_Screensaver(); - m_ifc.screensaver->toKodi->get_properties = get_properties; - - /* Open the class "kodi::addon::CInstanceScreensaver" on add-on side */ if (CreateInstance() != ADDON_STATUS_OK) CLog::Log(LOGFATAL, "Screensaver: failed to create instance for '{}' and not usable!", ID()); } @@ -42,29 +28,39 @@ CScreenSaver::~CScreenSaver() { /* Destroy the class "kodi::addon::CInstanceScreensaver" on add-on side */ DestroyInstance(); - - delete m_ifc.screensaver->toAddon; - delete m_ifc.screensaver->toKodi; - delete m_ifc.screensaver; } bool CScreenSaver::Start() { - if (m_ifc.screensaver->toAddon->start) - return m_ifc.screensaver->toAddon->start(m_ifc.hdl); - return false; + const auto ifc = m_ifc->kodi_addoninstance_screensaver_h; + return ifc->kodi_addon_screensaver_start_v1(this, m_instance); } void CScreenSaver::Stop() { - if (m_ifc.screensaver->toAddon->stop) - m_ifc.screensaver->toAddon->stop(m_ifc.hdl); + const auto ifc = m_ifc->kodi_addoninstance_screensaver_h; + return ifc->kodi_addon_screensaver_stop_v1(this, m_instance); } void CScreenSaver::Render() { - if (m_ifc.screensaver->toAddon->render) - m_ifc.screensaver->toAddon->render(m_ifc.hdl); + const auto ifc = m_ifc->kodi_addoninstance_screensaver_h; + return ifc->kodi_addon_screensaver_render_v1(this, m_instance); +} + +bool CScreenSaver::GetOffscreenRenderInfos(int& x, int& y, int& width, int& height, ADDON_HARDWARE_CONTEXT& context) +{ + const auto winSystem = CServiceBroker::GetWinSystem(); + if (!winSystem) + return false; + + x = 0; + y = 0; + context = winSystem->GetHWContext(); + width = winSystem->GetGfxContext().GetWidth(); + height = winSystem->GetGfxContext().GetHeight(); + + return true; } void CScreenSaver::GetProperties(struct KODI_ADDON_SCREENSAVER_PROPS* props) diff --git a/xbmc/addons/ScreenSaver.h b/xbmc/addons/ScreenSaver.h index 616d3e82c714a..770646f65beaa 100644 --- a/xbmc/addons/ScreenSaver.h +++ b/xbmc/addons/ScreenSaver.h @@ -8,15 +8,17 @@ #pragma once -#include "addons/binary-addons/AddonInstanceHandler.h" -#include "addons/kodi-dev-kit/include/kodi/addon-instance/Screensaver.h" +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/screensaver.h" +#include "interface/InstanceHandler.h" +#include "interface/IOffscreenRenderProcess.h" namespace KODI { namespace ADDONS { -class CScreenSaver : public ADDON::IAddonInstanceHandler +class CScreenSaver : public KODI::ADDONS::INTERFACE::IInstanceHandler, + public KODI::ADDONS::INTERFACE::IOffscreenRenderProcess { public: explicit CScreenSaver(const ADDON::AddonInfoPtr& addonInfo); @@ -28,6 +30,10 @@ class CScreenSaver : public ADDON::IAddonInstanceHandler // Addon callback functions void GetProperties(struct KODI_ADDON_SCREENSAVER_PROPS* props); + /*---AUTO_GEN_PARSE---*/ + +protected: + bool GetOffscreenRenderInfos(int& x, int& y, int& width, int& height, ADDON_HARDWARE_CONTEXT& context) override; }; } /* namespace ADDONS */ diff --git a/xbmc/addons/Service.cpp b/xbmc/addons/Service.cpp index c8a825288a87b..8d32e73dadec5 100644 --- a/xbmc/addons/Service.cpp +++ b/xbmc/addons/Service.cpp @@ -8,13 +8,15 @@ #include "Service.h" #include "AddonManager.h" +#include "ServiceBroker.h" +#include "interface/Controller.h" +#include "interface/RunningProcess.h" #include "interfaces/generic/ScriptInvocationManager.h" #include "utils/StringUtils.h" #include "utils/log.h" #include - namespace ADDON { @@ -73,12 +75,36 @@ void CServiceAddonManager::Start(const std::string& addonId) void CServiceAddonManager::Start(const AddonPtr& addon) { std::unique_lock lock(m_criticalSection); + if (m_services.find(addon->ID()) != m_services.end()) { CLog::Log(LOGDEBUG, "CServiceAddonManager: {} already started.", addon->ID()); return; } + if (CServiceBroker::GetAddonIfcCtrl().AddonLanguageSupported(addon)) + { + std::vector argv; + std::shared_ptr process; + bool ret = CServiceBroker::GetAddonIfcCtrl().LaunchAddon(addon, argv, false, process); + if (!ret) + { + CLog::Log(LOGERROR, "CServiceAddonManager: {} failed to start", addon->ID()); + return; + } + + m_services[addon->ID()] = process; + } + + //! @brief Old way. Still supported until new is main + //! @todo Remove after new is final and support whole python interface + /*!@{*/ + if (m_servicesPythonOld.find(addon->ID()) != m_servicesPythonOld.end()) + { + CLog::Log(LOGDEBUG, "CServiceAddonManager: {} already started.", addon->ID()); + return; + } + if (StringUtils::EndsWith(addon->LibPath(), ".py")) { CLog::Log(LOGDEBUG, "CServiceAddonManager: starting {}", addon->ID()); @@ -88,8 +114,9 @@ void CServiceAddonManager::Start(const AddonPtr& addon) CLog::Log(LOGERROR, "CServiceAddonManager: {} failed to start", addon->ID()); return; } - m_services[addon->ID()] = handle; + m_servicesPythonOld[addon->ID()] = handle; } + /*!@}*/ } void CServiceAddonManager::Stop() @@ -99,9 +126,19 @@ void CServiceAddonManager::Stop() std::unique_lock lock(m_criticalSection); for (const auto& service : m_services) { - Stop(service); + Stop(service.second); } m_services.clear(); + + //! @brief Old way. Still supported until new is main + //! @todo Remove after new is final and support whole python interface + /*!@{*/ + for (const auto& service : m_servicesPythonOld) + { + Stop(service); + } + m_servicesPythonOld.clear(); + /*!@}*/ } void CServiceAddonManager::Stop(const std::string& addonId) @@ -110,11 +147,36 @@ void CServiceAddonManager::Stop(const std::string& addonId) auto it = m_services.find(addonId); if (it != m_services.end()) { - Stop(*it); + Stop(it->second); m_services.erase(it); } + + //! @brief Old way. Still supported until new is main + //! @todo Remove after new is final and support whole python interface + /*!@{*/ + auto itOld = m_servicesPythonOld.find(addonId); + if (itOld != m_servicesPythonOld.end()) + { + Stop(*itOld); + m_servicesPythonOld.erase(itOld); + } + /*!@}*/ +} + +void CServiceAddonManager::Stop( + const std::shared_ptr& service) +{ + CLog::Log(LOGDEBUG, "CServiceAddonManager: stopping {}.", service->GetAddon()->ID()); + if (!service->Kill()) + { + CLog::Log(LOGINFO, "CServiceAddonManager: failed to stop {} (may have ended)", + service->GetAddon()->ID()); + } } +//! @brief Old way. Still supported until new is main +//! @todo Remove after new is final and support whole python interface +/*!@{*/ void CServiceAddonManager::Stop(const std::map::value_type& service) { CLog::Log(LOGDEBUG, "CServiceAddonManager: stopping {}.", service.first); @@ -123,4 +185,5 @@ void CServiceAddonManager::Stop(const std::map::value_type& se CLog::Log(LOGINFO, "CServiceAddonManager: failed to stop {} (may have ended)", service.first); } } +/*!@}*/ } diff --git a/xbmc/addons/Service.h b/xbmc/addons/Service.h index c997ef01b3b37..02bfecd36abdf 100644 --- a/xbmc/addons/Service.h +++ b/xbmc/addons/Service.h @@ -12,6 +12,19 @@ #include "AddonEvents.h" #include "threads/CriticalSection.h" +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CRunningProcess; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + namespace ADDON { class CService: public CAddon @@ -50,11 +63,13 @@ namespace ADDON private: void OnEvent(const AddonEvent& event); + void Stop(const std::shared_ptr& service); void Stop(const std::map::value_type& service); CAddonMgr& m_addonMgr; CCriticalSection m_criticalSection; + std::map> m_services; /** add-on id -> script id */ - std::map m_services; + std::map m_servicesPythonOld; }; } diff --git a/xbmc/addons/Skin.cpp b/xbmc/addons/Skin.cpp index 0e1b876dff869..ff26c9970d736 100644 --- a/xbmc/addons/Skin.cpp +++ b/xbmc/addons/Skin.cpp @@ -328,6 +328,7 @@ bool CSkinInfo::LoadStartupWindows(const AddonInfoPtr& addonInfo) m_startupWindows.emplace_back(WINDOW_PICTURES, "1"); m_startupWindows.emplace_back(WINDOW_MUSIC_NAV, "2"); m_startupWindows.emplace_back(WINDOW_VIDEO_NAV, "3"); + m_startupWindows.emplace_back(WINDOW_WEB_BROWSER, "911"); m_startupWindows.emplace_back(WINDOW_FILES, "7"); m_startupWindows.emplace_back(WINDOW_SETTINGS_MENU, "5"); m_startupWindows.emplace_back(WINDOW_WEATHER, "8"); diff --git a/xbmc/addons/VFSEntry.cpp b/xbmc/addons/VFSEntry.cpp index a5d46e78882be..9b66fa1a55ace 100644 --- a/xbmc/addons/VFSEntry.cpp +++ b/xbmc/addons/VFSEntry.cpp @@ -10,7 +10,7 @@ #include "ServiceBroker.h" #include "URL.h" #include "addons/AddonManager.h" -#include "addons/interfaces/Filesystem.h" +#include "addons/interface/api/addon-instance/vfs.h" #include "network/ZeroconfBrowser.h" #include "utils/StringUtils.h" #include "utils/log.h" @@ -42,6 +42,8 @@ #endif #endif +using namespace KODI::ADDONS::INTERFACE; + namespace ADDON { @@ -62,7 +64,7 @@ void CVFSAddonCache::Init() for (const auto& addonInfo : addonInfos) { VFSEntryPtr vfs = std::make_shared(addonInfo); - vfs->Addon()->RegisterInformer(this); + // vfs->Addon()->RegisterInformer(this); m_addonsInstances.emplace_back(vfs); @@ -149,7 +151,7 @@ void CVFSAddonCache::Update(const std::string& id) if (itAddon != m_addonsInstances.end()) { - (*itAddon)->Addon()->RegisterInformer(nullptr); + // (*itAddon)->Addon()->RegisterInformer(nullptr); m_addonsInstances.erase(itAddon); } } @@ -197,7 +199,8 @@ class CVFSURLWrapper url.protocol = m_strings[9].c_str(); } - VFSURL url; + KODI_ADDON_VFS_URL url; + protected: std::vector m_strings; }; @@ -216,7 +219,7 @@ CVFSEntry::ProtocolInfo::ProtocolInfo(const AddonInfoPtr& addonInfo) } CVFSEntry::CVFSEntry(const AddonInfoPtr& addonInfo) - : IAddonInstanceHandler(ADDON_INSTANCE_VFS, addonInfo), + : IInstanceHandler(this, ADDON_INSTANCE_VFS, addonInfo), m_protocols(addonInfo->Type(ADDON_VFS)->GetValue("@protocols").asString()), m_extensions(addonInfo->Type(ADDON_VFS)->GetValue("@extensions").asString()), m_zeroconf(addonInfo->Type(ADDON_VFS)->GetValue("@zeroconf").asString()), @@ -228,13 +231,6 @@ CVFSEntry::CVFSEntry(const AddonInfoPtr& addonInfo) if (!addonInfo->Type(ADDON_VFS)->GetValue("@supportDialog").asBoolean()) m_protocolInfo.type.clear(); - // Create "C" interface structures, used as own parts to prevent API problems on update - m_ifc.vfs = new AddonInstance_VFSEntry; - m_ifc.vfs->props = new AddonProps_VFSEntry(); - m_ifc.vfs->toAddon = new KodiToAddonFuncTable_VFSEntry(); - m_ifc.vfs->toKodi = new AddonToKodiFuncTable_VFSEntry(); - - m_ifc.vfs->toKodi->kodiInstance = this; if (CreateInstance() != ADDON_STATUS_OK) CLog::Log(LOGFATAL, "CVFSEntry - Couldn't create instance on add-on '{}'", addonInfo->Name()); } @@ -242,50 +238,33 @@ CVFSEntry::CVFSEntry(const AddonInfoPtr& addonInfo) CVFSEntry::~CVFSEntry() { DestroyInstance(); - - // Delete "C" interface structures - delete m_ifc.vfs->toAddon; - delete m_ifc.vfs->toKodi; - delete m_ifc.vfs->props; - delete m_ifc.vfs; } void* CVFSEntry::Open(const CURL& url) { - if (!m_ifc.vfs->toAddon->open) - return nullptr; - CVFSURLWrapper url2(url); - return m_ifc.vfs->toAddon->open(m_ifc.vfs, &url2.url); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_open_v1(m_instance, &url2.url); } void* CVFSEntry::OpenForWrite(const CURL& url, bool bOverWrite) { - if (!m_ifc.vfs->toAddon->open_for_write) - return nullptr; - CVFSURLWrapper url2(url); - return m_ifc.vfs->toAddon->open_for_write(m_ifc.vfs, &url2.url, bOverWrite); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_open_for_write_v1( + m_instance, &url2.url, bOverWrite); } bool CVFSEntry::Exists(const CURL& url) { - if (!m_ifc.vfs->toAddon->exists) - return false; - CVFSURLWrapper url2(url); - return m_ifc.vfs->toAddon->exists(m_ifc.vfs, &url2.url); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_exists_v1(m_instance, &url2.url); } int CVFSEntry::Stat(const CURL& url, struct __stat64* buffer) { - int ret = -1; - if (!m_ifc.vfs->toAddon->stat) - return ret; - CVFSURLWrapper url2(url); - STAT_STRUCTURE statBuffer = {}; - ret = m_ifc.vfs->toAddon->stat(m_ifc.vfs, &url2.url, &statBuffer); + VFS_STAT_STRUCTURE statBuffer = {}; + int ret = + m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_stat_v1(m_instance, &url2.url, &statBuffer); buffer->st_dev = statBuffer.deviceId; buffer->st_ino = statBuffer.fileSerialNumber; @@ -314,64 +293,45 @@ int CVFSEntry::Stat(const CURL& url, struct __stat64* buffer) ssize_t CVFSEntry::Read(void* ctx, void* lpBuf, size_t uiBufSize) { - if (!m_ifc.vfs->toAddon->read) - return 0; - - return m_ifc.vfs->toAddon->read(m_ifc.vfs, ctx, static_cast(lpBuf), uiBufSize); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_read_v1( + m_instance, ctx, static_cast(lpBuf), uiBufSize); } ssize_t CVFSEntry::Write(void* ctx, const void* lpBuf, size_t uiBufSize) { - if (!m_ifc.vfs->toAddon->write) - return 0; - - return m_ifc.vfs->toAddon->write(m_ifc.vfs, ctx, static_cast(lpBuf), uiBufSize); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_write_v1( + m_instance, ctx, static_cast(lpBuf), uiBufSize); } int64_t CVFSEntry::Seek(void* ctx, int64_t position, int whence) { - if (!m_ifc.vfs->toAddon->seek) - return 0; - - return m_ifc.vfs->toAddon->seek(m_ifc.vfs, ctx, position, whence); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_seek_v1(m_instance, ctx, position, + whence); } int CVFSEntry::Truncate(void* ctx, int64_t size) { - if (!m_ifc.vfs->toAddon->truncate) - return 0; - - return m_ifc.vfs->toAddon->truncate(m_ifc.vfs, ctx, size); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_truncate_v1(m_instance, ctx, size); } void CVFSEntry::Close(void* ctx) { - if (m_ifc.vfs->toAddon->close) - m_ifc.vfs->toAddon->close(m_ifc.vfs, ctx); + m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_close_v1(m_instance, ctx); } int64_t CVFSEntry::GetPosition(void* ctx) { - if (!m_ifc.vfs->toAddon->get_position) - return 0; - - return m_ifc.vfs->toAddon->get_position(m_ifc.vfs, ctx); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_get_position_v1(m_instance, ctx); } int CVFSEntry::GetChunkSize(void* ctx) { - if (!m_ifc.vfs->toAddon->get_chunk_size) - return 0; - - return m_ifc.vfs->toAddon->get_chunk_size(m_ifc.vfs, ctx); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_get_chunk_size_v1(m_instance, ctx); } int64_t CVFSEntry::GetLength(void* ctx) { - if (!m_ifc.vfs->toAddon->get_length) - return 0; - - return m_ifc.vfs->toAddon->get_length(m_ifc.vfs, ctx); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_get_length_v1(m_instance, ctx); } int CVFSEntry::IoControl(void* ctx, XFILE::EIoControl request, void* param) @@ -380,21 +340,22 @@ int CVFSEntry::IoControl(void* ctx, XFILE::EIoControl request, void* param) { case XFILE::EIoControl::IOCTRL_SEEK_POSSIBLE: { - if (!m_ifc.vfs->toAddon->io_control_get_seek_possible) - return -1; - return m_ifc.vfs->toAddon->io_control_get_seek_possible(m_ifc.vfs, ctx) ? 1 : 0; + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_io_control_get_seek_possible_v1( + m_instance, ctx) + ? 1 + : 0; } case XFILE::EIoControl::IOCTRL_CACHE_STATUS: { - if (!m_ifc.vfs->toAddon->io_control_get_cache_status) - return -1; - XFILE::SCacheStatus* kodiData = static_cast(param); if (!kodiData) return -1; - VFS_CACHE_STATUS_DATA status; - int ret = m_ifc.vfs->toAddon->io_control_get_cache_status(m_ifc.vfs, ctx, &status) ? 0 : -1; + VFS_CACHE_STATUS status; + int ret = m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_io_control_get_cache_status_v1( + m_instance, ctx, &status) + ? 0 + : -1; if (ret >= 0) { kodiData->forward = status.forward; @@ -406,19 +367,19 @@ int CVFSEntry::IoControl(void* ctx, XFILE::EIoControl request, void* param) } case XFILE::EIoControl::IOCTRL_CACHE_SETRATE: { - if (!m_ifc.vfs->toAddon->io_control_set_cache_rate) - return -1; - uint32_t& iParam = *static_cast(param); - return m_ifc.vfs->toAddon->io_control_set_cache_rate(m_ifc.vfs, ctx, iParam) ? 1 : 0; + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_io_control_set_cache_rate_v1( + m_instance, ctx, iParam) + ? 1 + : 0; } case XFILE::EIoControl::IOCTRL_SET_RETRY: { - if (!m_ifc.vfs->toAddon->io_control_set_retry) - return -1; - bool& bParam = *static_cast(param); - return m_ifc.vfs->toAddon->io_control_set_retry(m_ifc.vfs, ctx, bParam) ? 0 : -1; + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_file_io_control_set_retry_v1( + m_instance, ctx, bParam) + ? 0 + : -1; } // Not by addon supported io's @@ -433,64 +394,48 @@ int CVFSEntry::IoControl(void* ctx, XFILE::EIoControl request, void* param) bool CVFSEntry::Delete(const CURL& url) { - if (!m_ifc.vfs->toAddon->delete_it) - return false; - CVFSURLWrapper url2(url); - return m_ifc.vfs->toAddon->delete_it(m_ifc.vfs, &url2.url); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_delete_it_v1(m_instance, &url2.url); } bool CVFSEntry::Rename(const CURL& url, const CURL& url2) { - if (!m_ifc.vfs->toAddon->rename) - return false; - CVFSURLWrapper url3(url); CVFSURLWrapper url4(url2); - return m_ifc.vfs->toAddon->rename(m_ifc.vfs, &url3.url, &url4.url); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_rename_v1(m_instance, &url3.url, + &url4.url); } void CVFSEntry::ClearOutIdle() { - if (m_ifc.vfs->toAddon->clear_out_idle) - m_ifc.vfs->toAddon->clear_out_idle(m_ifc.vfs); + m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_clear_out_idle_v1(m_instance); } void CVFSEntry::DisconnectAll() { - if (m_ifc.vfs->toAddon->disconnect_all) - m_ifc.vfs->toAddon->disconnect_all(m_ifc.vfs); + m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_disconnect_all_v1(m_instance); } bool CVFSEntry::DirectoryExists(const CURL& url) { - if (!m_ifc.vfs->toAddon->directory_exists) - return false; - CVFSURLWrapper url2(url); - return m_ifc.vfs->toAddon->directory_exists(m_ifc.vfs, &url2.url); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_directory_exists_v1(m_instance, &url2.url); } bool CVFSEntry::RemoveDirectory(const CURL& url) { - if (!m_ifc.vfs->toAddon->remove_directory) - return false; - CVFSURLWrapper url2(url); - return m_ifc.vfs->toAddon->remove_directory(m_ifc.vfs, &url2.url); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_directory_remove_v1(m_instance, &url2.url); } bool CVFSEntry::CreateDirectory(const CURL& url) { - if (!m_ifc.vfs->toAddon->create_directory) - return false; - CVFSURLWrapper url2(url); - return m_ifc.vfs->toAddon->create_directory(m_ifc.vfs, &url2.url); + return m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_directory_create_v1(m_instance, &url2.url); } static void VFSDirEntriesToCFileItemList(int num_entries, - VFSDirEntry* entries, + VFS_DIR_ENTRY* entries, CFileItemList& items) { for (int i=0;itoAddon->get_directory || !m_ifc.vfs->toAddon->free_directory) - return false; - - VFSGetDirectoryCallbacks callbacks; - callbacks.ctx = ctx; - callbacks.get_keyboard_input = CVFSEntryIDirectoryWrapper::DoGetKeyboardInput; - callbacks.set_error_dialog = CVFSEntryIDirectoryWrapper::DoSetErrorDialog; - callbacks.require_authentication = CVFSEntryIDirectoryWrapper::DoRequireAuthentication; - - VFSDirEntry* entries = nullptr; - int num_entries = 0; + VFS_DIR_ENTRY* entries = nullptr; + size_t num_entries = 0; CVFSURLWrapper url2(url); - bool ret = - m_ifc.vfs->toAddon->get_directory(m_ifc.vfs, &url2.url, &entries, &num_entries, &callbacks); + bool ret = m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_directory_get_v1( + m_instance, &url2.url, &entries, &num_entries, ctx); if (ret) { VFSDirEntriesToCFileItemList(num_entries, entries, items); - m_ifc.vfs->toAddon->free_directory(m_ifc.vfs, entries, num_entries); + m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_directory_free_v1(entries, num_entries); } return ret; @@ -547,24 +482,24 @@ bool CVFSEntry::GetDirectory(const CURL& url, CFileItemList& items, bool CVFSEntry::ContainsFiles(const CURL& url, CFileItemList& items) { - if (!m_ifc.vfs->toAddon->contains_files || !m_ifc.vfs->toAddon->free_directory) - return false; - - VFSDirEntry* entries = nullptr; - int num_entries = 0; + VFS_DIR_ENTRY* entries = nullptr; + size_t num_entries = 0; CVFSURLWrapper url2(url); - char rootpath[ADDON_STANDARD_STRING_LENGTH]; + char* rootpath = nullptr; rootpath[0] = 0; - bool ret = - m_ifc.vfs->toAddon->contains_files(m_ifc.vfs, &url2.url, &entries, &num_entries, rootpath); + bool ret = m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_directory_contains_files_v1( + m_instance, &url2.url, &entries, &num_entries, &rootpath); if (!ret) return false; VFSDirEntriesToCFileItemList(num_entries, entries, items); - m_ifc.vfs->toAddon->free_directory(m_ifc.vfs, entries, num_entries); - if (strlen(rootpath)) + m_ifc->kodi_addoninstance_vfs_h->kodi_addon_vfs_directory_free_v1(entries, num_entries); + if (rootpath) + { items.SetPath(rootpath); + free(rootpath); + } return true; } @@ -706,10 +641,10 @@ bool CVFSEntryIDirectoryWrapper::GetDirectory(const CURL& url, return m_addon->GetDirectory(url, items, this); } -bool CVFSEntryIDirectoryWrapper::DoGetKeyboardInput(void* ctx, - const char* heading, - char** input, - bool hidden_input) +bool CVFSEntry::DoGetKeyboardInput(KODI_CTX_CB_HDL ctx, + const char* heading, + char** input, + bool hidden_input) { return static_cast(ctx)->GetKeyboardInput2(heading, input, hidden_input); } @@ -726,10 +661,11 @@ bool CVFSEntryIDirectoryWrapper::GetKeyboardInput2(const char* heading, return result; } -void CVFSEntryIDirectoryWrapper::DoSetErrorDialog(void* ctx, const char* heading, - const char* line1, - const char* line2, - const char* line3) +void CVFSEntry::DoSetErrorDialog(KODI_CTX_CB_HDL ctx, + const char* heading, + const char* line1, + const char* line2, + const char* line3) { static_cast(ctx)->SetErrorDialog2(heading, line1, line2, line3); @@ -750,8 +686,7 @@ void CVFSEntryIDirectoryWrapper::SetErrorDialog2(const char* heading, CVariant(std::string(line1)), l2, l3); } -void CVFSEntryIDirectoryWrapper::DoRequireAuthentication(void* ctx, - const char* url) +void CVFSEntry::DoRequireAuthentication(KODI_CTX_CB_HDL ctx, const char* url) { static_cast(ctx)->RequireAuthentication2(CURL(url)); } diff --git a/xbmc/addons/VFSEntry.h b/xbmc/addons/VFSEntry.h index e7ec899315256..c83e70161ed26 100644 --- a/xbmc/addons/VFSEntry.h +++ b/xbmc/addons/VFSEntry.h @@ -7,11 +7,13 @@ #pragma once -#include "addons/binary-addons/AddonInstanceHandler.h" -#include "addons/kodi-dev-kit/include/kodi/addon-instance/VFS.h" +#include "FileItem.h" +#include "addons/AddonEvents.h" +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/vfs.h" #include "filesystem/IDirectory.h" #include "filesystem/IFile.h" #include "filesystem/IFileDirectory.h" +#include "interface/InstanceHandler.h" #include @@ -21,7 +23,7 @@ namespace ADDON class CVFSEntry; typedef std::shared_ptr VFSEntryPtr; - class CVFSAddonCache : public CAddonDllInformer + class CVFSAddonCache //: public CAddonDllInformer { public: virtual ~CVFSAddonCache(); @@ -33,14 +35,14 @@ namespace ADDON protected: void Update(const std::string& id); void OnEvent(const AddonEvent& event); - bool IsInUse(const std::string& id) override; + bool IsInUse(const std::string& id); // override; CCriticalSection m_critSection; std::vector m_addonsInstances; }; //! \brief A virtual filesystem entry add-on. - class CVFSEntry : public IAddonInstanceHandler + class CVFSEntry : public KODI::ADDONS::INTERFACE::IInstanceHandler { public: //! \brief A structure encapsulating properties of supplied protocol. @@ -82,7 +84,7 @@ namespace ADDON bool Delete(const CURL& url); bool Rename(const CURL& url, const CURL& url2); - bool GetDirectory(const CURL& url, CFileItemList& items, void* ctx); + bool GetDirectory(const CURL& url, CFileItemList& items, KODI_CTX_CB_HDL ctx); bool DirectoryExists(const CURL& url); bool RemoveDirectory(const CURL& url); bool CreateDirectory(const CURL& url); @@ -98,6 +100,26 @@ namespace ADDON bool HasFileDirectories() const { return m_filedirectories; } const std::string& GetZeroconfType() const { return m_zeroconf; } const ProtocolInfo& GetProtocolInfo() const { return m_protocolInfo; } + + //! \brief Helper for CVFSEntryIDirectoryWrapper doing a keyboard callback. + bool DoGetKeyboardInput(KODI_CTX_CB_HDL context, + const char* heading, + char** input, + bool hidden_input); + /*---AUTO_GEN_PARSE---*/ + + //! \brief Static helper for displaying an error dialog. + void DoSetErrorDialog(KODI_CTX_CB_HDL ctx, + const char* heading, + const char* line1, + const char* line2, + const char* line3); + /*---AUTO_GEN_PARSE---*/ + + //! \brief Static helper for requiring authentication. + void DoRequireAuthentication(KODI_CTX_CB_HDL ctx, const char* url); + /*---AUTO_GEN_PARSE---*/ + protected: std::string m_protocols; //!< Protocols for VFS entry. std::string m_extensions; //!< Extensions for VFS entry. @@ -223,25 +245,14 @@ namespace ADDON //! \param[in] url URL to delete. bool Create(const CURL& url) override; - //! \brief Static helper for doing a keyboard callback. - static bool DoGetKeyboardInput(void* context, const char* heading, - char** input, bool hidden_input); //! \brief Get keyboard input. bool GetKeyboardInput2(const char* heading, char** input, bool hidden_input); - //! \brief Static helper for displaying an error dialog. - static void DoSetErrorDialog(void* ctx, const char* heading, - const char* line1, const char* line2, - const char* line3); - //! \brief Show an error dialog. void SetErrorDialog2(const char* heading, const char* line1, const char* line2, const char* line3); - //! \brief Static helper for requiring authentication. - static void DoRequireAuthentication(void* ctx, const char* url); - //! \brief Require authentication. void RequireAuthentication2(const CURL& url); protected: diff --git a/xbmc/addons/Visualization.cpp b/xbmc/addons/Visualization.cpp index be9967314b220..09b0efb8581cd 100644 --- a/xbmc/addons/Visualization.cpp +++ b/xbmc/addons/Visualization.cpp @@ -8,42 +8,18 @@ #include "Visualization.h" +#include "addons/interface/api/addon-instance/visualization.h" #include "filesystem/SpecialProtocol.h" #include "guilib/GUIWindowManager.h" #include "utils/log.h" -namespace ADDON -{ +using namespace ADDON; +using namespace KODI::ADDONS; +using namespace KODI::ADDONS::INTERFACE; CVisualization::CVisualization(const AddonInfoPtr& addonInfo, float x, float y, float w, float h) - : IAddonInstanceHandler(ADDON_INSTANCE_VISUALIZATION, addonInfo) -{ - // Setup new Visualization instance - m_name = Name(); - m_presetsPath = CSpecialProtocol::TranslatePath(Path()); - m_profilePath = CSpecialProtocol::TranslatePath(Profile()); - - m_ifc.visualization = new AddonInstance_Visualization; - - m_ifc.visualization->props = new AddonProps_Visualization(); - m_ifc.visualization->props->x = static_cast(x); - m_ifc.visualization->props->y = static_cast(y); - m_ifc.visualization->props->width = static_cast(w); - m_ifc.visualization->props->height = static_cast(h); - m_ifc.visualization->props->device = CServiceBroker::GetWinSystem()->GetHWContext(); - m_ifc.visualization->props->pixelRatio = - CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo().fPixelRatio; - m_ifc.visualization->props->name = m_name.c_str(); - m_ifc.visualization->props->presets = m_presetsPath.c_str(); - m_ifc.visualization->props->profile = m_profilePath.c_str(); - - m_ifc.visualization->toKodi = new AddonToKodiFuncTable_Visualization(); - m_ifc.visualization->toKodi->kodiInstance = this; - m_ifc.visualization->toKodi->transfer_preset = transfer_preset; - m_ifc.visualization->toKodi->clear_presets = clear_presets; - - m_ifc.visualization->toAddon = new KodiToAddonFuncTable_Visualization(); - + : IInstanceHandler(this, ADDON_INSTANCE_VISUALIZATION, addonInfo) +{ /* Open the class "kodi::addon::CInstanceVisualization" on add-on side */ if (CreateInstance() != ADDON_STATUS_OK) { @@ -52,115 +28,102 @@ CVisualization::CVisualization(const AddonInfoPtr& addonInfo, float x, float y, } /* presets becomes send with "transfer_preset" during call of function below */ - if (m_ifc.visualization->toAddon->get_presets) - m_ifc.visualization->toAddon->get_presets(m_ifc.visualization); + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + ifc->kodi_addon_visualization_get_presets_v1(m_instance); } CVisualization::~CVisualization() { /* Destroy the class "kodi::addon::CInstanceVisualization" on add-on side */ DestroyInstance(); - - delete m_ifc.visualization->toAddon; - delete m_ifc.visualization->toKodi; - delete m_ifc.visualization->props; - delete m_ifc.visualization; } -bool CVisualization::Start(int channels, int samplesPerSec, int bitsPerSample, const std::string& songName) +bool CVisualization::Start(int channels, + int samplesPerSec, + int bitsPerSample, + const std::string& songName) { - if (m_ifc.visualization->toAddon->start) - return m_ifc.visualization->toAddon->start(m_ifc.visualization, channels, samplesPerSec, - bitsPerSample, songName.c_str()); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_start_v1(this, m_instance, channels, samplesPerSec, + bitsPerSample, songName.c_str()); } void CVisualization::Stop() { - if (m_ifc.visualization->toAddon->stop) - m_ifc.visualization->toAddon->stop(m_ifc.visualization); + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + ifc->kodi_addon_visualization_stop_v1(this, m_instance); } -void CVisualization::AudioData(const float* audioData, int audioDataLength, float *freqData, int freqDataLength) +void CVisualization::AudioData(const float* audioData, int audioDataLength) { - if (m_ifc.visualization->toAddon->audio_data) - m_ifc.visualization->toAddon->audio_data(m_ifc.visualization, audioData, audioDataLength, - freqData, freqDataLength); + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + ifc->kodi_addon_visualization_audio_data_v1(m_instance, audioData, audioDataLength); } bool CVisualization::IsDirty() { - if (m_ifc.visualization->toAddon->is_dirty) - return m_ifc.visualization->toAddon->is_dirty(m_ifc.visualization); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_is_dirty_v1(m_instance); } void CVisualization::Render() { - if (m_ifc.visualization->toAddon->render) - m_ifc.visualization->toAddon->render(m_ifc.visualization); + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + ifc->kodi_addon_visualization_render_v1(this, m_instance); } -void CVisualization::GetInfo(VIS_INFO *info) +int CVisualization::GetSyncDelay() { - if (m_ifc.visualization->toAddon->get_info) - m_ifc.visualization->toAddon->get_info(m_ifc.visualization, info); + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_get_sync_delay_v1(m_instance); } bool CVisualization::NextPreset() { - if (m_ifc.visualization->toAddon->next_preset) - return m_ifc.visualization->toAddon->next_preset(m_ifc.visualization); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_next_preset_v1(m_instance); } bool CVisualization::PrevPreset() { - if (m_ifc.visualization->toAddon->prev_preset) - return m_ifc.visualization->toAddon->prev_preset(m_ifc.visualization); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_prev_preset_v1(m_instance); } bool CVisualization::LoadPreset(int select) { - if (m_ifc.visualization->toAddon->load_preset) - return m_ifc.visualization->toAddon->load_preset(m_ifc.visualization, select); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_load_preset_v1(m_instance, select); } bool CVisualization::RandomPreset() { - if (m_ifc.visualization->toAddon->random_preset) - return m_ifc.visualization->toAddon->random_preset(m_ifc.visualization); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_random_preset_v1(m_instance); } bool CVisualization::LockPreset() { - if (m_ifc.visualization->toAddon->lock_preset) - return m_ifc.visualization->toAddon->lock_preset(m_ifc.visualization); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_lock_preset_v1(m_instance); } bool CVisualization::RatePreset(bool plus_minus) { - if (m_ifc.visualization->toAddon->rate_preset) - return m_ifc.visualization->toAddon->rate_preset(m_ifc.visualization, plus_minus); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_rate_preset_v1(m_instance, plus_minus); } bool CVisualization::UpdateAlbumart(const char* albumart) { - if (m_ifc.visualization->toAddon->update_albumart) - return m_ifc.visualization->toAddon->update_albumart(m_ifc.visualization, albumart); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_update_albumart_v1(m_instance, albumart); } -bool CVisualization::UpdateTrack(const VIS_TRACK* track) +bool CVisualization::UpdateTrack(const KODI_ADDON_VISUALIZATION_TRACK* track) { - if (m_ifc.visualization->toAddon->update_track) - return m_ifc.visualization->toAddon->update_track(m_ifc.visualization, track); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_update_track_v1(m_instance, track); } bool CVisualization::HasPresets() @@ -168,7 +131,7 @@ bool CVisualization::HasPresets() return !m_presets.empty(); } -bool CVisualization::GetPresetList(std::vector &vecpresets) +bool CVisualization::GetPresetList(std::vector& vecpresets) { vecpresets = m_presets; return !m_presets.empty(); @@ -176,9 +139,8 @@ bool CVisualization::GetPresetList(std::vector &vecpresets) int CVisualization::GetActivePreset() { - if (m_ifc.visualization->toAddon->get_active_preset) - return m_ifc.visualization->toAddon->get_active_preset(m_ifc.visualization); - return -1; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_get_active_preset_v1(m_instance); } std::string CVisualization::GetActivePresetName() @@ -190,33 +152,49 @@ std::string CVisualization::GetActivePresetName() bool CVisualization::IsLocked() { - if (m_ifc.visualization->toAddon->is_locked) - return m_ifc.visualization->toAddon->is_locked(m_ifc.visualization); - return false; + const auto ifc = m_ifc->kodi_addoninstance_visualization_h; + return ifc->kodi_addon_visualization_is_locked_v1(m_instance); } -void CVisualization::transfer_preset(void* kodiInstance, const char* preset) +bool CVisualization::GetOffscreenRenderInfos( + int& x, int& y, int& width, int& height, ADDON_HARDWARE_CONTEXT& context) { - CVisualization *addon = static_cast(kodiInstance); - if (!addon || !preset) - { - CLog::Log(LOGERROR, "CVisualization::{} - invalid handler data", __FUNCTION__); - return; - } + const auto winSystem = CServiceBroker::GetWinSystem(); + if (!winSystem) + return false; - addon->m_presets.emplace_back(preset); + x = 0; + y = 0; + context = winSystem->GetHWContext(); + width = winSystem->GetGfxContext().GetWidth(); + height = winSystem->GetGfxContext().GetHeight(); + + return true; } -void CVisualization::clear_presets(void* kodiInstance) +void CVisualization::get_properties(struct KODI_ADDON_VISUALIZATION_PROPS* props) { - CVisualization* addon = static_cast(kodiInstance); - if (!addon) - { - CLog::Log(LOGERROR, "CVisualization::{} - invalid handler data", __FUNCTION__); + if (!props) return; - } - addon->m_presets.clear(); + const auto winSystem = CServiceBroker::GetWinSystem(); + if (!winSystem) + return; + + props->x = 0; + props->y = 0; + props->device = winSystem->GetHWContext(); + props->width = winSystem->GetGfxContext().GetWidth(); + props->height = winSystem->GetGfxContext().GetHeight(); + props->pixelRatio = winSystem->GetGfxContext().GetResInfo().fPixelRatio; +} + +void CVisualization::transfer_preset(const char* preset) +{ + m_presets.emplace_back(preset); } -} /* namespace ADDON */ +void CVisualization::clear_presets() +{ + m_presets.clear(); +} diff --git a/xbmc/addons/Visualization.h b/xbmc/addons/Visualization.h index 43af24f006db4..da9d99c743de1 100644 --- a/xbmc/addons/Visualization.h +++ b/xbmc/addons/Visualization.h @@ -8,24 +8,28 @@ #pragma once -#include "addons/binary-addons/AddonInstanceHandler.h" -#include "addons/kodi-dev-kit/include/kodi/addon-instance/Visualization.h" +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/visualization.h" +#include "interface/IOffscreenRenderProcess.h" +#include "interface/InstanceHandler.h" -namespace ADDON +namespace KODI +{ +namespace ADDONS { -class CVisualization : public IAddonInstanceHandler +class CVisualization : public KODI::ADDONS::INTERFACE::IInstanceHandler, + public KODI::ADDONS::INTERFACE::IOffscreenRenderProcess { public: - CVisualization(const AddonInfoPtr& addonInfo, float x, float y, float w, float h); + CVisualization(const ADDON::AddonInfoPtr& addonInfo, float x, float y, float w, float h); ~CVisualization() override; bool Start(int channels, int samplesPerSec, int bitsPerSample, const std::string& songName); void Stop(); - void AudioData(const float* audioData, int audioDataLength, float *freqData, int freqDataLength); + void AudioData(const float* audioData, int audioDataLength); bool IsDirty(); void Render(); - void GetInfo(VIS_INFO *info); + int GetSyncDelay(); bool NextPreset(); bool PrevPreset(); bool LoadPreset(int select); @@ -33,22 +37,27 @@ class CVisualization : public IAddonInstanceHandler bool LockPreset(); bool RatePreset(bool plus_minus); bool UpdateAlbumart(const char* albumart); - bool UpdateTrack(const VIS_TRACK* track); + bool UpdateTrack(const KODI_ADDON_VISUALIZATION_TRACK* track); bool HasPresets(); bool GetPresetList(std::vector& vecpresets); int GetActivePreset(); std::string GetActivePresetName(); bool IsLocked(); + void get_properties(KODI_ADDON_VISUALIZATION_PROPS* props); + /*---AUTO_GEN_PARSE---*/ + void transfer_preset(const char* preset); + /*---AUTO_GEN_PARSE---*/ + void clear_presets(); + /*---AUTO_GEN_PARSE---*/ + +protected: + bool GetOffscreenRenderInfos( + int& x, int& y, int& width, int& height, ADDON_HARDWARE_CONTEXT& context) override; + private: - std::string m_name; /*!< To add-on sended name */ - std::string m_presetsPath; /*!< To add-on sended preset path */ - std::string m_profilePath; /*!< To add-on sended profile path */ std::vector m_presets; /*!< cached preset list */ - - // Static function to transfer data from add-on to kodi - static void transfer_preset(void* kodiInstance, const char* preset); - static void clear_presets(void* kodiInstance); }; -} /* namespace ADDON */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/addoninfo/AddonInfo.cpp b/xbmc/addons/addoninfo/AddonInfo.cpp index babfaab16ba2a..5727ae52a649d 100644 --- a/xbmc/addons/addoninfo/AddonInfo.cpp +++ b/xbmc/addons/addoninfo/AddonInfo.cpp @@ -34,7 +34,7 @@ typedef struct } TypeMapping; // clang-format off -static constexpr const std::array types = +static constexpr const std::array types = {{ {"unknown", "", ADDON_UNKNOWN, 0, AddonInstanceSupport::SUPPORT_NONE, "" }, {"xbmc.metadata.scraper.albums", "", ADDON_SCRAPER_ALBUMS, 24016, AddonInstanceSupport::SUPPORT_NONE, "DefaultAddonAlbumInfo.png" }, @@ -76,6 +76,7 @@ static constexpr const std::array types = {"kodi.inputstream", "", ADDON_INPUTSTREAM, 24048, AddonInstanceSupport::SUPPORT_MANDATORY, "DefaultAddonInputstream.png" }, {"kodi.vfs", "", ADDON_VFS, 39013, AddonInstanceSupport::SUPPORT_MANDATORY, "DefaultAddonVfs.png" }, {"kodi.imagedecoder", "", ADDON_IMAGEDECODER, 39015, AddonInstanceSupport::SUPPORT_MANDATORY, "DefaultAddonImageDecoder.png" }, + {"kodi.web", "", ADDON_WEB_MANAGER, 29986, AddonInstanceSupport::SUPPORT_NONE, "DefaultAddonWeb.png" }, }}; // clang-format on @@ -169,7 +170,7 @@ CAddonInfo::CAddonInfo(std::string id, TYPE type) const CAddonType* CAddonInfo::Type(TYPE type) const { - static CAddonType dummy; + static CAddonType dummy(ADDON_UNKNOWN, AddonLanguage::Unknown); if (!m_types.empty()) { diff --git a/xbmc/addons/addoninfo/AddonInfoBuilder.cpp b/xbmc/addons/addoninfo/AddonInfoBuilder.cpp index e00266bca65f3..2eae8589ba3eb 100644 --- a/xbmc/addons/addoninfo/AddonInfoBuilder.cpp +++ b/xbmc/addons/addoninfo/AddonInfoBuilder.cpp @@ -8,7 +8,6 @@ #include "AddonInfoBuilder.h" -#include "CompileInfo.h" #include "LangInfo.h" #include "addons/addoninfo/AddonType.h" #include "filesystem/File.h" @@ -23,7 +22,6 @@ #include #include -#include namespace { @@ -146,6 +144,8 @@ bool CAddonInfoBuilder::ParseXML(const AddonInfoPtr& addon, const TiXmlElement* return false; } + addon->m_profilePath = StringUtils::Format("special://profile/addon_data/{}/", addon->m_id); + // Check addon identifier for forbidden characters // The identifier is used e.g. in URLs so we shouldn't allow just // any character to go through. @@ -399,7 +399,7 @@ bool CAddonInfoBuilder::ParseXML(const AddonInfoPtr& addon, const TiXmlElement* return false; } - CAddonType addonType(type); + CAddonType addonType(type, AddonLanguage::Unknown); if (ParseXMLTypes(addonType, addon, child)) addon->m_types.emplace_back(std::move(addonType)); } @@ -411,7 +411,7 @@ bool CAddonInfoBuilder::ParseXML(const AddonInfoPtr& addon, const TiXmlElement* */ if (addon->m_types.empty()) { - CAddonType addonType(ADDON_UNKNOWN); + CAddonType addonType(ADDON_UNKNOWN, AddonLanguage::Unknown); addon->m_types.emplace_back(std::move(addonType)); } @@ -472,25 +472,19 @@ bool CAddonInfoBuilder::ParseXMLTypes(CAddonType& addonType, if (library != nullptr) { addonType.m_libname = library; + info->SetBinary(URIUtils::IsSharedLibrarySuffix(library)); - try - { - // linux is different and has the version number after the suffix - static const std::regex libRegex("^.*" + - CCompileInfo::CCompileInfo::GetSharedLibrarySuffix() + - "\\.?[0-9]*\\.?[0-9]*\\.?[0-9]*$"); - if (std::regex_match(library, libRegex)) - { - info->SetBinary(true); - CLog::Log(LOGDEBUG, "CAddonInfoBuilder::{}: Binary addon found: {}", __func__, - info->ID()); - } - } - catch (const std::regex_error& e) - { - CLog::Log(LOGERROR, "CAddonInfoBuilder::{}: Regex error caught: {}", __func__, - e.what()); - } + const char* language = child->Attribute("language"); + if (language) + addonType.SetLanguage(language); + else if (info->IsBinary()) + addonType.SetLanguage(AddonLanguage::CPP); + else + addonType.SetLanguage(DetectAddonLanguage(library)); + } + else if (addonType.Type() == ADDON_SKIN) + { + addonType.SetLanguage(AddonLanguage::Skin); } if (!ParseXMLExtension(addonType, child)) @@ -604,6 +598,32 @@ bool CAddonInfoBuilder::GetTextList(const TiXmlElement* element, const std::stri return !translatedValues.empty(); } +AddonLanguage CAddonInfoBuilder::DetectAddonLanguage(const std::string& library) +{ + AddonLanguage language = AddonLanguage::Unknown; + + const std::string ext = URIUtils::GetExtension(library); + if (ext.empty()) + return language; + + /*if (ext == ".py") + return AddonLanguage::Python3; + else */if (ext == ".java" || ext == ".jar") + return AddonLanguage::Java; + else if (ext == ".js") + return AddonLanguage::JavaScript; + else if (ext == ".exe") + return AddonLanguage::CPP; // Hopefully, but no matter there if C or C++ + else if (ext == ".groovy" || ext == ".gvy" || ext == ".gy" || ext == ".gsh") + return AddonLanguage::Groovy; + else if (ext == ".rb") + return AddonLanguage::Ruby; + else if (ext == ".xml") + return AddonLanguage::XML; + + return language; +} + const char* CAddonInfoBuilder::GetPlatformLibraryName(const TiXmlElement* element) { const char* libraryName; diff --git a/xbmc/addons/addoninfo/AddonInfoBuilder.h b/xbmc/addons/addoninfo/AddonInfoBuilder.h index 08fdaa6734305..4d263900e366e 100644 --- a/xbmc/addons/addoninfo/AddonInfoBuilder.h +++ b/xbmc/addons/addoninfo/AddonInfoBuilder.h @@ -98,6 +98,7 @@ class CAddonInfoBuilder static bool GetTextList(const TiXmlElement* element, const std::string& tag, std::unordered_map& translatedValues); static const char* GetPlatformLibraryName(const TiXmlElement* element); static bool PlatformSupportsAddon(const AddonInfoPtr& addon); + static AddonLanguage DetectAddonLanguage(const std::string& library); }; } diff --git a/xbmc/addons/addoninfo/AddonType.cpp b/xbmc/addons/addoninfo/AddonType.cpp index 0df7dda4f0a09..d08b1b09827ec 100644 --- a/xbmc/addons/addoninfo/AddonType.cpp +++ b/xbmc/addons/addoninfo/AddonType.cpp @@ -18,6 +18,29 @@ static const std::set dependencyTypes = { ADDON_SCRIPT_LIBRARY, ADDON_SCRIPT_MODULE, }; + +typedef struct +{ + AddonLanguage language; + std::string name; + int localizedStringID; +} LanguageMapping; + +// clang-format off +static const LanguageMapping languages[] = + {{ AddonLanguage::Unknown, "unknown", 2300 }, + { AddonLanguage::C, "C", 2301 }, + { AddonLanguage::CPP, "C++", 2302 }, + { AddonLanguage::Groovy, "Groovy", 2303 }, + { AddonLanguage::Java, "Java", 2304 }, + { AddonLanguage::JavaScript, "JavaScript", 2305 }, + { AddonLanguage::Python3, "Python3", 2306 }, + { AddonLanguage::Ruby, "Ruby", 2307 }, + { AddonLanguage::Skin, "Skin", 2308 }, + { AddonLanguage::XML, "XML", 2309 } + }; +// clang-format on + } /* namespace ADDON */ using namespace ADDON; @@ -29,6 +52,31 @@ std::string CAddonType::LibPath() const return URIUtils::AddFileToFolder(m_path, m_libname); } +const std::string& CAddonType::LanguageName() const +{ + for (const LanguageMapping& map : languages) + { + if (map.language == m_language) + return map.name; + } + return languages[0].name; +} + +int CAddonType::LanguageLocalizedStringID() const +{ + for (const LanguageMapping& map : languages) + { + if (map.language == m_language) + return map.localizedStringID; + } + return languages[0].localizedStringID; +} + +void CAddonType::SetType(TYPE type) +{ + m_type = type; +} + void CAddonType::SetProvides(const std::string& content) { if (!content.empty()) @@ -52,6 +100,24 @@ void CAddonType::SetProvides(const std::string& content) } } +void CAddonType::SetLanguage(const std::string& name) +{ + for (const LanguageMapping& map : languages) + { + if (StringUtils::EqualsNoCase(map.name, name)) + { + m_language = map.language; + return; + } + } + m_language = AddonLanguage::Unknown; +} + +void CAddonType::SetLanguage(AddonLanguage lang) +{ + m_language = lang; +} + bool CAddonType::IsDependencyType(TYPE type) { return dependencyTypes.find(type) != dependencyTypes.end(); diff --git a/xbmc/addons/addoninfo/AddonType.h b/xbmc/addons/addoninfo/AddonType.h index 36b43a8cf687a..f3f48a7bd6843 100644 --- a/xbmc/addons/addoninfo/AddonType.h +++ b/xbmc/addons/addoninfo/AddonType.h @@ -18,6 +18,20 @@ class TiXmlElement; namespace ADDON { +enum class AddonLanguage +{ + Unknown, + C, + CPP, + Groovy, + Java, + JavaScript, + Python3, + Ruby, + XML, + Skin +}; + typedef enum { ADDON_UNKNOWN, @@ -56,6 +70,7 @@ typedef enum ADDON_SCRIPT_MODULE, ADDON_GAME_CONTROLLER, ADDON_VIDEOCODEC, + ADDON_WEB_MANAGER, /** * @brief virtual addon types @@ -77,11 +92,14 @@ class CAddonDatabaseSerializer; class CAddonType : public CAddonExtensions { public: - CAddonType(TYPE type = ADDON_UNKNOWN) : m_type(type) {} + CAddonType(TYPE type, AddonLanguage lang) : m_type(type), m_language(lang) {} TYPE Type() const { return m_type; } std::string LibPath() const; const std::string& LibName() const { return m_libname; } + AddonLanguage Language() const { return m_language; } + const std::string& LanguageName() const; + int LanguageLocalizedStringID() const; bool ProvidesSubContent(const TYPE& content) const { @@ -111,9 +129,13 @@ class CAddonType : public CAddonExtensions friend class CAddonInfoBuilder; friend class CAddonDatabaseSerializer; + void SetType(TYPE type); void SetProvides(const std::string& content); + void SetLanguage(const std::string& name); + void SetLanguage(AddonLanguage lang); TYPE m_type; + AddonLanguage m_language; std::string m_path; std::string m_libname; std::set m_providedSubContent; diff --git a/xbmc/addons/binary-addons/AddonDll.cpp b/xbmc/addons/binary-addons/AddonDll.cpp deleted file mode 100644 index 882bb22a292dd..0000000000000 --- a/xbmc/addons/binary-addons/AddonDll.cpp +++ /dev/null @@ -1,548 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "AddonDll.h" - -#include "ServiceBroker.h" -#include "addons/AddonStatusHandler.h" -#include "addons/binary-addons/BinaryAddonBase.h" -#include "addons/binary-addons/BinaryAddonManager.h" -#include "addons/settings/AddonSettings.h" -#include "events/EventLog.h" -#include "events/NotificationEvent.h" -#include "filesystem/File.h" -#include "filesystem/SpecialProtocol.h" -#include "messaging/helpers/DialogOKHelper.h" -#include "utils/URIUtils.h" -#include "utils/Variant.h" -#include "utils/log.h" - -#include - -using namespace KODI::MESSAGING; - -namespace ADDON -{ - -CAddonDll::CAddonDll(const AddonInfoPtr& addonInfo, BinaryAddonBasePtr addonBase) - : CAddon(addonInfo, addonInfo->MainType()), m_binaryAddonBase(std::move(addonBase)) -{ -} - -CAddonDll::CAddonDll(const AddonInfoPtr& addonInfo, TYPE addonType) - : CAddon(addonInfo, addonType), - m_binaryAddonBase(CServiceBroker::GetBinaryAddonManager().GetRunningAddonBase(addonInfo->ID())) -{ -} - -CAddonDll::~CAddonDll() -{ - if (m_initialized) - Destroy(); -} - -std::string CAddonDll::GetDllPath(const std::string &libPath) -{ - std::string strFileName = libPath; - std::string strLibName = URIUtils::GetFileName(strFileName); - - if (strLibName.empty()) - return ""; - - /* Check if lib being loaded exists, else check in XBMC binary location */ -#if defined(TARGET_ANDROID) - if (XFILE::CFile::Exists(strFileName)) - { - bool doCopy = true; - std::string dstfile = URIUtils::AddFileToFolder(CSpecialProtocol::TranslatePath("special://xbmcaltbinaddons/"), strLibName); - - struct __stat64 dstFileStat; - if (XFILE::CFile::Stat(dstfile, &dstFileStat) == 0) - { - struct __stat64 srcFileStat; - if (XFILE::CFile::Stat(strFileName, &srcFileStat) == 0) - { - if (dstFileStat.st_size == srcFileStat.st_size && dstFileStat.st_mtime > srcFileStat.st_mtime) - doCopy = false; - } - } - - if (doCopy) - { - CLog::Log(LOGDEBUG, "ADDON: caching {} to {}", strFileName, dstfile); - XFILE::CFile::Copy(strFileName, dstfile); - } - - strFileName = dstfile; - } - if (!XFILE::CFile::Exists(strFileName)) - { - std::string tempbin = getenv("KODI_ANDROID_LIBS"); - strFileName = tempbin + "/" + strLibName; - } -#endif - - if (!XFILE::CFile::Exists(strFileName)) - { - std::string strAltFileName; - - std::string altbin = CSpecialProtocol::TranslatePath("special://xbmcaltbinaddons/"); - if (!altbin.empty()) - { - strAltFileName = altbin + strLibName; - if (!XFILE::CFile::Exists(strAltFileName)) - { - std::string temp = CSpecialProtocol::TranslatePath("special://xbmc/addons/"); - strAltFileName = strFileName; - strAltFileName.erase(0, temp.size()); - strAltFileName = altbin + strAltFileName; - } - CLog::Log(LOGDEBUG, "ADDON: Trying to load {}", strAltFileName); - } - - if (XFILE::CFile::Exists(strAltFileName)) - strFileName = strAltFileName; - else - { - std::string temp = CSpecialProtocol::TranslatePath("special://xbmc/"); - std::string tempbin = CSpecialProtocol::TranslatePath("special://xbmcbin/"); - strFileName.erase(0, temp.size()); - strFileName = tempbin + strFileName; - if (!XFILE::CFile::Exists(strFileName)) - { - CLog::Log(LOGERROR, "ADDON: Could not locate {}", strLibName); - strFileName.clear(); - } - } - } - - return strFileName; -} - -std::string CAddonDll::LibPath() const -{ - return GetDllPath(CAddon::LibPath()); -} - -bool CAddonDll::LoadDll() -{ - if (m_pDll) - return true; - - std::string strFileName = LibPath(); - if (strFileName.empty()) - return false; - - /* Load the Dll */ - m_pDll = new DllAddon; - m_pDll->SetFile(strFileName); - m_pDll->EnableDelayedUnload(false); - if (!m_pDll->Load()) - { - delete m_pDll; - m_pDll = nullptr; - - std::string heading = - StringUtils::Format("{}: {}", CAddonInfo::TranslateType(Type(), true), Name()); - HELPERS::ShowOKDialogLines(CVariant{heading}, CVariant{24070}, CVariant{24071}); - - return false; - } - - return true; -} - -ADDON_STATUS CAddonDll::Create(KODI_ADDON_INSTANCE_STRUCT* firstKodiInstance) -{ - CLog::Log(LOGDEBUG, "ADDON: Dll Initializing - {}", Name()); - m_initialized = false; - - if (!LoadDll()) - { - return ADDON_STATUS_PERMANENT_FAILURE; - } - - /* Check versions about global parts on add-on (parts used on all types) */ - for (unsigned int id = ADDON_GLOBAL_MAIN; id <= ADDON_GLOBAL_MAX; ++id) - { - if (!CheckAPIVersion(id)) - return ADDON_STATUS_PERMANENT_FAILURE; - } - - /* Allocate the helper function class to allow crosstalk over - helper add-on headers */ - if (!Interface_Base::InitInterface(this, m_interface, firstKodiInstance)) - return ADDON_STATUS_PERMANENT_FAILURE; - - /* Call Create to make connections, initializing data or whatever is - needed to become the AddOn running */ - ADDON_STATUS status = m_pDll->Create(&m_interface); - - // "C" ABI related call, if on add-on used. - if (status == ADDON_STATUS_OK && m_interface.toAddon->create) - status = m_interface.toAddon->create(m_interface.firstKodiInstance, &m_interface.addonBase); - - if (status == ADDON_STATUS_OK) - { - m_initialized = true; - } - else if (status == ADDON_STATUS_NEED_SETTINGS) - { - if ((status = TransferSettings(ADDON_SETTINGS_ID)) == ADDON_STATUS_OK) - m_initialized = true; - else - new CAddonStatusHandler(ID(), ADDON_SETTINGS_ID, status, false); - } - else - { // Addon failed initialization - CLog::Log(LOGERROR, - "ADDON: Dll {} - Client returned bad status ({}) from Create and is not usable", - Name(), status); - - // @todo currently a copy and paste from other function and becomes improved. - std::string heading = - StringUtils::Format("{}: {}", CAddonInfo::TranslateType(Type(), true), Name()); - HELPERS::ShowOKDialogLines(CVariant{ heading }, CVariant{ 24070 }, CVariant{ 24071 }); - } - - return status; -} - -void CAddonDll::Destroy() -{ - /* Unload library file */ - if (m_pDll) - { - if (m_interface.toAddon->destroy) - m_interface.toAddon->destroy(m_interface.addonBase); - m_pDll->Unload(); - } - - Interface_Base::DeInitInterface(m_interface); - - if (m_pDll) - { - delete m_pDll; - m_pDll = nullptr; - CLog::Log(LOGINFO, "ADDON: Dll Destroyed - {}", Name()); - } - - ResetSettings(ADDON_SETTINGS_ID); - - m_initialized = false; -} - -ADDON_STATUS CAddonDll::CreateInstance(KODI_ADDON_INSTANCE_STRUCT* instance) -{ - assert(instance != nullptr); - assert(instance->functions != nullptr); - assert(instance->info != nullptr); - assert(instance->info->functions != nullptr); - - ADDON_STATUS status = ADDON_STATUS_OK; - - if (!m_initialized) - status = Create(instance); - if (status != ADDON_STATUS_OK) - return status; - - /* Check version of requested instance type */ - if (!CheckAPIVersion(instance->info->type)) - return ADDON_STATUS_PERMANENT_FAILURE; - - status = m_interface.toAddon->create_instance(m_interface.addonBase, instance); - - if (instance->info) - { - m_usedInstances[instance->info->kodi] = instance; - } - - return status; -} - -void CAddonDll::DestroyInstance(KODI_ADDON_INSTANCE_STRUCT* instance) -{ - if (m_usedInstances.empty()) - return; - - auto it = m_usedInstances.find(instance->info->kodi); - if (it != m_usedInstances.end()) - { - m_interface.toAddon->destroy_instance(m_interface.addonBase, it->second); - m_usedInstances.erase(it); - } - - if (m_usedInstances.empty()) - Destroy(); -} - -bool CAddonDll::IsInUse() const -{ - if (m_informer) - return m_informer->IsInUse(ID()); - return false; -} - -void CAddonDll::RegisterInformer(CAddonDllInformer* informer) -{ - m_informer = informer; -} - -AddonPtr CAddonDll::GetRunningInstance() const -{ - if (CServiceBroker::IsBinaryAddonCacheUp()) - return CServiceBroker::GetBinaryAddonManager().GetRunningAddon(ID()); - - return AddonPtr(); -} - -void CAddonDll::OnPreInstall() -{ - if (m_binaryAddonBase) - m_binaryAddonBase->OnPreInstall(); -} - -void CAddonDll::OnPostInstall(bool update, bool modal) -{ - if (m_binaryAddonBase) - m_binaryAddonBase->OnPostInstall(update, modal); -} - -void CAddonDll::OnPreUnInstall() -{ - if (m_binaryAddonBase) - m_binaryAddonBase->OnPreUnInstall(); -} - -void CAddonDll::OnPostUnInstall() -{ - if (m_binaryAddonBase) - m_binaryAddonBase->OnPostUnInstall(); -} - -bool CAddonDll::DllLoaded(void) const -{ - return m_pDll != nullptr; -} - -AddonVersion CAddonDll::GetTypeVersionDll(int type) const -{ - return AddonVersion(m_pDll ? m_pDll->GetAddonTypeVersion(type) : nullptr); -} - -AddonVersion CAddonDll::GetTypeMinVersionDll(int type) const -{ - return AddonVersion(m_pDll ? m_pDll->GetAddonTypeMinVersion(type) : nullptr); -} - -void CAddonDll::SaveSettings(AddonInstanceId id /* = ADDON_SETTINGS_ID */) -{ - // must save first, as TransferSettings() reloads saved settings! - CAddon::SaveSettings(id); - if (m_initialized) - TransferSettings(id); -} - -ADDON_STATUS CAddonDll::TransferSettings(AddonInstanceId instanceId) -{ - bool restart = false; - ADDON_STATUS reportStatus = ADDON_STATUS_OK; - - CLog::Log(LOGDEBUG, "Calling TransferSettings for: {}", Name()); - - LoadSettings(false, true, instanceId); - - auto settings = GetSettings(instanceId); - if (settings != nullptr) - { - KODI_ADDON_INSTANCE_FUNC* instanceTarget{nullptr}; - KODI_ADDON_INSTANCE_HDL instanceHandle{nullptr}; - if (instanceId != ADDON_SETTINGS_ID) - { - const auto it = std::find_if( - m_usedInstances.begin(), m_usedInstances.end(), - [instanceId](const auto& data) { return data.second->info->number == instanceId; }); - if (it == m_usedInstances.end()) - return ADDON_STATUS_UNKNOWN; - - instanceTarget = it->second->functions; - instanceHandle = it->second->hdl; - } - - for (const auto& section : settings->GetSections()) - { - for (const auto& category : section->GetCategories()) - { - for (const auto& group : category->GetGroups()) - { - for (const auto& setting : group->GetSettings()) - { - if (StringUtils::StartsWith(setting->GetId(), ADDON_SETTING_INSTANCE_GROUP)) - continue; // skip internal settings - - ADDON_STATUS status = ADDON_STATUS_OK; - const char* id = setting->GetId().c_str(); - - switch (setting->GetType()) - { - case SettingType::Boolean: - { - bool tmp = std::static_pointer_cast(setting)->GetValue(); - if (instanceId == ADDON_SETTINGS_ID) - { - if (m_interface.toAddon->setting_change_boolean) - status = - m_interface.toAddon->setting_change_boolean(m_interface.addonBase, id, tmp); - } - else if (instanceTarget && instanceHandle) - { - if (instanceTarget->instance_setting_change_boolean) - status = - instanceTarget->instance_setting_change_boolean(instanceHandle, id, tmp); - } - break; - } - - case SettingType::Integer: - { - int tmp = std::static_pointer_cast(setting)->GetValue(); - if (instanceId == ADDON_SETTINGS_ID) - { - if (m_interface.toAddon->setting_change_integer) - status = - m_interface.toAddon->setting_change_integer(m_interface.addonBase, id, tmp); - } - else if (instanceTarget && instanceHandle) - { - if (instanceTarget->instance_setting_change_integer) - status = - instanceTarget->instance_setting_change_integer(instanceHandle, id, tmp); - } - break; - } - - case SettingType::Number: - { - float tmpf = static_cast(std::static_pointer_cast(setting)->GetValue()); - if (instanceId == ADDON_SETTINGS_ID) - { - if (m_interface.toAddon->setting_change_float) - status = - m_interface.toAddon->setting_change_float(m_interface.addonBase, id, tmpf); - } - else if (instanceTarget && instanceHandle) - { - if (instanceTarget->instance_setting_change_float) - status = - instanceTarget->instance_setting_change_float(instanceHandle, id, tmpf); - } - break; - } - - case SettingType::String: - { - if (instanceId == ADDON_SETTINGS_ID) - { - if (m_interface.toAddon->setting_change_string) - status = m_interface.toAddon->setting_change_string( - m_interface.addonBase, id, - std::static_pointer_cast(setting)->GetValue().c_str()); - } - else if (instanceTarget && instanceHandle) - { - if (instanceTarget->instance_setting_change_string) - status = instanceTarget->instance_setting_change_string( - instanceHandle, id, - std::static_pointer_cast(setting)->GetValue().c_str()); - } - break; - } - - default: - { - // log unknowns as an error, but go ahead and transfer the string - CLog::Log(LOGERROR, "Unknown setting type of '{}' for {}", id, Name()); - if (instanceId == ADDON_SETTINGS_ID) - { - if (m_interface.toAddon->setting_change_string) - status = m_interface.toAddon->setting_change_string( - m_interface.addonBase, id, setting->ToString().c_str()); - } - else if (instanceTarget && instanceHandle) - { - if (instanceTarget->instance_setting_change_string) - status = instanceTarget->instance_setting_change_string( - instanceHandle, id, setting->ToString().c_str()); - } - break; - } - } - - if (status == ADDON_STATUS_NEED_RESTART) - restart = true; - else if (status != ADDON_STATUS_OK) - reportStatus = status; - } - } - } - } - } - - if (restart || reportStatus != ADDON_STATUS_OK) - { - new CAddonStatusHandler(ID(), instanceId, restart ? ADDON_STATUS_NEED_RESTART : reportStatus, - true); - } - - return ADDON_STATUS_OK; -} - -bool CAddonDll::CheckAPIVersion(int type) -{ - /* check the API version */ - AddonVersion kodiMinVersion(kodi::addon::GetTypeMinVersion(type)); - AddonVersion addonVersion(m_pDll->GetAddonTypeVersion(type)); - AddonVersion addonMinVersion = m_pDll->GetAddonTypeMinVersion_available() - ? AddonVersion(m_pDll->GetAddonTypeMinVersion(type)) - : addonVersion; - - /* Check the global usage from addon - * if not used from addon, empty version is returned - */ - if (type <= ADDON_GLOBAL_MAX && addonVersion.empty()) - return true; - - /* If a instance (not global) version becomes checked must be the version - * present. - */ - if (kodiMinVersion > addonVersion || - addonMinVersion > AddonVersion(kodi::addon::GetTypeVersion(type))) - { - CLog::Log(LOGERROR, "Add-on '{}' is using an incompatible API version for type '{}'. Kodi API min version = '{}/{}', add-on API version '{}/{}'", - Name(), - kodi::addon::GetTypeName(type), - kodi::addon::GetTypeVersion(type), - kodiMinVersion.asString(), - addonMinVersion.asString(), - addonVersion.asString()); - - if (CServiceBroker::GetGUI()) - { - CEventLog* eventLog = CServiceBroker::GetEventLog(); - if (eventLog) - eventLog->AddWithNotification( - EventPtr(new CNotificationEvent(Name(), 24152, EventLevel::Error))); - } - - return false; - } - - return true; -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/binary-addons/AddonDll.h b/xbmc/addons/binary-addons/AddonDll.h deleted file mode 100644 index 701900fe89d22..0000000000000 --- a/xbmc/addons/binary-addons/AddonDll.h +++ /dev/null @@ -1,159 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "BinaryAddonManager.h" -#include "DllAddon.h" -#include "addons/Addon.h" -#include "utils/XMLUtils.h" - -// Global addon callback handle classes -#include "addons/interfaces/AddonBase.h" - -namespace ADDON -{ - -/*! - * Addon instance handler, used as identify for std::map to find related - * addon instance. This class itself not accessed here. - * - * @todo As long game addon system use CAddonDll itself and not - * IAddonInstanceHandler as parent, is the set of this as "void*" needed. - * After game system is changed should by this also changed to - * "const IAddonInstanceHandler*" or direct in map below. - */ -using ADDON_INSTANCE_HANDLER = void*; - -/*! - * @brief Information class for use on addon type managers. - * - * This to query via @ref CAddonDll the manager so that work can be performed. - * If there are multiple instances it be harder to be informed about any changes. - */ -class CAddonDllInformer -{ -public: - virtual ~CAddonDllInformer() = default; - - virtual bool IsInUse(const std::string& id) = 0; -}; - -class CAddonDll : public CAddon -{ -public: - CAddonDll(const AddonInfoPtr& addonInfo, BinaryAddonBasePtr addonBase); - CAddonDll(const AddonInfoPtr& addonInfo, TYPE addonType); - ~CAddonDll() override; - - // Implementation of IAddon via CAddon - std::string LibPath() const override; - - // addon settings - void SaveSettings(AddonInstanceId id = ADDON_SETTINGS_ID) override; - - bool DllLoaded(void) const; - - /*! - * @brief Get api version of moduleType type - * - * @return The version of requested type, if dll is loaded and supported by addon. - * If one of both do not match, an empty version is returned. - * - * @note This should only be called if the associated dll is loaded. - * Otherwise use @ref CAddonInfo::DependencyVersion(...) - */ - AddonVersion GetTypeVersionDll(int type) const; - - /*! - * @brief Get api min version of moduleType type - * - * @return The version of requested type, if dll is loaded and supported by addon. - * If one of both do not match, an empty version is returned. - * - * @note This should only be called if the associated dll is loaded. - * Otherwise use @ref CAddonInfo::DependencyMinVersion(...) - */ - AddonVersion GetTypeMinVersionDll(int type) const; - - /*! - * @brief Function to create a addon instance class - * - * @param[in,out] instance The for addon used data structure for active instance - * @return The status of addon after the creation. - */ - ADDON_STATUS CreateInstance(KODI_ADDON_INSTANCE_STRUCT* instance); - - /*! - * @brief Function to destroy a on addon created instance class - * - * @param[in] instance The for addon used data structure for active instance - */ - void DestroyInstance(KODI_ADDON_INSTANCE_STRUCT* instance); - - bool IsInUse() const override; - void RegisterInformer(CAddonDllInformer* informer); - AddonPtr GetRunningInstance() const override; - - void OnPreInstall() override; - void OnPostInstall(bool update, bool modal) override; - void OnPreUnInstall() override; - void OnPostUnInstall() override; - - bool Initialized() const { return m_initialized; } - -protected: - static std::string GetDllPath(const std::string& strFileName); - - std::string m_parentLib; - -private: - /*! - * @brief Main addon creation call function - * - * This becomes called only one time before a addon instance becomes created. - * If another instance becomes requested is this Create no more used. To see - * like a "int main()" on exe. - * - * @param[in] firstKodiInstance The first instance who becomes used. - * In case addon supports only one instance - * and not multiple together can addon use - * only one complete class for everything. - * This is used then to interact on interface. - * @return The status of addon after the creation. - */ - ADDON_STATUS Create(KODI_ADDON_INSTANCE_STRUCT* firstKodiInstance); - - /*! - * @brief Main addon destroying call function - * - * This becomes called only one time after the last addon instance becomes destroyed. - */ - void Destroy(); - - bool CheckAPIVersion(int type); - - BinaryAddonBasePtr m_binaryAddonBase = nullptr; - DllAddon* m_pDll = nullptr; - bool m_initialized = false; - bool LoadDll(); - std::map m_usedInstances; - CAddonDllInformer* m_informer = nullptr; - - virtual ADDON_STATUS TransferSettings(AddonInstanceId instanceId); - - /*! - * This structure, which is fixed to the addon headers, makes use of the at - * least supposed parts for the interface. - * This structure is defined in: - * /xbmc/addons/kodi-dev-kit/include/kodi/AddonBase.h - */ - AddonGlobalInterface m_interface = {}; -}; - -} /* namespace ADDON */ diff --git a/xbmc/addons/binary-addons/AddonInstanceHandler.cpp b/xbmc/addons/binary-addons/AddonInstanceHandler.cpp deleted file mode 100644 index b1576e592cd7c..0000000000000 --- a/xbmc/addons/binary-addons/AddonInstanceHandler.cpp +++ /dev/null @@ -1,380 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "AddonInstanceHandler.h" - -#include "ServiceBroker.h" -#include "addons/settings/AddonSettings.h" -#include "filesystem/Directory.h" -#include "filesystem/SpecialProtocol.h" -#include "utils/StringUtils.h" -#include "utils/log.h" - -#include - -namespace ADDON -{ - -CCriticalSection IAddonInstanceHandler::m_cdSec; - -IAddonInstanceHandler::IAddonInstanceHandler( - ADDON_TYPE type, - const AddonInfoPtr& addonInfo, - AddonInstanceId instanceId /* = ADDON_INSTANCE_ID_UNUSED */, - KODI_HANDLE parentInstance /* = nullptr*/, - const std::string& uniqueWorkID /* = ""*/) - : m_type(type), m_instanceId(instanceId), m_parentInstance(parentInstance), m_addonInfo(addonInfo) -{ - // if no special instance ID is given generate one from class pointer (is - // faster as unique id and also safe enough for them). - m_uniqueWorkID = !uniqueWorkID.empty() ? uniqueWorkID : StringUtils::Format("{}", fmt::ptr(this)); - m_addonBase = CServiceBroker::GetBinaryAddonManager().GetAddonBase(addonInfo, this, m_addon); - - KODI_ADDON_INSTANCE_INFO* info = new KODI_ADDON_INSTANCE_INFO(); - info->number = m_instanceId; // @todo change within next big API change to "instance_id" - info->id = m_uniqueWorkID.c_str(); // @todo change within next big API change to "unique_work_id" - info->version = kodi::addon::GetTypeVersion(m_type); - info->type = m_type; - info->kodi = this; - info->parent = m_parentInstance; - info->first_instance = m_addon && !m_addon->Initialized(); - info->functions = new KODI_ADDON_INSTANCE_FUNC_CB(); - info->functions->get_instance_user_path = get_instance_user_path; - info->functions->is_instance_setting_using_default = is_instance_setting_using_default; - info->functions->get_instance_setting_bool = get_instance_setting_bool; - info->functions->get_instance_setting_int = get_instance_setting_int; - info->functions->get_instance_setting_float = get_instance_setting_float; - info->functions->get_instance_setting_string = get_instance_setting_string; - info->functions->set_instance_setting_bool = set_instance_setting_bool; - info->functions->set_instance_setting_int = set_instance_setting_int; - info->functions->set_instance_setting_float = set_instance_setting_float; - info->functions->set_instance_setting_string = set_instance_setting_string; - m_ifc.info = info; - m_ifc.functions = new KODI_ADDON_INSTANCE_FUNC(); -} - -IAddonInstanceHandler::~IAddonInstanceHandler() -{ - CServiceBroker::GetBinaryAddonManager().ReleaseAddonBase(m_addonBase, this); - - delete m_ifc.functions; - if (m_ifc.info) - delete m_ifc.info->functions; - delete m_ifc.info; -} - -std::string IAddonInstanceHandler::ID() const -{ - return m_addon ? m_addon->ID() : ""; -} - -std::string IAddonInstanceHandler::Name() const -{ - return m_addon ? m_addon->Name() : ""; -} - -std::string IAddonInstanceHandler::Author() const -{ - return m_addon ? m_addon->Author() : ""; -} - -std::string IAddonInstanceHandler::Icon() const -{ - return m_addon ? m_addon->Icon() : ""; -} - -std::string IAddonInstanceHandler::Path() const -{ - return m_addon ? m_addon->Path() : ""; -} - -std::string IAddonInstanceHandler::Profile() const -{ - return m_addon ? m_addon->Profile() : ""; -} - -AddonVersion IAddonInstanceHandler::Version() const -{ - return m_addon ? m_addon->Version() : AddonVersion(); -} - -ADDON_STATUS IAddonInstanceHandler::CreateInstance() -{ - if (!m_addon) - return ADDON_STATUS_UNKNOWN; - - std::unique_lock lock(m_cdSec); - - ADDON_STATUS status = m_addon->CreateInstance(&m_ifc); - if (status != ADDON_STATUS_OK) - { - CLog::Log(LOGERROR, - "IAddonInstanceHandler::{}: {} returned bad status \"{}\" during instance creation", - __func__, m_addon->ID(), kodi::addon::TranslateAddonStatus(status)); - } - return status; -} - -void IAddonInstanceHandler::DestroyInstance() -{ - std::unique_lock lock(m_cdSec); - if (m_addon) - m_addon->DestroyInstance(&m_ifc); -} - -std::shared_ptr IAddonInstanceHandler::GetSetting(const std::string& setting) -{ - if (!m_addon->HasSettings(m_instanceId)) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - couldn't get settings for add-on '{}'", - __func__, Name()); - return nullptr; - } - - auto value = m_addon->GetSettings(m_instanceId)->GetSetting(setting); - if (value == nullptr) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - can't find setting '{}' in '{}'", __func__, - setting, Name()); - return nullptr; - } - - return value; -} - -char* IAddonInstanceHandler::get_instance_user_path(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) -{ - IAddonInstanceHandler* instance = static_cast(hdl); - if (!instance) - return nullptr; - - const std::string path = CSpecialProtocol::TranslatePath(instance->m_addon->Profile()); - - XFILE::CDirectory::Create(path); - return strdup(path.c_str()); -} - -bool IAddonInstanceHandler::is_instance_setting_using_default( - const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id) -{ - IAddonInstanceHandler* instance = static_cast(hdl); - if (!instance || !id) - return false; - - auto setting = instance->GetSetting(id); - if (setting == nullptr) - return false; - - return setting->IsDefault(); -} - -bool IAddonInstanceHandler::get_instance_setting_bool(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - bool* value) -{ - IAddonInstanceHandler* instance = static_cast(hdl); - if (!instance || !id || !value) - return false; - - auto setting = instance->GetSetting(id); - if (setting == nullptr) - return false; - - if (setting->GetType() != SettingType::Boolean) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - setting '{}' is not a boolean in '{}'", - __func__, id, instance->Name()); - return false; - } - - *value = std::static_pointer_cast(setting)->GetValue(); - return true; -} - -bool IAddonInstanceHandler::get_instance_setting_int(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - int* value) -{ - IAddonInstanceHandler* instance = static_cast(hdl); - if (!instance || !id || !value) - return false; - - auto setting = instance->GetSetting(id); - if (setting == nullptr) - return false; - - if (setting->GetType() != SettingType::Integer && setting->GetType() != SettingType::Number) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - setting '{}' is not a integer in '{}'", - __func__, id, instance->Name()); - return false; - } - - if (setting->GetType() == SettingType::Integer) - *value = std::static_pointer_cast(setting)->GetValue(); - else - *value = static_cast(std::static_pointer_cast(setting)->GetValue()); - return true; -} - -bool IAddonInstanceHandler::get_instance_setting_float(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - float* value) -{ - IAddonInstanceHandler* instance = static_cast(hdl); - if (!instance || !id || !value) - return false; - - auto setting = instance->GetSetting(id); - if (setting == nullptr) - return false; - - if (setting->GetType() != SettingType::Number) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - setting '{}' is not a number in '{}'", - __func__, id, instance->Name()); - return false; - } - - *value = static_cast(std::static_pointer_cast(setting)->GetValue()); - return true; -} - -bool IAddonInstanceHandler::get_instance_setting_string(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - char** value) -{ - IAddonInstanceHandler* instance = static_cast(hdl); - if (!instance || !id || !value) - return false; - - auto setting = instance->GetSetting(id); - if (setting == nullptr) - return false; - - if (setting->GetType() != SettingType::String) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - setting '{}' is not a string in '{}'", - __func__, id, instance->Name()); - return false; - } - - *value = strdup(std::static_pointer_cast(setting)->GetValue().c_str()); - return true; -} - -bool IAddonInstanceHandler::set_instance_setting_bool(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - bool value) -{ - IAddonInstanceHandler* instance = static_cast(hdl); - if (!instance || !id) - return false; - - if (Interface_Base::UpdateSettingInActiveDialog(instance->m_addon.get(), instance->m_instanceId, - id, value ? "true" : "false")) - return true; - - if (!instance->m_addon->UpdateSettingBool(id, value, instance->m_instanceId)) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid setting type", __func__); - return false; - } - - instance->m_addon->SaveSettings(instance->m_instanceId); - - return true; -} - -bool IAddonInstanceHandler::set_instance_setting_int(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - int value) -{ - IAddonInstanceHandler* instance = static_cast(hdl); - if (!instance || !id) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid data (instance='{}', id='{}')", - __func__, hdl, static_cast(id)); - - return false; - } - - if (Interface_Base::UpdateSettingInActiveDialog(instance->m_addon.get(), instance->m_instanceId, - id, std::to_string(value))) - return true; - - if (!instance->m_addon->UpdateSettingInt(id, value, instance->m_instanceId)) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid setting type", __func__); - return false; - } - - instance->m_addon->SaveSettings(instance->m_instanceId); - - return true; -} - -bool IAddonInstanceHandler::set_instance_setting_float(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - float value) -{ - IAddonInstanceHandler* instance = static_cast(hdl); - if (!instance || !id) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid data (instance='{}', id='{}')", - __func__, hdl, static_cast(id)); - - return false; - } - - if (Interface_Base::UpdateSettingInActiveDialog(instance->m_addon.get(), instance->m_instanceId, - id, StringUtils::Format("{:f}", value))) - return true; - - if (!instance->m_addon->UpdateSettingNumber(id, static_cast(value), - instance->m_instanceId)) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid setting type", __func__); - return false; - } - - instance->m_addon->SaveSettings(instance->m_instanceId); - - return true; -} - -bool IAddonInstanceHandler::set_instance_setting_string(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - const char* value) -{ - IAddonInstanceHandler* instance = static_cast(hdl); - if (!instance || !id || !value) - { - CLog::Log(LOGERROR, - "IAddonInstanceHandler::{} - invalid data (instance='{}', id='{}', value='{}')", - __func__, hdl, static_cast(id), static_cast(value)); - - return false; - } - - if (Interface_Base::UpdateSettingInActiveDialog(instance->m_addon.get(), instance->m_instanceId, - id, value)) - return true; - - if (!instance->m_addon->UpdateSettingString(id, value, instance->m_instanceId)) - { - CLog::Log(LOGERROR, "IAddonInstanceHandler::{} - invalid setting type", __func__); - return false; - } - - instance->m_addon->SaveSettings(instance->m_instanceId); - - return true; -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/binary-addons/AddonInstanceHandler.h b/xbmc/addons/binary-addons/AddonInstanceHandler.h deleted file mode 100644 index 6f2ed739140fd..0000000000000 --- a/xbmc/addons/binary-addons/AddonInstanceHandler.h +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "AddonDll.h" -#include "addons/AddonVersion.h" -#include "addons/kodi-dev-kit/include/kodi/AddonBase.h" - -#include - -class CSetting; - -namespace ADDON -{ - -class IAddonInstanceHandler -{ -public: - /** - * @brief Class constructor for handling add-on instance processes, allowing - * an add-on to handle multiple work simultaneously and independently. - * - * @param[in] type The associated add-on type which is processed in the running - * instance. - * @param[in] addonInfo Class for querying available add-on information (e.g. - * content declared in addon.xml). - * @param[in] parentInstance *[opt]* Above running add-on instance which starts this - * instance. Used to have the associated class for - * work to open in the add-on.\n\n - * **Currently used values:** - * | Parent | Target | Description - * |--------|--------|------------- - * | @ref kodi::addon::CInstanceInputStream | @ref kodi::addon::CInstanceVideoCodec | In order to be able to access the overlying input stream instance in the video codec created by Kodi on the add-on. - * @param[in] uniqueWorkID *[opt]* Identification value intended to pass any special - * values to the instance to be opened. - * If not used, the IAddonInstanceHandler class pointer - * is used as a string.\n\n - * **Currently used values:** - * | Add-on instance type | Description - * |----------------------|--------------------- - * | @ref kodi::addon::CInstanceInputStream "Inputstream" | To transfer special values to inputstream using the property @ref STREAM_PROPERTY_INPUTSTREAM_INSTANCE_ID from external space, for example PVR add-on which also supports inputstream can exchange special values with it, e.g. select the necessary add-on processing class, since it is not known at the start what is being executed ( live TV, radio, recordings...) and add-on may use different classes. - * | All other | The used class pointer of Kodi's @ref IAddonInstanceHandler is used as a value to have an individually different value. - */ - IAddonInstanceHandler(ADDON_TYPE type, - const AddonInfoPtr& addonInfo, - AddonInstanceId instanceId = ADDON_INSTANCE_ID_UNUSED, - KODI_HANDLE parentInstance = nullptr, - const std::string& uniqueWorkID = ""); - virtual ~IAddonInstanceHandler(); - - ADDON_TYPE UsedType() const { return m_type; } - AddonInstanceId InstanceId() const { return m_instanceId; } - const std::string& UniqueWorkID() { return m_uniqueWorkID; } - - std::string ID() const; - std::string Name() const; - std::string Author() const; - std::string Icon() const; - std::string Path() const; - std::string Profile() const; - AddonVersion Version() const; - - ADDON_STATUS CreateInstance(); - void DestroyInstance(); - const AddonDllPtr& Addon() const { return m_addon; } - AddonInfoPtr GetAddonInfo() const { return m_addonInfo; } - - virtual void OnPreInstall() {} - virtual void OnPostInstall(bool update, bool modal) {} - virtual void OnPreUnInstall() {} - virtual void OnPostUnInstall() {} - -protected: - KODI_ADDON_INSTANCE_INFO m_info{}; - KODI_ADDON_INSTANCE_STRUCT m_ifc{}; - -private: - std::shared_ptr GetSetting(const std::string& setting); - - static char* get_instance_user_path(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl); - static bool is_instance_setting_using_default(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id); - static bool get_instance_setting_bool(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - bool* value); - static bool get_instance_setting_int(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - int* value); - static bool get_instance_setting_float(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - float* value); - static bool get_instance_setting_string(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - char** value); - static bool set_instance_setting_bool(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - bool value); - static bool set_instance_setting_int(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - int value); - static bool set_instance_setting_float(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - float value); - static bool set_instance_setting_string(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - const char* value); - - const ADDON_TYPE m_type; - const AddonInstanceId m_instanceId; - std::string m_uniqueWorkID; - KODI_HANDLE m_parentInstance; - AddonInfoPtr m_addonInfo; - BinaryAddonBasePtr m_addonBase; - AddonDllPtr m_addon; - static CCriticalSection m_cdSec; -}; - -} /* namespace ADDON */ diff --git a/xbmc/addons/binary-addons/BinaryAddonBase.cpp b/xbmc/addons/binary-addons/BinaryAddonBase.cpp deleted file mode 100644 index 44ce3220b0292..0000000000000 --- a/xbmc/addons/binary-addons/BinaryAddonBase.cpp +++ /dev/null @@ -1,105 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "BinaryAddonBase.h" - -#include "utils/log.h" - -#include - -using namespace ADDON; - -const std::string& CBinaryAddonBase::ID() const -{ - return m_addonInfo->ID(); -} - -AddonDllPtr CBinaryAddonBase::GetAddon(IAddonInstanceHandler* handler) -{ - if (handler == nullptr) - { - CLog::Log(LOGERROR, "CBinaryAddonBase::{}: for Id '{}' called with empty instance handler", - __FUNCTION__, ID()); - return nullptr; - } - - std::unique_lock lock(m_critSection); - - // If no 'm_activeAddon' is defined create it new. - if (m_activeAddon == nullptr) - m_activeAddon = std::make_shared(m_addonInfo, shared_from_this()); - - // add the instance handler to the info to know used amount on addon - m_activeAddonHandlers.insert(handler); - - return m_activeAddon; -} - -void CBinaryAddonBase::ReleaseAddon(IAddonInstanceHandler* handler) -{ - if (handler == nullptr) - { - CLog::Log(LOGERROR, "CBinaryAddonBase::{}: for Id '{}' called with empty instance handler", - __FUNCTION__, ID()); - return; - } - - std::unique_lock lock(m_critSection); - - auto presentHandler = m_activeAddonHandlers.find(handler); - if (presentHandler == m_activeAddonHandlers.end()) - return; - - m_activeAddonHandlers.erase(presentHandler); - - // if no handler is present anymore reset and delete the add-on class on information - if (m_activeAddonHandlers.empty()) - { - m_activeAddon.reset(); - } -} - -size_t CBinaryAddonBase::UsedInstanceCount() const -{ - std::unique_lock lock(m_critSection); - return m_activeAddonHandlers.size(); -} - -AddonDllPtr CBinaryAddonBase::GetActiveAddon() -{ - std::unique_lock lock(m_critSection); - return m_activeAddon; -} - -void CBinaryAddonBase::OnPreInstall() -{ - const std::unordered_set activeAddonHandlers = m_activeAddonHandlers; - for (const auto& instance : activeAddonHandlers) - instance->OnPreInstall(); -} - -void CBinaryAddonBase::OnPostInstall(bool update, bool modal) -{ - const std::unordered_set activeAddonHandlers = m_activeAddonHandlers; - for (const auto& instance : activeAddonHandlers) - instance->OnPostInstall(update, modal); -} - -void CBinaryAddonBase::OnPreUnInstall() -{ - const std::unordered_set activeAddonHandlers = m_activeAddonHandlers; - for (const auto& instance : activeAddonHandlers) - instance->OnPreUnInstall(); -} - -void CBinaryAddonBase::OnPostUnInstall() -{ - const std::unordered_set activeAddonHandlers = m_activeAddonHandlers; - for (const auto& instance : activeAddonHandlers) - instance->OnPostUnInstall(); -} diff --git a/xbmc/addons/binary-addons/BinaryAddonBase.h b/xbmc/addons/binary-addons/BinaryAddonBase.h deleted file mode 100644 index 4027f9d71d152..0000000000000 --- a/xbmc/addons/binary-addons/BinaryAddonBase.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "AddonInstanceHandler.h" -#include "addons/addoninfo/AddonInfo.h" -#include "threads/CriticalSection.h" - -#include -#include -#include - -namespace ADDON -{ - - class IAddonInstanceHandler; - - class CAddonDll; - typedef std::shared_ptr AddonDllPtr; - - class CBinaryAddonBase : public std::enable_shared_from_this - { - public: - explicit CBinaryAddonBase(const AddonInfoPtr& addonInfo) : m_addonInfo(addonInfo) { } - - const std::string& ID() const; - - AddonDllPtr GetAddon(IAddonInstanceHandler* handler); - void ReleaseAddon(IAddonInstanceHandler* handler); - size_t UsedInstanceCount() const; - - AddonDllPtr GetActiveAddon(); - - void OnPreInstall(); - void OnPostInstall(bool update, bool modal); - void OnPreUnInstall(); - void OnPostUnInstall(); - - private: - AddonInfoPtr m_addonInfo; - - mutable CCriticalSection m_critSection; - AddonDllPtr m_activeAddon; - std::unordered_set m_activeAddonHandlers; - }; - -} /* namespace ADDON */ diff --git a/xbmc/addons/binary-addons/BinaryAddonManager.cpp b/xbmc/addons/binary-addons/BinaryAddonManager.cpp deleted file mode 100644 index 6593bc362394e..0000000000000 --- a/xbmc/addons/binary-addons/BinaryAddonManager.cpp +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "BinaryAddonManager.h" - -#include "BinaryAddonBase.h" -#include "utils/log.h" - -#include - -using namespace ADDON; - -BinaryAddonBasePtr CBinaryAddonManager::GetAddonBase(const AddonInfoPtr& addonInfo, - IAddonInstanceHandler* handler, - AddonDllPtr& addon) -{ - std::unique_lock lock(m_critSection); - - BinaryAddonBasePtr addonBase; - - const auto& addonInstances = m_runningAddons.find(addonInfo->ID()); - if (addonInstances != m_runningAddons.end()) - { - addonBase = addonInstances->second; - } - else - { - addonBase = std::make_shared(addonInfo); - - m_runningAddons.emplace(addonInfo->ID(), addonBase); - } - - if (addonBase) - { - addon = addonBase->GetAddon(handler); - } - if (!addon) - { - CLog::Log(LOGFATAL, "CBinaryAddonManager::{}: Tried to get add-on '{}' who not available!", - __func__, addonInfo->ID()); - } - - return addonBase; -} - -void CBinaryAddonManager::ReleaseAddonBase(const BinaryAddonBasePtr& addonBase, - IAddonInstanceHandler* handler) -{ - const auto& addon = m_runningAddons.find(addonBase->ID()); - if (addon == m_runningAddons.end()) - return; - - addonBase->ReleaseAddon(handler); - - if (addonBase->UsedInstanceCount() > 0) - return; - - m_runningAddons.erase(addon); -} - -BinaryAddonBasePtr CBinaryAddonManager::GetRunningAddonBase(const std::string& addonId) const -{ - std::unique_lock lock(m_critSection); - - const auto& addonInstances = m_runningAddons.find(addonId); - if (addonInstances != m_runningAddons.end()) - return addonInstances->second; - - return nullptr; -} - -AddonPtr CBinaryAddonManager::GetRunningAddon(const std::string& addonId) const -{ - std::unique_lock lock(m_critSection); - - const BinaryAddonBasePtr base = GetRunningAddonBase(addonId); - if (base) - return base->GetActiveAddon(); - - return nullptr; -} diff --git a/xbmc/addons/binary-addons/BinaryAddonManager.h b/xbmc/addons/binary-addons/BinaryAddonManager.h deleted file mode 100644 index a6328e175808d..0000000000000 --- a/xbmc/addons/binary-addons/BinaryAddonManager.h +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/AddonManager.h" -#include "threads/CriticalSection.h" - -#include - -namespace ADDON -{ - - class IAddonInstanceHandler; - - class CAddonDll; - typedef std::shared_ptr AddonDllPtr; - - class CBinaryAddonBase; - typedef std::shared_ptr BinaryAddonBasePtr; - - class CBinaryAddonManager - { - public: - CBinaryAddonManager() = default; - CBinaryAddonManager(const CBinaryAddonManager&) = delete; - ~CBinaryAddonManager() = default; - - /*! - * @brief Create or get available addon instance handle base. - * - * On first call the binary addon base class becomes created, on every next - * call of addon id, this becomes given again and a counter about in - * @ref CBinaryAddonBase increased. - * - * @param[in] addonBase related addon base to release - * @param[in] handler related instance handle class - * - * @warning This and @ref ReleaseAddonBase are only be called from - * @ref IAddonInstanceHandler, use nowhere else allowed! - * - */ - BinaryAddonBasePtr GetAddonBase(const AddonInfoPtr& addonInfo, - IAddonInstanceHandler* handler, - AddonDllPtr& addon); - - /*! - * @brief Release a running addon instance handle base. - * - * On last release call the here on map stored entry becomes - * removed and the dll unloaded. - * - * @param[in] addonBase related addon base to release - * @param[in] handler related instance handle class - * - */ - void ReleaseAddonBase(const BinaryAddonBasePtr& addonBase, IAddonInstanceHandler* handler); - - /*! - * @brief Get running addon base class for a given addon id. - * - * @param[in] addonId the addon id - * @return running addon base class if found, nullptr otherwise. - * - */ - BinaryAddonBasePtr GetRunningAddonBase(const std::string& addonId) const; - - /*! - * @brief Used from other addon manager to get active addon over a from him - * created CAddonDll. - * - * @param[in] addonId related addon id string - * @return if present the pointer to active one or nullptr if not present - * - */ - AddonPtr GetRunningAddon(const std::string& addonId) const; - - private: - mutable CCriticalSection m_critSection; - - std::map m_runningAddons; - }; - -} /* namespace ADDON */ diff --git a/xbmc/addons/binary-addons/CMakeLists.txt b/xbmc/addons/binary-addons/CMakeLists.txt deleted file mode 100644 index 33a72ce6b6a18..0000000000000 --- a/xbmc/addons/binary-addons/CMakeLists.txt +++ /dev/null @@ -1,12 +0,0 @@ -set(SOURCES BinaryAddonManager.cpp - AddonDll.cpp - AddonInstanceHandler.cpp - BinaryAddonBase.cpp) - -set(HEADERS BinaryAddonManager.h - AddonDll.h - AddonInstanceHandler.h - BinaryAddonBase.h - DllAddon.h) - -core_add_library(addons_binary-addons) diff --git a/xbmc/addons/binary-addons/DllAddon.h b/xbmc/addons/binary-addons/DllAddon.h deleted file mode 100644 index dbcf89301e3f6..0000000000000 --- a/xbmc/addons/binary-addons/DllAddon.h +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "DynamicDll.h" -#include "addons/kodi-dev-kit/include/kodi/AddonBase.h" - -class DllAddonInterface -{ -public: - virtual ~DllAddonInterface() = default; - virtual ADDON_STATUS Create(void* cb) = 0; - virtual const char* GetAddonTypeVersion(int type)=0; - virtual const char* GetAddonTypeMinVersion(int type) = 0; -}; - -class DllAddon : public DllDynamic, public DllAddonInterface -{ -public: - DECLARE_DLL_WRAPPER_TEMPLATE(DllAddon) - DEFINE_METHOD1(ADDON_STATUS, Create, (void* p1)) - DEFINE_METHOD1(const char*, GetAddonTypeVersion, (int p1)) - DEFINE_METHOD1(const char*, GetAddonTypeMinVersion, (int p1)) - bool GetAddonTypeMinVersion_available() { return m_GetAddonTypeMinVersion != nullptr; } - BEGIN_METHOD_RESOLVE() - RESOLVE_METHOD_RENAME(ADDON_Create, Create) - RESOLVE_METHOD_RENAME(ADDON_GetTypeVersion, GetAddonTypeVersion) - RESOLVE_METHOD_RENAME_OPTIONAL(ADDON_GetTypeMinVersion, GetAddonTypeMinVersion) - END_METHOD_RESOLVE() -}; - diff --git a/xbmc/addons/interface/CMakeLists.txt b/xbmc/addons/interface/CMakeLists.txt new file mode 100644 index 0000000000000..f98a4dbf5f36a --- /dev/null +++ b/xbmc/addons/interface/CMakeLists.txt @@ -0,0 +1,26 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + Controller.cpp + IMsgHdl.cpp + IOffscreenRenderProcess.cpp + InstanceHandler.cpp + Interface.cpp + RunningProcess.cpp + RunningThread.cpp +) + +set(HEADERS + Controller.h + IMsgHdl.h + IOffscreenRenderProcess.h + InstanceHandler.h + Interface.h + RunningProcess.h + RunningThread.h +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface) +endif() diff --git a/xbmc/addons/interface/Controller.cpp b/xbmc/addons/interface/Controller.cpp new file mode 100644 index 0000000000000..fd02205fcc3a6 --- /dev/null +++ b/xbmc/addons/interface/Controller.cpp @@ -0,0 +1,308 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "Controller.h" + +#include "AppParams.h" +#include "Application.h" +#include "CompileInfo.h" +#include "ServiceBroker.h" +#include "addons/interface/RunningProcess.h" +#include "addons/interface/gui/GUIDialogCrashReporter.h" +#include "filesystem/Directory.h" +#include "filesystem/File.h" +#include "filesystem/SpecialProtocol.h" +#include "settings/AdvancedSettings.h" +#include "settings/SettingsComponent.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/log.h" + +#include + +using namespace std::chrono_literals; + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +CController::CController(ADDON::CAddonMgr& addonMgr) + : CThread("KODI::ADDONS::INTERFACE::CController"), + m_addonMgr(addonMgr), + m_devkitPath(CSpecialProtocol::TranslatePath("special://xbmcbinaddons/kodi.binary.devkit/")), + m_devkitLib(CSpecialProtocol::TranslatePath( + "special://xbmcbinaddons/kodi.binary.devkit/" DEVKIT_LIBRARY)), + m_devkitLaunchExe(CSpecialProtocol::TranslatePath( + "special://xbmcbinaddons/kodi.binary.devkit/" DEVKIT_LAUNCH_EXE)), + m_devkitReportPath(CSpecialProtocol::TranslatePath("special://temp")) +{ +} + +CController::~CController() +{ + Deinit(); +} + +bool CController::Init() +{ + using namespace XFILE; + + if (!CFile::Exists(m_devkitLib, false)) + { + CLog::Log(LOGFATAL, "Needed DevKit library {} not present!", m_devkitLib); + return false; + } + if (!CFile::Exists(m_devkitLaunchExe, false)) + { + CLog::Log(LOGFATAL, "Needed DevKit help launch executable {} not present!", m_devkitLaunchExe); + return false; + } + + CThread::Create(); + m_running = true; + m_onSystemStop = false; + return true; +} + +void CController::Deinit() +{ + if (m_running) + { + m_running = false; + CThread::StopThread(); + } +} + +void CController::StopReport() +{ + std::unique_lock lock(m_lock); + m_onSystemStop = true; +} + +bool CController::AddonLanguageSupported(const std::shared_ptr& addon) const +{ + if (addon->Type(addon->Type())->Language() != ADDON::AddonLanguage::Unknown) + return true; + return false; +} + +bool CController::LaunchAddon(const std::shared_ptr& addon, + std::vector& argv, + bool waitForExit, + std::shared_ptr& process) +{ + std::shared_ptr newProcess; + { + std::unique_lock lock(m_lock); + newProcess = std::make_shared( + addon, "kodi-subproc-" + StringUtils::CreateUUID(), CheckNoSandboxUsage(addon), nullptr); + m_runningProcesses.emplace(addon->ID(), newProcess); + } + + if (!newProcess->Launch(argv, waitForExit)) + { + return false; + } + + if (waitForExit) + { + std::unique_lock lock(m_lock); + m_runningProcesses.erase(newProcess->GetAddonID()); + } + + process = newProcess; + return true; +} + +std::shared_ptr CController::GetAddonProcess( + const std::shared_ptr& addonInfo, + IInstanceHandler* handler, + const KODI_ADDON_INSTANCE_INFO* firstInstance, + std::shared_ptr& addon) +{ + + std::shared_ptr newProcess; + + { + std::unique_lock lock(m_lock); + + const auto& addonInstances = m_runningProcesses.find(addonInfo->ID()); + if (addonInstances != m_runningProcesses.end()) + { + newProcess = addonInstances->second; + addon = newProcess->GetAddon(); + } + else + { + addon = std::make_shared(addonInfo, addonInfo->MainType()); + newProcess = + std::make_shared(addon, "kodi-subproc-" + StringUtils::CreateUUID(), + CheckNoSandboxUsage(addon), firstInstance); + std::vector argv; + if (!newProcess->Launch(argv, false)) + { + return nullptr; + } + + m_runningProcesses.emplace(addonInfo->ID(), newProcess); + } + } + + newProcess->SetEndtime(3000); + newProcess->AddAddonInstance(handler); + + if (!addon) + { + CLog::Log(LOGFATAL, "CController:{}: Tried to get add-on '{}' who not available!", __func__, + addonInfo->ID()); + } + + return newProcess; +} + +void CController::ReleaseAddonProcess(const std::shared_ptr& process, + IInstanceHandler* handler) +{ + std::unique_lock lock(m_lock); + + const auto& addon = m_runningProcesses.find(process->GetAddonID()); + if (addon == m_runningProcesses.end()) + return; + + process->ReleaseAddonInstance(handler); + + if (process->UsedInstanceCount() > 0) + return; + + if (!process->UseEndTime()) + { + process->Kill(); + + m_runningProcesses.erase(addon); + } +} + +std::shared_ptr CController::GetRunningAddonProcess( + const std::string& addonId) const +{ + std::unique_lock lock(m_lock); + + const auto& addonInstances = m_runningProcesses.find(addonId); + if (addonInstances != m_runningProcesses.end()) + return addonInstances->second; + + return nullptr; +} + +std::shared_ptr CController::GetRunningAddon(const std::string& addonId) const +{ + const std::shared_ptr process = GetRunningAddonProcess(addonId); + if (process) + return process->GetAddon(); + + return nullptr; +} + +std::vector CController::GetProcessInfoData() +{ + std::vector data; + + std::unique_lock lock(m_lock); + + for (const auto& process : m_runningProcesses) + { + data.emplace_back(process.second->GetProcessInfoData()); + } + + return data; +} + +void CController::Process() +{ + while (!m_bStop) + { + CThread::Sleep(500ms); + + std::unique_lock lock(m_lock); + + for (auto it = m_runningProcesses.cbegin(); it != m_runningProcesses.cend();) + { + /* + * Check the addon stopped itself, e.g. by normal way or with a crash. + */ + const ChildStatus status = it->second->ProcessActive(); + if (status != ChildStatus::Running) + { + const auto addonId = it->second->GetAddonID(); + + CLog::Log(LOGFATAL, "CController::{}: Addon '{}' process was uncontrolled stopped!", + __func__, addonId); + it->second->InformStopReport(status); + it->second->Kill(); + + const auto uuid = it->second->GetUUID(); + const auto stacktrace = it->second->GetStackTrace(); + + m_runningProcesses.erase(it++); + + /* + * Check for case user interrupt Kodi with a e.g. Strg+C + * and not start a GUI in this case! + */ + if (!m_onSystemStop) + { + // Show Dialog with a non blocking call and to have this thread further available + MESSAGING::HELPERS::ShowReportCrashDialog(std::move(addonId), std::move(uuid), std::move(stacktrace)); + } + continue; + } + + /* + * Check run of addon, if it is ununsed a amount of time do a stop of it. + * This mainly relates to addons where processed by Kodi, e.g. PVR, audiodecoder + * and so on related addons. + */ + if (it->second->UseEndTime() && !it->second->IsInUse()) + { + if (it->second->EndTimeLeft() == 0ms) + { + CLog::Log(LOGDEBUG, + "CController::{}: Addon '{}' process was inactive and becomes stopped", + __func__, it->second->GetAddonID()); + it->second->Kill(); + m_runningProcesses.erase(it++); + continue; + } + } + + it++; + } + } +} + +bool CController::CheckNoSandboxUsage(const std::shared_ptr& addon) +{ + if (CServiceBroker::GetAppParams()->IsNoSandbox()) + return true; + + const std::string path = addon->Type(addon->MainType())->LibPath(); + if (URIUtils::IsSharedLibrarySuffix(path)) + { + const auto advanced = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings(); + return !advanced->m_addonsSimulateBinaryLibAsExe; + } + + return false; +} + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/Controller.h b/xbmc/addons/interface/Controller.h new file mode 100644 index 0000000000000..cfde17a1d7d70 --- /dev/null +++ b/xbmc/addons/interface/Controller.h @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "Interface.h" +#include "processinfo/ProcessInfo.h" +#include "threads/Thread.h" + +#include +#include +#include +#include +#include + +namespace ADDON +{ +class CAddonInfo; +class CAddonMgr; +class IAddon; +} /* namespace ADDON */ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CRunningProcess; +class IInstanceHandler; + +class CController : private CThread +{ +public: + CController(ADDON::CAddonMgr& addonMgr); + ~CController(); + + bool Init(); + void Deinit(); + void StopReport(); + + bool AddonLanguageSupported(const std::shared_ptr& addon) const; + bool LaunchAddon(const std::shared_ptr& addon, + std::vector& argv, + bool waitForExit, + std::shared_ptr& process); + std::shared_ptr GetAddonProcess( + const std::shared_ptr& addonInfo, + IInstanceHandler* handler, + const KODI_ADDON_INSTANCE_INFO* firstInstance, + std::shared_ptr& addon); + void ReleaseAddonProcess(const std::shared_ptr& process, + IInstanceHandler* handler); + std::shared_ptr GetRunningAddonProcess(const std::string& addonId) const; + std::shared_ptr GetRunningAddon(const std::string& addonId) const; + + std::vector GetProcessInfoData(); + const std::string& GetDevkitPath() const { return m_devkitPath; } + const std::string& GetDevkitLibPath() const { return m_devkitLib; } + const std::string& GetDevkitLaunchExe() const { return m_devkitLaunchExe; } + const std::string& GetDevkitReportPath() const { return m_devkitReportPath; } + +private: + void Process() override; + + bool CheckNoSandboxUsage(const std::shared_ptr& addon); + + ADDON::CAddonMgr& m_addonMgr; + const std::string m_devkitPath; + const std::string m_devkitLib; + const std::string m_devkitLaunchExe; + const std::string m_devkitReportPath; + std::atomic_bool m_running{false}; + bool m_onSystemStop{false}; + mutable std::mutex m_lock; + std::map> m_runningProcesses; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/IMsgHdl.cpp b/xbmc/addons/interface/IMsgHdl.cpp new file mode 100644 index 0000000000000..98b8f6f301a60 --- /dev/null +++ b/xbmc/addons/interface/IMsgHdl.cpp @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2020 Team Kodi (https://kodi.tv) + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSE.md for more information. + */ + +#include "IMsgHdl.h" + +#include "RunningProcess.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +IMsgHdl::IMsgHdl(CInterface& interface) : m_interface(interface), m_process(interface.m_process) +{ +} + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/IMsgHdl.h b/xbmc/addons/interface/IMsgHdl.h new file mode 100644 index 0000000000000..55d5874a61f79 --- /dev/null +++ b/xbmc/addons/interface/IMsgHdl.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2020 Team Kodi (https://kodi.tv) + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSE.md for more information. + */ + +#pragma once + +#include "../../addons/addoninfo/AddonInfo.h" + +#include + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CInterface; +class CRunningProcess; + +class IMsgHdl +{ +public: + IMsgHdl(CInterface& interface); + virtual ~IMsgHdl() = default; + + virtual bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) = 0; + +protected: + CInterface& m_interface; + CRunningProcess* const m_process; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/IOffscreenRenderProcess.cpp b/xbmc/addons/interface/IOffscreenRenderProcess.cpp new file mode 100644 index 0000000000000..1bf42832c0efb --- /dev/null +++ b/xbmc/addons/interface/IOffscreenRenderProcess.cpp @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "IOffscreenRenderProcess.h" +#include "addons/interface/RunningProcess.h" +#include "utils/StringUtils.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +namespace +{ +static uint64_t nextUsableId = 0; +} /* namespace */ + +IOffscreenRenderProcess::IOffscreenRenderProcess() + : m_usedId(nextUsableId++) +{ +} + +bool IOffscreenRenderProcess::CreateRenderHelper(CRunningProcess* process) +{ + if (m_renderHelper) + return true; + + const std::string id = StringUtils::Format("{}-{:04}", process->GetUUID(), m_usedId); + m_renderHelper = std::make_unique(id); + return true; +} + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/IOffscreenRenderProcess.h b/xbmc/addons/interface/IOffscreenRenderProcess.h new file mode 100644 index 0000000000000..5157151bed480 --- /dev/null +++ b/xbmc/addons/interface/IOffscreenRenderProcess.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "addons/interface/renderer/IRenderHelper.h" +#include "addons/kodi-dev-kit/src/shared/SharedGL.h" +#include "addons/kodi-dev-kit/include/kodi/c-api/addon_base.h" + +#include + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CRunningProcess; + +class IOffscreenRenderProcess +{ +public: + IOffscreenRenderProcess(); + virtual ~IOffscreenRenderProcess() = default; + virtual bool GetOffscreenRenderInfos(int& x, int& y, int& width, int& height, ADDON_HARDWARE_CONTEXT& context) = 0; + + uint64_t GetUsedId() const { return m_usedId; } + void SetAddonOffscreenHdl(uint64_t hdl) { m_addonHdl = hdl; } + uint64_t GetAddonOffscreenHdl() const { return m_addonHdl; } + bool CreateRenderHelper(CRunningProcess* process); + IRenderHelper* GetRenderHelper() { return m_renderHelper.get(); } + +private: + const uint64_t m_usedId; + uint64_t m_addonHdl{0}; + + std::unique_ptr m_renderHelper; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/InstanceHandler.cpp b/xbmc/addons/interface/InstanceHandler.cpp new file mode 100644 index 0000000000000..6e23c36949f30 --- /dev/null +++ b/xbmc/addons/interface/InstanceHandler.cpp @@ -0,0 +1,323 @@ +/* + * Copyright (C) 2005-2021 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "InstanceHandler.h" + +#include "ServiceBroker.h" +#include "addons/interface/Controller.h" +#include "addons/interface/api/addon_base.h" +#include "addons/settings/AddonSettings.h" +#include "filesystem/Directory.h" +#include "filesystem/SpecialProtocol.h" +#include "utils/StringUtils.h" +#include "utils/log.h" + +using namespace ADDON; +using namespace KODI::ADDONS::INTERFACE; + +std::mutex IInstanceHandler::m_cdSec; + +IInstanceHandler::IInstanceHandler(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_ADDON_INSTANCE_TYPE type, + const AddonInfoPtr& addonInfo, + AddonInstanceId instanceId /* = ADDON_INSTANCE_ID_UNUSED */, + KODI_HANDLE parentInstance /* = nullptr*/, + const std::string& uniqueWorkID /* = ""*/) + : m_type(type), m_instanceId(instanceId), m_parentInstance(parentInstance), m_addonInfo(addonInfo) +{ + // if no special instance ID is given generate one from class pointer (is + // faster as unique id and also safe enough for them). + m_uniqueWorkID = !uniqueWorkID.empty() ? uniqueWorkID : StringUtils::Format("{}", fmt::ptr(this)); + + m_info.instance_id = instanceId; + m_info.unique_work_id = m_uniqueWorkID.c_str(); + m_info.type = m_type; + m_info.kodi = hdl; + m_info.parent = m_parentInstance; +} + +IInstanceHandler::~IInstanceHandler() +{ +} + +std::string IInstanceHandler::ID() const +{ + return m_addonInfo ? m_addonInfo->ID() : ""; +} + +std::string IInstanceHandler::Name() const +{ + return m_addonInfo ? m_addonInfo->Name() : ""; +} + +std::string IInstanceHandler::Author() const +{ + return m_addonInfo ? m_addonInfo->Author() : ""; +} + +std::string IInstanceHandler::Icon() const +{ + return m_addonInfo ? m_addonInfo->Icon() : ""; +} + +std::string IInstanceHandler::Path() const +{ + return m_addonInfo ? m_addonInfo->Path() : ""; +} + +std::string IInstanceHandler::Profile() const +{ + return m_addonInfo ? m_addonInfo->ProfilePath() : ""; +} + +AddonVersion IInstanceHandler::Version() const +{ + return m_addonInfo ? m_addonInfo->Version() : AddonVersion(); +} + +ADDON_STATUS IInstanceHandler::CreateInstance() +{ + m_process = + CServiceBroker::GetAddonIfcCtrl().GetAddonProcess(m_addonInfo, this, &m_info, m_addon); + if (!m_process) + { + CLog::Log(LOGERROR, + "IInstanceHandler::{}: {} failed to get addon process during instance creation", + __func__, m_addonInfo->ID()); + return ADDON_STATUS_UNKNOWN; + } + m_ifc = &m_process->GetIfc(); + + if (!m_addon || !m_ifc) + return ADDON_STATUS_UNKNOWN; + + std::unique_lock lock(m_cdSec); + + ADDON_STATUS status = m_ifc->kodi_addon_base_h->kodi_addon_create_instance_v1( + m_process->m_hdl, &m_info, &m_instance); + if (status != ADDON_STATUS_OK) + { + CLog::Log(LOGERROR, + "IInstanceHandler::{}: {} returned bad status \"{}\" during instance creation", + __func__, m_addonInfo->ID(), status); + } + return status; +} + +void IInstanceHandler::DestroyInstance() +{ + std::unique_lock lock(m_cdSec); + if (m_addon && m_ifc) + { + m_ifc->kodi_addon_base_h->kodi_addon_destroy_instance_v1(m_process->m_hdl, &m_info, m_instance); + m_ifc = nullptr; + } + + CServiceBroker::GetAddonIfcCtrl().ReleaseAddonProcess(m_process, this); + m_process = nullptr; +} + +std::shared_ptr IInstanceHandler::GetSetting(const std::string& setting) +{ + if (!m_addon->HasSettings()) + { + CLog::Log(LOGERROR, "IInstanceHandler::{} - couldn't get settings for add-on '{}'", __func__, + Name()); + return nullptr; + } + + auto value = m_addon->GetSettings()->GetSetting(setting); + if (value == nullptr) + { + CLog::Log(LOGERROR, "IInstanceHandler::{} - can't find setting '{}' in '{}'", __func__, setting, + Name()); + return nullptr; + } + + return value; +} + +char* IInstanceHandler::get_instance_user_path() +{ + const std::string path = CSpecialProtocol::TranslatePath(m_addon->Profile()); + + XFILE::CDirectory::Create(path); + return strdup(path.c_str()); +} + +bool IInstanceHandler::is_instance_setting_using_default(const char* id) +{ + if (!id) + return false; + + auto setting = GetSetting(id); + if (setting == nullptr) + return false; + + return setting->IsDefault(); +} + +bool IInstanceHandler::get_instance_setting_bool(const char* id, bool* value) +{ + if (!id || !value) + return false; + + auto setting = GetSetting(id); + if (setting == nullptr) + return false; + + if (setting->GetType() != SettingType::Boolean) + { + CLog::Log(LOGERROR, "IInstanceHandler::{} - setting '{}' is not a boolean in '{}'", __func__, + id, Name()); + return false; + } + + *value = std::static_pointer_cast(setting)->GetValue(); + return true; +} + +bool IInstanceHandler::get_instance_setting_int(const char* id, int* value) +{ + if (!id || !value) + return false; + + auto setting = GetSetting(id); + if (setting == nullptr) + return false; + + if (setting->GetType() != SettingType::Integer && setting->GetType() != SettingType::Number) + { + CLog::Log(LOGERROR, "IInstanceHandler::{} - setting '{}' is not a integer in '{}'", __func__, + id, Name()); + return false; + } + + if (setting->GetType() == SettingType::Integer) + *value = std::static_pointer_cast(setting)->GetValue(); + else + *value = static_cast(std::static_pointer_cast(setting)->GetValue()); + return true; +} + +bool IInstanceHandler::get_instance_setting_float(const char* id, double* value) +{ + if (!id || !value) + return false; + + auto setting = GetSetting(id); + if (setting == nullptr) + return false; + + if (setting->GetType() != SettingType::Number) + { + CLog::Log(LOGERROR, "IInstanceHandler::{} - setting '{}' is not a number in '{}'", __func__, id, + Name()); + return false; + } + + *value = std::static_pointer_cast(setting)->GetValue(); + return true; +} + +bool IInstanceHandler::get_instance_setting_string(const char* id, char** value) +{ + if (!id || !value) + return false; + + auto setting = GetSetting(id); + if (setting == nullptr) + return false; + + if (setting->GetType() != SettingType::String) + { + CLog::Log(LOGERROR, "IInstanceHandler::{} - setting '{}' is not a string in '{}'", __func__, id, + Name()); + return false; + } + + *value = strdup(std::static_pointer_cast(setting)->GetValue().c_str()); + return true; +} + +bool IInstanceHandler::set_instance_setting_bool(const char* id, bool value) +{ + if (!id) + return false; + + if (CHdl_kodi_addon_base_h::UpdateSettingInActiveDialog(ID(), id, value ? "true" : "false")) + return true; + + if (!m_addon->UpdateSettingBool(id, value)) + { + CLog::Log(LOGERROR, "IInstanceHandler::{} - invalid setting type", __func__); + return false; + } + + m_addon->SaveSettings(); + + return true; +} + +bool IInstanceHandler::set_instance_setting_int(const char* id, int value) +{ + if (!id) + return false; + + if (CHdl_kodi_addon_base_h::UpdateSettingInActiveDialog(ID(), id, std::to_string(value))) + return true; + + if (!m_addon->UpdateSettingInt(id, value)) + { + CLog::Log(LOGERROR, "IInstanceHandler::{} - invalid setting type", __func__); + return false; + } + + m_addon->SaveSettings(); + + return true; +} + +bool IInstanceHandler::set_instance_setting_float(const char* id, double value) +{ + if (!id) + return false; + + if (CHdl_kodi_addon_base_h::UpdateSettingInActiveDialog(ID(), id, + StringUtils::Format("{:f}", value))) + return true; + + if (!m_addon->UpdateSettingNumber(id, static_cast(value))) + { + CLog::Log(LOGERROR, "IInstanceHandler::{} - invalid setting type", __func__); + return false; + } + + m_addon->SaveSettings(); + + return true; +} + +bool IInstanceHandler::set_instance_setting_string(const char* id, const char* value) +{ + if (!id || !value) + return false; + + if (CHdl_kodi_addon_base_h::UpdateSettingInActiveDialog(ID(), id, value)) + return true; + + if (!m_addon->UpdateSettingString(id, value)) + { + CLog::Log(LOGERROR, "IInstanceHandler::{} - invalid setting type", __func__); + return false; + } + + m_addon->SaveSettings(); + + return true; +} diff --git a/xbmc/addons/interface/InstanceHandler.h b/xbmc/addons/interface/InstanceHandler.h new file mode 100644 index 0000000000000..299b9781a27ce --- /dev/null +++ b/xbmc/addons/interface/InstanceHandler.h @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2005-2021 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "RunningProcess.h" +#include "addons/AddonVersion.h" +#include "addons/IAddon.h" +#include "addons/kodi-dev-kit/include/kodi/c-api/addon_base.h" + +#include +#include + +class CSetting; + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CInterface; +typedef void* ADDON_HANDLE; +typedef void* KODI_HANDLE; + +class IInstanceHandler +{ +public: + IInstanceHandler(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_ADDON_INSTANCE_TYPE type, + const std::shared_ptr& addonInfo, + ADDON::AddonInstanceId instanceId = ADDON::ADDON_INSTANCE_ID_UNUSED, + ADDON_HANDLE parentInstance = nullptr, + const std::string& uniqueWorkID = ""); + virtual ~IInstanceHandler(); + + KODI_ADDON_INSTANCE_TYPE UsedType() const { return m_type; } + ADDON::AddonInstanceId InstanceId() const { return m_instanceId; } + const std::string& UniqueWorkID() { return m_uniqueWorkID; } + + std::string ID() const; + std::string Name() const; + std::string Author() const; + std::string Icon() const; + std::string Path() const; + std::string Profile() const; + ADDON::AddonVersion Version() const; + + ADDON_STATUS CreateInstance(); + void DestroyInstance(); + const std::shared_ptr& Addon() const { return m_addon; } + const std::shared_ptr& GetAddonInfo() const { return m_addonInfo; } + const std::shared_ptr& GetProcess() const { return m_process; } + const KODI_ADDON_INSTANCE_INFO* GetCInfo() const { return &m_info; } + + virtual void StopReport(ChildStatus status) {} + virtual void OnPreInstall() {} + virtual void OnPostInstall(bool update, bool modal) {} + virtual void OnPreUnInstall() {} + virtual void OnPostUnInstall() {} + + char* get_instance_user_path(); + /*---AUTO_GEN_PARSE---*/ + bool is_instance_setting_using_default(const char* id); + /*---AUTO_GEN_PARSE---*/ + bool get_instance_setting_bool(const char* id, bool* value); + /*---AUTO_GEN_PARSE---*/ + bool get_instance_setting_int(const char* id, int* value); + /*---AUTO_GEN_PARSE---*/ + bool get_instance_setting_float(const char* id, double* value); + /*---AUTO_GEN_PARSE---*/ + bool get_instance_setting_string(const char* id, char** value); + /*---AUTO_GEN_PARSE---*/ + bool set_instance_setting_bool(const char* id, bool value); + /*---AUTO_GEN_PARSE---*/ + bool set_instance_setting_int(const char* id, int value); + /*---AUTO_GEN_PARSE---*/ + bool set_instance_setting_float(const char* id, double value); + /*---AUTO_GEN_PARSE---*/ + bool set_instance_setting_string(const char* id, const char* value); + /*---AUTO_GEN_PARSE---*/ + +protected: + CInterface* m_ifc; + KODI_ADDON_INSTANCE_INFO m_info{}; + KODI_HANDLE m_instance{}; + +private: + std::shared_ptr GetSetting(const std::string& setting); + + const KODI_ADDON_INSTANCE_TYPE m_type; + const ADDON::AddonInstanceId m_instanceId; + std::string m_uniqueWorkID; + ADDON_HANDLE m_parentInstance; + std::shared_ptr m_process; + std::shared_ptr m_addonInfo; + std::shared_ptr m_addon; + static std::mutex m_cdSec; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/Interface.cpp b/xbmc/addons/interface/Interface.cpp new file mode 100644 index 0000000000000..1b03424d36061 --- /dev/null +++ b/xbmc/addons/interface/Interface.cpp @@ -0,0 +1,274 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "Interface.h" + +#include "addons/kodi-dev-kit/src/shared/DirectData.h" + +/*---AUTO_GEN_PARSE---*/ +#include "api/addon-instance/audiodecoder.h" +#include "api/addon-instance/audioencoder.h" +#include "api/addon-instance/game.h" +#include "api/addon-instance/imagedecoder.h" +#include "api/addon-instance/inputstream.h" +#include "api/addon-instance/peripheral.h" +#include "api/addon-instance/pvr.h" +#include "api/addon-instance/screensaver.h" +#include "api/addon-instance/vfs.h" +#include "api/addon-instance/videocodec.h" +#include "api/addon-instance/visualization.h" +#include "api/addon-instance/web.h" +#include "api/addon_base.h" +#include "api/audio_engine.h" +#include "api/filesystem.h" +#include "api/general.h" +#include "api/gui/controls/button.h" +#include "api/gui/controls/edit.h" +#include "api/gui/controls/fade_label.h" +#include "api/gui/controls/image.h" +#include "api/gui/controls/label.h" +#include "api/gui/controls/progress.h" +#include "api/gui/controls/radio_button.h" +#include "api/gui/controls/rendering.h" +#include "api/gui/controls/settings_slider.h" +#include "api/gui/controls/slider.h" +#include "api/gui/controls/spin.h" +#include "api/gui/controls/text_box.h" +#include "api/gui/dialogs/context_menu.h" +#include "api/gui/dialogs/extended_progress.h" +#include "api/gui/dialogs/filebrowser.h" +#include "api/gui/dialogs/keyboard.h" +#include "api/gui/dialogs/numeric.h" +#include "api/gui/dialogs/ok.h" +#include "api/gui/dialogs/progress.h" +#include "api/gui/dialogs/select.h" +#include "api/gui/dialogs/text_viewer.h" +#include "api/gui/dialogs/yes_no.h" +#include "api/gui/general.h" +#include "api/gui/list_item.h" +#include "api/gui/window.h" +#include "api/monitor.h" +#include "api/network.h" +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +CInterface::CInterface(CRunningProcess* process, bool directDll) + : m_process(process), + m_directIfc(directDll ? std::make_unique() : nullptr), + m_directDll(directDll) +{ + /*---AUTO_GEN_PARSE---*/ + kodi_addon_base_h = new CHdl_kodi_addon_base_h(*this); + m_handlers[funcGroup_addon_base_h] = kodi_addon_base_h; + kodi_audio_engine_h = new CHdl_kodi_audio_engine_h(*this); + m_handlers[funcGroup_audio_engine_h] = kodi_audio_engine_h; + kodi_filesystem_h = new CHdl_kodi_filesystem_h(*this); + m_handlers[funcGroup_filesystem_h] = kodi_filesystem_h; + kodi_general_h = new CHdl_kodi_general_h(*this); + m_handlers[funcGroup_general_h] = kodi_general_h; + kodi_monitor_h = new CHdl_kodi_monitor_h(*this); + m_handlers[funcGroup_monitor_h] = kodi_monitor_h; + kodi_network_h = new CHdl_kodi_network_h(*this); + m_handlers[funcGroup_network_h] = kodi_network_h; + kodi_addoninstance_audiodecoder_h = new CHdl_kodi_addoninstance_audiodecoder_h(*this); + m_handlers[funcGroup_addoninstance_audiodecoder_h] = kodi_addoninstance_audiodecoder_h; + kodi_addoninstance_audioencoder_h = new CHdl_kodi_addoninstance_audioencoder_h(*this); + m_handlers[funcGroup_addoninstance_audioencoder_h] = kodi_addoninstance_audioencoder_h; + kodi_addoninstance_game_h = new CHdl_kodi_addoninstance_game_h(*this); + m_handlers[funcGroup_addoninstance_game_h] = kodi_addoninstance_game_h; + kodi_addoninstance_imagedecoder_h = new CHdl_kodi_addoninstance_imagedecoder_h(*this); + m_handlers[funcGroup_addoninstance_imagedecoder_h] = kodi_addoninstance_imagedecoder_h; + kodi_addoninstance_inputstream_h = new CHdl_kodi_addoninstance_inputstream_h(*this); + m_handlers[funcGroup_addoninstance_inputstream_h] = kodi_addoninstance_inputstream_h; + kodi_addoninstance_peripheral_h = new CHdl_kodi_addoninstance_peripheral_h(*this); + m_handlers[funcGroup_addoninstance_peripheral_h] = kodi_addoninstance_peripheral_h; + kodi_addoninstance_pvr_h = new CHdl_kodi_addoninstance_pvr_h(*this); + m_handlers[funcGroup_addoninstance_pvr_h] = kodi_addoninstance_pvr_h; + kodi_addoninstance_screensaver_h = new CHdl_kodi_addoninstance_screensaver_h(*this); + m_handlers[funcGroup_addoninstance_screensaver_h] = kodi_addoninstance_screensaver_h; + kodi_addoninstance_vfs_h = new CHdl_kodi_addoninstance_vfs_h(*this); + m_handlers[funcGroup_addoninstance_vfs_h] = kodi_addoninstance_vfs_h; + kodi_addoninstance_videocodec_h = new CHdl_kodi_addoninstance_videocodec_h(*this); + m_handlers[funcGroup_addoninstance_videocodec_h] = kodi_addoninstance_videocodec_h; + kodi_addoninstance_visualization_h = new CHdl_kodi_addoninstance_visualization_h(*this); + m_handlers[funcGroup_addoninstance_visualization_h] = kodi_addoninstance_visualization_h; + kodi_addoninstance_web_h = new CHdl_kodi_addoninstance_web_h(*this); + m_handlers[funcGroup_addoninstance_web_h] = kodi_addoninstance_web_h; + kodi_gui_general_h = new CHdl_kodi_gui_general_h(*this); + m_handlers[funcGroup_gui_general_h] = kodi_gui_general_h; + kodi_gui_list_item_h = new CHdl_kodi_gui_list_item_h(*this); + m_handlers[funcGroup_gui_list_item_h] = kodi_gui_list_item_h; + kodi_gui_window_h = new CHdl_kodi_gui_window_h(*this); + m_handlers[funcGroup_gui_window_h] = kodi_gui_window_h; + kodi_gui_controls_button_h = new CHdl_kodi_gui_controls_button_h(*this); + m_handlers[funcGroup_gui_controls_button_h] = kodi_gui_controls_button_h; + kodi_gui_controls_edit_h = new CHdl_kodi_gui_controls_edit_h(*this); + m_handlers[funcGroup_gui_controls_edit_h] = kodi_gui_controls_edit_h; + kodi_gui_controls_fade_label_h = new CHdl_kodi_gui_controls_fade_label_h(*this); + m_handlers[funcGroup_gui_controls_fade_label_h] = kodi_gui_controls_fade_label_h; + kodi_gui_controls_image_h = new CHdl_kodi_gui_controls_image_h(*this); + m_handlers[funcGroup_gui_controls_image_h] = kodi_gui_controls_image_h; + kodi_gui_controls_label_h = new CHdl_kodi_gui_controls_label_h(*this); + m_handlers[funcGroup_gui_controls_label_h] = kodi_gui_controls_label_h; + kodi_gui_controls_progress_h = new CHdl_kodi_gui_controls_progress_h(*this); + m_handlers[funcGroup_gui_controls_progress_h] = kodi_gui_controls_progress_h; + kodi_gui_controls_radio_button_h = new CHdl_kodi_gui_controls_radio_button_h(*this); + m_handlers[funcGroup_gui_controls_radio_button_h] = kodi_gui_controls_radio_button_h; + kodi_gui_controls_rendering_h = new CHdl_kodi_gui_controls_rendering_h(*this); + m_handlers[funcGroup_gui_controls_rendering_h] = kodi_gui_controls_rendering_h; + kodi_gui_controls_settings_slider_h = new CHdl_kodi_gui_controls_settings_slider_h(*this); + m_handlers[funcGroup_gui_controls_settings_slider_h] = kodi_gui_controls_settings_slider_h; + kodi_gui_controls_slider_h = new CHdl_kodi_gui_controls_slider_h(*this); + m_handlers[funcGroup_gui_controls_slider_h] = kodi_gui_controls_slider_h; + kodi_gui_controls_spin_h = new CHdl_kodi_gui_controls_spin_h(*this); + m_handlers[funcGroup_gui_controls_spin_h] = kodi_gui_controls_spin_h; + kodi_gui_controls_text_box_h = new CHdl_kodi_gui_controls_text_box_h(*this); + m_handlers[funcGroup_gui_controls_text_box_h] = kodi_gui_controls_text_box_h; + kodi_gui_dialogs_context_menu_h = new CHdl_kodi_gui_dialogs_context_menu_h(*this); + m_handlers[funcGroup_gui_dialogs_context_menu_h] = kodi_gui_dialogs_context_menu_h; + kodi_gui_dialogs_extended_progress_h = new CHdl_kodi_gui_dialogs_extended_progress_h(*this); + m_handlers[funcGroup_gui_dialogs_extended_progress_h] = kodi_gui_dialogs_extended_progress_h; + kodi_gui_dialogs_filebrowser_h = new CHdl_kodi_gui_dialogs_filebrowser_h(*this); + m_handlers[funcGroup_gui_dialogs_filebrowser_h] = kodi_gui_dialogs_filebrowser_h; + kodi_gui_dialogs_keyboard_h = new CHdl_kodi_gui_dialogs_keyboard_h(*this); + m_handlers[funcGroup_gui_dialogs_keyboard_h] = kodi_gui_dialogs_keyboard_h; + kodi_gui_dialogs_numeric_h = new CHdl_kodi_gui_dialogs_numeric_h(*this); + m_handlers[funcGroup_gui_dialogs_numeric_h] = kodi_gui_dialogs_numeric_h; + kodi_gui_dialogs_ok_h = new CHdl_kodi_gui_dialogs_ok_h(*this); + m_handlers[funcGroup_gui_dialogs_ok_h] = kodi_gui_dialogs_ok_h; + kodi_gui_dialogs_progress_h = new CHdl_kodi_gui_dialogs_progress_h(*this); + m_handlers[funcGroup_gui_dialogs_progress_h] = kodi_gui_dialogs_progress_h; + kodi_gui_dialogs_select_h = new CHdl_kodi_gui_dialogs_select_h(*this); + m_handlers[funcGroup_gui_dialogs_select_h] = kodi_gui_dialogs_select_h; + kodi_gui_dialogs_text_viewer_h = new CHdl_kodi_gui_dialogs_text_viewer_h(*this); + m_handlers[funcGroup_gui_dialogs_text_viewer_h] = kodi_gui_dialogs_text_viewer_h; + kodi_gui_dialogs_yes_no_h = new CHdl_kodi_gui_dialogs_yes_no_h(*this); + m_handlers[funcGroup_gui_dialogs_yes_no_h] = kodi_gui_dialogs_yes_no_h; + + if (m_directIfc != nullptr) + { + kodi_addon_base_h->InitDirect(&m_directIfc->to_kodi.addon_base_h, + &m_directIfc->to_addon.addon_base_h); + kodi_audio_engine_h->InitDirect(&m_directIfc->to_kodi.audio_engine_h, + &m_directIfc->to_addon.audio_engine_h); + kodi_filesystem_h->InitDirect(&m_directIfc->to_kodi.filesystem_h, + &m_directIfc->to_addon.filesystem_h); + kodi_general_h->InitDirect(&m_directIfc->to_kodi.general_h, &m_directIfc->to_addon.general_h); + kodi_monitor_h->InitDirect(&m_directIfc->to_kodi.monitor_h, &m_directIfc->to_addon.monitor_h); + kodi_network_h->InitDirect(&m_directIfc->to_kodi.network_h, &m_directIfc->to_addon.network_h); + kodi_addoninstance_audiodecoder_h->InitDirect( + &m_directIfc->to_kodi.addoninstance_audiodecoder_h, + &m_directIfc->to_addon.addoninstance_audiodecoder_h); + kodi_addoninstance_audioencoder_h->InitDirect( + &m_directIfc->to_kodi.addoninstance_audioencoder_h, + &m_directIfc->to_addon.addoninstance_audioencoder_h); + kodi_addoninstance_game_h->InitDirect(&m_directIfc->to_kodi.addoninstance_game_h, + &m_directIfc->to_addon.addoninstance_game_h); + kodi_addoninstance_imagedecoder_h->InitDirect( + &m_directIfc->to_kodi.addoninstance_imagedecoder_h, + &m_directIfc->to_addon.addoninstance_imagedecoder_h); + kodi_addoninstance_inputstream_h->InitDirect( + &m_directIfc->to_kodi.addoninstance_inputstream_h, + &m_directIfc->to_addon.addoninstance_inputstream_h); + kodi_addoninstance_peripheral_h->InitDirect(&m_directIfc->to_kodi.addoninstance_peripheral_h, + &m_directIfc->to_addon.addoninstance_peripheral_h); + kodi_addoninstance_pvr_h->InitDirect(&m_directIfc->to_kodi.addoninstance_pvr_h, + &m_directIfc->to_addon.addoninstance_pvr_h); + kodi_addoninstance_screensaver_h->InitDirect( + &m_directIfc->to_kodi.addoninstance_screensaver_h, + &m_directIfc->to_addon.addoninstance_screensaver_h); + kodi_addoninstance_vfs_h->InitDirect(&m_directIfc->to_kodi.addoninstance_vfs_h, + &m_directIfc->to_addon.addoninstance_vfs_h); + kodi_addoninstance_videocodec_h->InitDirect(&m_directIfc->to_kodi.addoninstance_videocodec_h, + &m_directIfc->to_addon.addoninstance_videocodec_h); + kodi_addoninstance_visualization_h->InitDirect( + &m_directIfc->to_kodi.addoninstance_visualization_h, + &m_directIfc->to_addon.addoninstance_visualization_h); + kodi_addoninstance_web_h->InitDirect(&m_directIfc->to_kodi.addoninstance_web_h, + &m_directIfc->to_addon.addoninstance_web_h); + kodi_gui_general_h->InitDirect(&m_directIfc->to_kodi.gui_general_h, + &m_directIfc->to_addon.gui_general_h); + kodi_gui_list_item_h->InitDirect(&m_directIfc->to_kodi.gui_list_item_h, + &m_directIfc->to_addon.gui_list_item_h); + kodi_gui_window_h->InitDirect(&m_directIfc->to_kodi.gui_window_h, + &m_directIfc->to_addon.gui_window_h); + kodi_gui_controls_button_h->InitDirect(&m_directIfc->to_kodi.gui_controls_button_h, + &m_directIfc->to_addon.gui_controls_button_h); + kodi_gui_controls_edit_h->InitDirect(&m_directIfc->to_kodi.gui_controls_edit_h, + &m_directIfc->to_addon.gui_controls_edit_h); + kodi_gui_controls_fade_label_h->InitDirect(&m_directIfc->to_kodi.gui_controls_fade_label_h, + &m_directIfc->to_addon.gui_controls_fade_label_h); + kodi_gui_controls_image_h->InitDirect(&m_directIfc->to_kodi.gui_controls_image_h, + &m_directIfc->to_addon.gui_controls_image_h); + kodi_gui_controls_label_h->InitDirect(&m_directIfc->to_kodi.gui_controls_label_h, + &m_directIfc->to_addon.gui_controls_label_h); + kodi_gui_controls_progress_h->InitDirect(&m_directIfc->to_kodi.gui_controls_progress_h, + &m_directIfc->to_addon.gui_controls_progress_h); + kodi_gui_controls_radio_button_h->InitDirect( + &m_directIfc->to_kodi.gui_controls_radio_button_h, + &m_directIfc->to_addon.gui_controls_radio_button_h); + kodi_gui_controls_rendering_h->InitDirect(&m_directIfc->to_kodi.gui_controls_rendering_h, + &m_directIfc->to_addon.gui_controls_rendering_h); + kodi_gui_controls_settings_slider_h->InitDirect( + &m_directIfc->to_kodi.gui_controls_settings_slider_h, + &m_directIfc->to_addon.gui_controls_settings_slider_h); + kodi_gui_controls_slider_h->InitDirect(&m_directIfc->to_kodi.gui_controls_slider_h, + &m_directIfc->to_addon.gui_controls_slider_h); + kodi_gui_controls_spin_h->InitDirect(&m_directIfc->to_kodi.gui_controls_spin_h, + &m_directIfc->to_addon.gui_controls_spin_h); + kodi_gui_controls_text_box_h->InitDirect(&m_directIfc->to_kodi.gui_controls_text_box_h, + &m_directIfc->to_addon.gui_controls_text_box_h); + kodi_gui_dialogs_context_menu_h->InitDirect(&m_directIfc->to_kodi.gui_dialogs_context_menu_h, + &m_directIfc->to_addon.gui_dialogs_context_menu_h); + kodi_gui_dialogs_extended_progress_h->InitDirect( + &m_directIfc->to_kodi.gui_dialogs_extended_progress_h, + &m_directIfc->to_addon.gui_dialogs_extended_progress_h); + kodi_gui_dialogs_filebrowser_h->InitDirect(&m_directIfc->to_kodi.gui_dialogs_filebrowser_h, + &m_directIfc->to_addon.gui_dialogs_filebrowser_h); + kodi_gui_dialogs_keyboard_h->InitDirect(&m_directIfc->to_kodi.gui_dialogs_keyboard_h, + &m_directIfc->to_addon.gui_dialogs_keyboard_h); + kodi_gui_dialogs_numeric_h->InitDirect(&m_directIfc->to_kodi.gui_dialogs_numeric_h, + &m_directIfc->to_addon.gui_dialogs_numeric_h); + kodi_gui_dialogs_ok_h->InitDirect(&m_directIfc->to_kodi.gui_dialogs_ok_h, + &m_directIfc->to_addon.gui_dialogs_ok_h); + kodi_gui_dialogs_progress_h->InitDirect(&m_directIfc->to_kodi.gui_dialogs_progress_h, + &m_directIfc->to_addon.gui_dialogs_progress_h); + kodi_gui_dialogs_select_h->InitDirect(&m_directIfc->to_kodi.gui_dialogs_select_h, + &m_directIfc->to_addon.gui_dialogs_select_h); + kodi_gui_dialogs_text_viewer_h->InitDirect(&m_directIfc->to_kodi.gui_dialogs_text_viewer_h, + &m_directIfc->to_addon.gui_dialogs_text_viewer_h); + kodi_gui_dialogs_yes_no_h->InitDirect(&m_directIfc->to_kodi.gui_dialogs_yes_no_h, + &m_directIfc->to_addon.gui_dialogs_yes_no_h); + } + /*---AUTO_GEN_PARSE---*/ +} + +CInterface::~CInterface() +{ + for (auto& handler : m_handlers) + { + delete handler; + } +} + +bool CInterface::FuncCall(int group, int func, const msgpack::unpacked& in, msgpack::sbuffer& out) +{ + if (m_handlers[group]) + return m_handlers[group]->HandleMessage(group, func, in, out); + return false; +} + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/Interface.h b/xbmc/addons/interface/Interface.h new file mode 100644 index 0000000000000..f174e84905087 --- /dev/null +++ b/xbmc/addons/interface/Interface.h @@ -0,0 +1,156 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "../kodi-dev-kit/src/shared/SharedGroups.h" +#include "IMsgHdl.h" + +#include + +namespace ADDON +{ +class CAddonInfo; +} /* namespace ADDON */ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/*---AUTO_GEN_PARSE---*/ +class CHdl_kodi_addon_base_h; +class CHdl_kodi_audio_engine_h; +class CHdl_kodi_filesystem_h; +class CHdl_kodi_general_h; +class CHdl_kodi_monitor_h; +class CHdl_kodi_network_h; +class CHdl_kodi_addoninstance_audiodecoder_h; +class CHdl_kodi_addoninstance_audioencoder_h; +class CHdl_kodi_addoninstance_game_h; +class CHdl_kodi_addoninstance_imagedecoder_h; +class CHdl_kodi_addoninstance_inputstream_h; +class CHdl_kodi_addoninstance_peripheral_h; +class CHdl_kodi_addoninstance_pvr_h; +class CHdl_kodi_addoninstance_screensaver_h; +class CHdl_kodi_addoninstance_vfs_h; +class CHdl_kodi_addoninstance_videocodec_h; +class CHdl_kodi_addoninstance_visualization_h; +class CHdl_kodi_addoninstance_web_h; +class CHdl_kodi_gui_general_h; +class CHdl_kodi_gui_list_item_h; +class CHdl_kodi_gui_window_h; +class CHdl_kodi_gui_controls_button_h; +class CHdl_kodi_gui_controls_edit_h; +class CHdl_kodi_gui_controls_fade_label_h; +class CHdl_kodi_gui_controls_image_h; +class CHdl_kodi_gui_controls_label_h; +class CHdl_kodi_gui_controls_progress_h; +class CHdl_kodi_gui_controls_radio_button_h; +class CHdl_kodi_gui_controls_rendering_h; +class CHdl_kodi_gui_controls_settings_slider_h; +class CHdl_kodi_gui_controls_slider_h; +class CHdl_kodi_gui_controls_spin_h; +class CHdl_kodi_gui_controls_text_box_h; +class CHdl_kodi_gui_dialogs_context_menu_h; +class CHdl_kodi_gui_dialogs_extended_progress_h; +class CHdl_kodi_gui_dialogs_filebrowser_h; +class CHdl_kodi_gui_dialogs_keyboard_h; +class CHdl_kodi_gui_dialogs_numeric_h; +class CHdl_kodi_gui_dialogs_ok_h; +class CHdl_kodi_gui_dialogs_progress_h; +class CHdl_kodi_gui_dialogs_select_h; +class CHdl_kodi_gui_dialogs_text_viewer_h; +class CHdl_kodi_gui_dialogs_yes_no_h; +/*---AUTO_GEN_PARSE---*/ + +struct DirectAddonIfc; + +enum class InterfaceKodiClass +{ + CFile, + CHttpHeader, + IAEStream, +}; + +class IInterfaceClassHdl +{ +public: + IInterfaceClassHdl(InterfaceKodiClass ifcClass) : m_ifcClass(ifcClass) {} + virtual ~IInterfaceClassHdl() = default; + + const InterfaceKodiClass m_ifcClass; +}; + +class CInterface +{ +public: + CInterface(CRunningProcess* process, bool directDll); + ~CInterface(); + + bool FuncCall(int group, int func, const msgpack::unpacked& in, msgpack::sbuffer& out); + + /*---AUTO_GEN_PARSE---*/ + CHdl_kodi_addon_base_h* kodi_addon_base_h; + CHdl_kodi_audio_engine_h* kodi_audio_engine_h; + CHdl_kodi_filesystem_h* kodi_filesystem_h; + CHdl_kodi_general_h* kodi_general_h; + CHdl_kodi_monitor_h* kodi_monitor_h; + CHdl_kodi_network_h* kodi_network_h; + CHdl_kodi_addoninstance_audiodecoder_h* kodi_addoninstance_audiodecoder_h; + CHdl_kodi_addoninstance_audioencoder_h* kodi_addoninstance_audioencoder_h; + CHdl_kodi_addoninstance_game_h* kodi_addoninstance_game_h; + CHdl_kodi_addoninstance_imagedecoder_h* kodi_addoninstance_imagedecoder_h; + CHdl_kodi_addoninstance_inputstream_h* kodi_addoninstance_inputstream_h; + CHdl_kodi_addoninstance_peripheral_h* kodi_addoninstance_peripheral_h; + CHdl_kodi_addoninstance_pvr_h* kodi_addoninstance_pvr_h; + CHdl_kodi_addoninstance_screensaver_h* kodi_addoninstance_screensaver_h; + CHdl_kodi_addoninstance_vfs_h* kodi_addoninstance_vfs_h; + CHdl_kodi_addoninstance_videocodec_h* kodi_addoninstance_videocodec_h; + CHdl_kodi_addoninstance_visualization_h* kodi_addoninstance_visualization_h; + CHdl_kodi_addoninstance_web_h* kodi_addoninstance_web_h; + CHdl_kodi_gui_general_h* kodi_gui_general_h; + CHdl_kodi_gui_list_item_h* kodi_gui_list_item_h; + CHdl_kodi_gui_window_h* kodi_gui_window_h; + CHdl_kodi_gui_controls_button_h* kodi_gui_controls_button_h; + CHdl_kodi_gui_controls_edit_h* kodi_gui_controls_edit_h; + CHdl_kodi_gui_controls_fade_label_h* kodi_gui_controls_fade_label_h; + CHdl_kodi_gui_controls_image_h* kodi_gui_controls_image_h; + CHdl_kodi_gui_controls_label_h* kodi_gui_controls_label_h; + CHdl_kodi_gui_controls_progress_h* kodi_gui_controls_progress_h; + CHdl_kodi_gui_controls_radio_button_h* kodi_gui_controls_radio_button_h; + CHdl_kodi_gui_controls_rendering_h* kodi_gui_controls_rendering_h; + CHdl_kodi_gui_controls_settings_slider_h* kodi_gui_controls_settings_slider_h; + CHdl_kodi_gui_controls_slider_h* kodi_gui_controls_slider_h; + CHdl_kodi_gui_controls_spin_h* kodi_gui_controls_spin_h; + CHdl_kodi_gui_controls_text_box_h* kodi_gui_controls_text_box_h; + CHdl_kodi_gui_dialogs_context_menu_h* kodi_gui_dialogs_context_menu_h; + CHdl_kodi_gui_dialogs_extended_progress_h* kodi_gui_dialogs_extended_progress_h; + CHdl_kodi_gui_dialogs_filebrowser_h* kodi_gui_dialogs_filebrowser_h; + CHdl_kodi_gui_dialogs_keyboard_h* kodi_gui_dialogs_keyboard_h; + CHdl_kodi_gui_dialogs_numeric_h* kodi_gui_dialogs_numeric_h; + CHdl_kodi_gui_dialogs_ok_h* kodi_gui_dialogs_ok_h; + CHdl_kodi_gui_dialogs_progress_h* kodi_gui_dialogs_progress_h; + CHdl_kodi_gui_dialogs_select_h* kodi_gui_dialogs_select_h; + CHdl_kodi_gui_dialogs_text_viewer_h* kodi_gui_dialogs_text_viewer_h; + CHdl_kodi_gui_dialogs_yes_no_h* kodi_gui_dialogs_yes_no_h; + /*---AUTO_GEN_PARSE---*/ + + CRunningProcess* const m_process; + std::unique_ptr const m_directIfc; + const bool m_directDll; + +private: + std::array m_handlers{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/RunningProcess.cpp b/xbmc/addons/interface/RunningProcess.cpp new file mode 100644 index 0000000000000..6721cd82e640c --- /dev/null +++ b/xbmc/addons/interface/RunningProcess.cpp @@ -0,0 +1,550 @@ +/* + * Copyright (C) 2005-2021 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "RunningProcess.h" + +// Interface +#include "Controller.h" +#include "InstanceHandler.h" +#include "RunningThread.h" +#include "api/addon_base.h" + +// Kodi +#include "ServiceBroker.h" +#include "addons/addoninfo/AddonInfo.h" +#include "addons/kodi-dev-kit/src/shared/DirectData.h" +#include "addons/kodi-dev-kit/src/shared/SharedData.h" +#include "addons/kodi-dev-kit/src/shared/api/processor.h" +#include "filesystem/File.h" +#include "utils/log.h" + +#ifdef TARGET_LINUX +#include "processinfo/ProcessInfoLinux.h" +#endif +#include "launcher/LauncherDirectDll.h" +#ifdef TARGET_POSIX +#include "launcher/LauncherPosix.h" +#elif TARGET_WINDOWS +#include "launcher/LauncherWindows.h" +#else +#error No valid OS defined +#endif + +using namespace std::chrono_literals; + +namespace +{ +#ifndef STR_HELPER +#define STR_HELPER(x) #x +#endif +#ifndef STR +#define STR(x) STR_HELPER(x) +#endif +constexpr const char* EXE_FLAG = "--addon"; +constexpr const char* API_VERSION_FLAG = "--api"; +constexpr const char* API_VERSION_VALUE = STR(__KDK_MAJOR__); +constexpr const char* DEBUG_FLAG = "--debug"; +constexpr const char* DEVKIT_LIB_FLAG = "--dl"; +constexpr const char* DEVKIT_DIR_FLAG = "--dir"; +constexpr const char* DEVKIT_MAIN_SHARED_FLAG = "--main-shared"; +constexpr const char* DEVKIT_DIRECT_API_FLAG = "--direct-api"; +constexpr const char* DEVKIT_REPORT_PATH = "--report-path"; +} // namespace + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +CRunningProcess::CRunningProcess(const std::shared_ptr& addon, + const std::string& uuid, + bool noSandbox, + const KODI_ADDON_INSTANCE_INFO* firstInstance) + : CThread("CRunningProcess"), + m_addon(addon), + m_uuid(uuid), +#ifndef KODI_INHIBIT_SHARED + m_noSandbox(noSandbox), +#else + m_noSandbox(true), +#endif + m_kodiInitInstancePtr(firstInstance), + m_mainThread(m_threadIdentfier++, this), + m_interface(this, m_noSandbox), + m_cmdValue_exe(m_addon->Type(m_addon->MainType())->LibPath()), + m_cmdValue_direct_api( + StringUtils::Format("{}", static_cast(m_interface.m_directIfc.get()))), + m_endMilliseconds(0ms) +{ + if (m_noSandbox) + m_launcher = new CLauncherDirectDll(addon, uuid); +#ifndef KODI_INHIBIT_SHARED + else +#ifdef TARGET_POSIX + m_launcher = new CLauncherPosix(addon, uuid); +#elif TARGET_WINDOWS + m_launcher = nullptr; +#else + m_launcher = nullptr; +#endif +#endif +} + +CRunningProcess::~CRunningProcess() +{ + Kill(); + delete m_launcher; + delete m_processInfo; +} + +bool CRunningProcess::MakeCommandLineValues(std::vector& argv_cstr) +{ + argv_cstr.reserve(m_argv.size() + 16); + + if (!m_noSandbox) + { + argv_cstr.emplace_back( + const_cast(CServiceBroker::GetAddonIfcCtrl().GetDevkitLaunchExe().c_str())); + argv_cstr.emplace_back(const_cast(EXE_FLAG)); + } + + argv_cstr.emplace_back(const_cast(m_cmdValue_exe.c_str())); + + if (m_noSandbox) + { + argv_cstr.emplace_back(const_cast(DEVKIT_DIRECT_API_FLAG)); + argv_cstr.emplace_back(const_cast(m_cmdValue_direct_api.c_str())); + } + + argv_cstr.emplace_back(const_cast(API_VERSION_FLAG)); + argv_cstr.emplace_back(const_cast(API_VERSION_VALUE)); + + argv_cstr.emplace_back(const_cast(DEVKIT_MAIN_SHARED_FLAG)); + argv_cstr.emplace_back(const_cast(m_uuid.c_str())); + + argv_cstr.emplace_back(const_cast(DEVKIT_LIB_FLAG)); + argv_cstr.emplace_back( + const_cast(CServiceBroker::GetAddonIfcCtrl().GetDevkitLibPath().c_str())); + + argv_cstr.emplace_back(const_cast(DEVKIT_DIR_FLAG)); + argv_cstr.emplace_back( + const_cast(CServiceBroker::GetAddonIfcCtrl().GetDevkitPath().c_str())); + + argv_cstr.emplace_back(const_cast(DEVKIT_REPORT_PATH)); + argv_cstr.emplace_back( + const_cast(CServiceBroker::GetAddonIfcCtrl().GetDevkitReportPath().c_str())); + + argv_cstr.emplace_back(const_cast(DEBUG_FLAG)); + + for (const auto& arg : m_argv) + argv_cstr.emplace_back(const_cast(arg.c_str())); + + argv_cstr.emplace_back(nullptr); + + return true; +} + +bool CRunningProcess::Launch(const std::vector& argv, bool waitForExit) +{ + /* + * Confirm the wanted executable is really present. + */ + if (m_cmdValue_exe.empty() || !XFILE::CFile::Exists(m_cmdValue_exe)) + { + CLog::Log(LOGERROR, "CRunningProcess::{}: Wanted add-on '{}' to run not present", __func__, m_cmdValue_exe); + return false; + } + + /* + * Start the addon main thread receiver. + * NOTE This not relate to a real thread process itself only that it handle + * addon his thread calls. + */ + if (!m_mainThread.Create(waitForExit)) + { + CLog::Log(LOGERROR, "CRunningProcess::{}: Failed to create process thread interface for addon", + __func__, m_addon->ID()); + return false; + } + + m_argv = argv; + + /* + * Start addon from here, if wait for exit is set, as it should return direct + * after performed work. + * + * This thought for helper apps where do one time by call the wanted work. + * + * For the normal cases the running thread becomes created where also start + * the executable. + */ + if (waitForExit || (m_noSandbox && m_launcher->SupportNonBlocking(m_cmdValue_exe))) + { + std::vector argv_cstr; + if (!MakeCommandLineValues(argv_cstr)) + { + CLog::Log(LOGERROR, + "CRunningProcess::{}: Failed to parse command values for addon '{}' process", + __func__, m_addon->ID()); + m_startFailed = true; + m_startDone = true; + return false; + } + + if (!m_launcher->Launch(argv_cstr, waitForExit)) + { + CLog::Log(LOGERROR, "CRunningProcess::{}: Failed to start addon '{}' process", __func__, + m_addon->ID()); + m_startFailed = true; + return false; + } + + m_startFailed = false; + } + else + { + /* + * Start here the thread and wait until done. + * This wait needed to have addon usable for other Kodi places, otherwise + * it can come that Kodi wants to call a non present place, e.g. + * kodi_addon_create below. + */ + CThread::Create(); + fprintf(stderr, "--------------> %i\n", ProcessActive()); + while (!m_startDone) + { + fprintf(stderr, "--------------> %i\n", ProcessActive()); + CThread::Sleep(100ms); + } + } + + return !m_startFailed; +} + +bool CRunningProcess::Kill() +{ + // Check addon is running, if yes stop by normal way + if (ProcessActive() == ChildStatus::Running) + { + // Inform addon of requested kill and to allow him needed work (e.g. stop process thread). + if (!m_noSandbox) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_processor_KillChild(m_uuid)); + SendMessage(funcGroup_Main, kodi_processor_KillChild, in); + } + else + { + void* hdl = m_interface.m_directIfc->to_addon.processor_h.thisClassHdl; + if (m_interface.m_directIfc->to_addon.processor_h.kodi_kill_child) + { + m_interface.m_directIfc->to_addon.processor_h.kodi_kill_child(hdl, m_uuid.c_str()); + } + } + + // Make the process kill with wait until done (if exceeds a time delay a kill becomes forced), + m_launcher->Kill(true); + } + + for (const auto& thread : m_runningSubThreads) + thread->Destroy(); + m_runningSubThreads.clear(); + m_mainThread.Destroy(); + + CThread::StopThread(); + + return true; +} + +ProcessInfoData CRunningProcess::GetProcessInfoData() +{ + static ProcessInfoData dummy; + + if (ProcessActive() != ChildStatus::Running) + { + return dummy; + } + + if (!m_processInfo) + { +#ifdef TARGET_LINUX + m_processInfo = new CProcessInfoLinux(m_addon, m_launcher->GetMainProcessPID()); +#endif + } + + return m_processInfo->Calculate(); +} + +ChildStatus CRunningProcess::ProcessActive() +{ + if (m_launcher) + return m_launcher->ProcessActive(); + + return ChildStatus::NotStarted; +} + +bool CRunningProcess::FuncCall(int group, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (group == funcGroup_Main) + { + switch (func) + { + case kodi_processor_CreateForNewThread: + { + msgParent__IN_kodi_processor_CreateForNewThread t = in.get().as(); + + if (m_mainThread.GetID() != std::get<0>(t)) + { + CLog::Log(LOGERROR, + "CRunningProcess::{}: Addon '{}' interface creation called from invalid place " + "'{}' (should '{}')", + __func__, m_addon->ID(), std::get<0>(t), m_mainThread.GetID()); + return false; + } + + std::shared_ptr thread = + std::make_shared(m_threadIdentfier++, this); + if (!thread->Create(true)) + { + CLog::Log(LOGERROR, + "CRunningProcess::{}: Failed to create new thread process for addon '{}'", + __func__, m_addon->ID()); + return false; + } + + m_runningSubThreads.emplace(thread); + + msgpack::pack(out, msgParent_OUT_kodi_processor_CreateForNewThread(thread->GetID(), + thread->GetThreadID())); + return true; + } + default: + return false; + } + } + + return m_interface.FuncCall(group, func, in, out); +} + +bool CRunningProcess::SendMessage(int group, int func) +{ + // TODO Call with other thread? + return m_mainThread.SendMessage(group, func); +} + +bool CRunningProcess::SendMessage(int group, int func, const msgpack::sbuffer& in) +{ + // TODO Call with other thread? + return m_mainThread.SendMessage(group, func, in); +} + +bool CRunningProcess::SendMessage(int group, + int func, + const msgpack::sbuffer& in, + msgpack::sbuffer& ret) +{ + // TODO Call with other thread? + return m_mainThread.SendMessage(group, func, in, ret); +} + +bool CRunningProcess::SendMessageOnlyGetReturn(int group, int func, msgpack::sbuffer& ret) +{ + // TODO Call with other thread? + return m_mainThread.SendMessageOnlyGetReturn(group, func, ret); +} + +void CRunningProcess::RegisterClass(IInterfaceClassHdl* ifcClass) +{ + std::unique_lock lock(m_classRegisterMutex); + m_activeIfcClasses.emplace(ifcClass); +} + +void CRunningProcess::UnregisterClass(IInterfaceClassHdl* ifcClass) +{ + std::unique_lock lock(m_classRegisterMutex); + m_activeIfcClasses.erase(ifcClass); +} + +void CRunningProcess::AddAddonInstance(IInstanceHandler* handler) +{ + // Paranoia check, if there a nullptr, then is really something wrong. + if (handler == nullptr) + { + CLog::Log(LOGERROR, "CRunningProcess::{}: for Id '{}' called with empty instance handler", + __func__, GetAddonID()); + return; + } + + bool empty; + + { + std::unique_lock lock(m_mutex); + + empty = m_activeAddonHandlers.empty(); + + // add the instance handler to the info to know used amount on addon + m_activeAddonHandlers.insert(handler); + } + + // Call addon create if no instances was used before, done without lock to prevent hangs if + // target produces problems and not return and background controller also then blocked to + // check. + if (empty) + m_interface.kodi_addon_base_h->kodi_addon_create_v1(handler->GetCInfo(), &m_hdl); +} + +void CRunningProcess::ReleaseAddonInstance(IInstanceHandler* handler) +{ + // Paranoia check, if there a nullptr, then is really something wrong. + if (handler == nullptr) + { + CLog::Log(LOGERROR, "CRunningProcess::{}: for Id '{}' called with empty instance handler", + __func__, GetAddonID()); + return; + } + + bool empty; + + { + std::unique_lock lock(m_mutex); + + auto presentHandler = m_activeAddonHandlers.find(handler); + if (presentHandler == m_activeAddonHandlers.end()) + return; + + m_activeAddonHandlers.erase(presentHandler); + + empty = m_activeAddonHandlers.empty(); + } + + if (empty) + m_interface.kodi_addon_base_h->kodi_addon_destroy_v1(m_hdl); +} + +void CRunningProcess::InformStopReport(ChildStatus status) +{ + std::unique_lock lock(m_mutex); + + /* + * Inform all running instances about uncontrolled stop by e.g. segemention + * fault on addon. + * + * They can then stop his related threads and destroy related classes. + * This also the reason about "++it;" as there can in for loop the amount + * decreased. + */ + for (auto it = m_activeAddonHandlers.cbegin(); it != m_activeAddonHandlers.cend();) + { + (*it)->StopReport(status); + ++it; + } +} + +size_t CRunningProcess::UsedInstanceCount() const +{ + std::unique_lock lock(m_mutex); + return m_activeAddonHandlers.size(); +} + +const std::string& CRunningProcess::GetStackTrace() const +{ + return m_launcher ? m_launcher->GetStackTrace() : StringUtils::Empty; +} + +void CRunningProcess::SetEndtime(unsigned int milliseconds) +{ + /* + * Set the used endtime, this mostly used by addons where Kodi use as his + * extension, e.g. PVR, audiodecoder and so on. + * + * Other independent running addons not use it as they stop itself. + */ + m_endMilliseconds = std::chrono::milliseconds(milliseconds); + m_endTimer.Set(m_endMilliseconds); +} + +std::chrono::milliseconds CRunningProcess::EndTimeLeft() const +{ + return m_endTimer.GetTimeLeft(); +} + +bool CRunningProcess::UseEndTime() const +{ + return m_endMilliseconds > 0ms; +} + +bool CRunningProcess::IsInUse() const +{ + /* + * If no active instances are present return false and let wait timer expire + * or in case of new instance to reset below again. + */ + if (m_activeAddonHandlers.empty()) + return false; + + /* + * Reset endtime to start. + * Done on ever call (where normally only by "CController::Process()") to use + * after addon no more used and stop his executable. + */ + m_endTimer.Set(m_endMilliseconds); + return true; +} + +void CRunningProcess::Process() +{ + { +fprintf(stderr, "----------------> %s\n", m_addon->ID().c_str()); + /* + * Launch addon from running thread. + * This done for safeness, if the addon was started on another thread where + * becomes stopped somewhere, becomes also the started executable stopped. + */ + std::vector argv_cstr; + if (!MakeCommandLineValues(argv_cstr)) + { + CLog::Log(LOGERROR, + "CRunningProcess::{}: Failed to parse command values for addon '{}' process", + __func__, m_addon->ID()); + m_startFailed = true; + m_startDone = true; + return; + } + + if (!m_launcher->Launch(argv_cstr, false)) + { + CLog::Log(LOGERROR, "CRunningProcess::{}: Failed to start addon '{}' process", __func__, + m_addon->ID()); + m_startFailed = true; + m_startDone = true; + return; + } + + m_startDone = true; + } + + /* + * Do below the addon call to Kodi requests where done by his main thread. + */ + while (!m_bStop) + { + if (!m_mainThread.ProcessOutside()) + { + break; + } + } +} + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/RunningProcess.h b/xbmc/addons/interface/RunningProcess.h new file mode 100644 index 0000000000000..98eebfa4b2902 --- /dev/null +++ b/xbmc/addons/interface/RunningProcess.h @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2005-2021 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "Interface.h" +#include "RunningThread.h" +#include "addons/Addon.h" +#include "launcher/ILauncher.h" +#include "processinfo/ProcessInfo.h" +#include "threads/SystemClock.h" +#include "threads/Thread.h" + +#include +#include +#include +#include +#include +#include + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CRunningThread; +class IInstanceHandler; + +class CRunningProcess : private CThread +{ +public: + CRunningProcess(const std::shared_ptr& addon, + const std::string& uuid, + bool noSandbox, + const KODI_ADDON_INSTANCE_INFO* firstInstance); + ~CRunningProcess(); + + bool Launch(const std::vector& argv, bool waitForExit); + bool Kill(); + ChildStatus ProcessActive(); + + bool FuncCall(int group, int func, const msgpack::unpacked& in, msgpack::sbuffer& out); + + bool SendMessage(int group, int func); + bool SendMessage(int group, int func, const msgpack::sbuffer& in); + bool SendMessage(int group, int func, const msgpack::sbuffer& in, msgpack::sbuffer& ret); + bool SendMessageOnlyGetReturn(int group, int func, msgpack::sbuffer& ret); + + void RegisterClass(IInterfaceClassHdl* ifcClass); + void UnregisterClass(IInterfaceClassHdl* ifcClass); + + void AddAddonInstance(IInstanceHandler* handler); + void ReleaseAddonInstance(IInstanceHandler* handler); + + void InformStopReport(ChildStatus status); + + const std::string& GetUUID() const { return m_uuid; } + const std::shared_ptr& GetAddon() const { return m_addon; } + std::string GetAddonID() const { return m_addon->ID(); } + size_t UsedInstanceCount() const; + const std::string& GetStackTrace() const; + + CInterface& GetIfc() { return m_interface; } + + void SetEndtime(unsigned int milliseconds); + std::chrono::milliseconds EndTimeLeft() const; + bool UseEndTime() const; + bool IsInUse() const; + + ProcessInfoData GetProcessInfoData(); + + const KODI_ADDON_INSTANCE_INFO* GetInitInstancePtr() { return m_kodiInitInstancePtr; } + + void* m_hdl; + +private: + void Process() override; + + bool MakeCommandLineValues(std::vector& argv_cstr); + + const std::shared_ptr m_addon; + const std::string m_uuid; + const bool m_noSandbox; + const KODI_ADDON_INSTANCE_INFO* m_kodiInitInstancePtr; + int64_t m_threadIdentfier{0}; + CRunningThread m_mainThread; + CInterface m_interface; + const std::string m_cmdValue_exe; + const std::string m_cmdValue_direct_api; + + std::atomic_bool m_startDone{false}; + bool m_startFailed{false}; + std::vector m_argv; + ILauncher* m_launcher; + std::set> m_runningSubThreads; + std::unordered_set m_activeIfcClasses; + std::unordered_set m_activeAddonHandlers; + mutable std::mutex m_mutex; + mutable std::mutex m_classRegisterMutex; + std::chrono::milliseconds m_endMilliseconds; + mutable XbmcThreads::EndTime<> m_endTimer; + CProcessInfo* m_processInfo{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/RunningThread.cpp b/xbmc/addons/interface/RunningThread.cpp new file mode 100644 index 0000000000000..f0d5020e38388 --- /dev/null +++ b/xbmc/addons/interface/RunningThread.cpp @@ -0,0 +1,105 @@ +/* + * Copyright (C) 2005-2021 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "RunningThread.h" + +#include "RunningProcess.h" +#include "addons/addoninfo/AddonInfo.h" +#include "addons/kodi-dev-kit/src/shared/ShareProcessReceiver.h" +#include "addons/kodi-dev-kit/src/shared/ShareProcessTransmitter.h" +#include "utils/StringUtils.h" +#include "utils/log.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +CRunningThread::CRunningThread(int64_t identifier, CRunningProcess* const process) + : m_mainThread(identifier == 0), + m_identifier(identifier), + m_id(StringUtils::Format("{}-ifc-{:05}", process->GetUUID().c_str(), m_identifier)), + m_process(process) +{ + m_shareProcessReceiver = new CShareProcessReceiver(m_id + "-chlsrv", m_mainThread); + m_shareProcessTransmitter = new CShareProcessTransmitter(m_id + "-srvchl", m_mainThread); +} + +CRunningThread::~CRunningThread() +{ + Destroy(); + delete m_shareProcessReceiver; + delete m_shareProcessTransmitter; +} + +bool CRunningThread::Create(bool useThread) +{ + if (!m_shareProcessTransmitter->Create(true)) + { + CLog::Log(LOGERROR, + "CRunningThread::{}: Failed to create shared process memory from Kodi to addon '{}' " + "(ERROR {})", + __func__, m_process->GetAddon()->ID(), m_shareProcessTransmitter->GetLastErrorText()); + return false; + } + + if (!m_shareProcessReceiver->Create(true, useThread)) + { + CLog::Log(LOGERROR, + "CRunningThread::{}: Failed to create shared process memory from addon to Kodi '{}' " + "(ERROR {})", + __func__, m_process->GetAddon()->ID(), m_shareProcessReceiver->GetLastErrorText()); + return false; + } + + m_shareProcessReceiver->RegisterReceiver(std::bind(&CRunningProcess::FuncCall, m_process, + std::placeholders::_1, std::placeholders::_2, + std::placeholders::_3, std::placeholders::_4)); + + return true; +} + +void CRunningThread::Destroy() +{ + m_shareProcessTransmitter->Destroy(); + m_shareProcessReceiver->Destroy(); +} + +bool CRunningThread::SendMessage(int group, int func) +{ + return m_shareProcessTransmitter->SendMessage(group, func); +} + +bool CRunningThread::SendMessage(int group, int func, const msgpack::sbuffer& in) +{ + return m_shareProcessTransmitter->SendMessage(group, func, in); +} + +bool CRunningThread::SendMessage(int group, + int func, + const msgpack::sbuffer& in, + msgpack::sbuffer& ret) +{ + return m_shareProcessTransmitter->SendMessage(group, func, in, ret); +} + +bool CRunningThread::SendMessageOnlyGetReturn(int group, int func, msgpack::sbuffer& ret) +{ + return m_shareProcessTransmitter->SendMessageOnlyGetReturn(group, func, ret); +} + +bool CRunningThread::ProcessOutside() +{ + return m_shareProcessReceiver->ProcessOutside(); +} + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/RunningThread.h b/xbmc/addons/interface/RunningThread.h new file mode 100644 index 0000000000000..935c6fc7cce38 --- /dev/null +++ b/xbmc/addons/interface/RunningThread.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2005-2021 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include +#include +#include +#include + +#include + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CRunningProcess; +class CShareProcessReceiver; +class CShareProcessTransmitter; + +class CRunningThread +{ +public: + CRunningThread(int64_t identifier, CRunningProcess* const process); + ~CRunningThread(); + + bool Create(bool useThread); + void Destroy(); + + bool SendMessage(int group, int func); + bool SendMessage(int group, int func, const msgpack::sbuffer& in); + bool SendMessage(int group, int func, const msgpack::sbuffer& in, msgpack::sbuffer& ret); + bool SendMessageOnlyGetReturn(int group, int func, msgpack::sbuffer& ret); + + bool ProcessOutside(); + + int64_t GetThreadID() const { return m_identifier; } + const std::string& GetID() const { return m_id; } + +private: + const bool m_mainThread; + const int64_t m_identifier; + const std::string m_id; + CRunningProcess* const m_process; + + int64_t m_pid{-1}; + CShareProcessReceiver* m_shareProcessReceiver{nullptr}; + CShareProcessTransmitter* m_shareProcessTransmitter{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/CMakeLists.txt b/xbmc/addons/interface/api/CMakeLists.txt new file mode 100644 index 0000000000000..c1043a4fd7b8f --- /dev/null +++ b/xbmc/addons/interface/api/CMakeLists.txt @@ -0,0 +1,24 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + addon_base.cpp + audio_engine.cpp + filesystem.cpp + general.cpp + monitor.cpp + network.cpp +) + +set(HEADERS + addon_base.h + audio_engine.h + filesystem.h + general.h + monitor.h + network.h +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface_api) +endif() diff --git a/xbmc/addons/interface/api/addon-instance/CMakeLists.txt b/xbmc/addons/interface/api/addon-instance/CMakeLists.txt new file mode 100644 index 0000000000000..a57c1b1d62eb9 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/CMakeLists.txt @@ -0,0 +1,36 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + audiodecoder.cpp + audioencoder.cpp + game.cpp + imagedecoder.cpp + inputstream.cpp + peripheral.cpp + pvr.cpp + screensaver.cpp + vfs.cpp + videocodec.cpp + visualization.cpp + web.cpp +) + +set(HEADERS + audiodecoder.h + audioencoder.h + game.h + imagedecoder.h + inputstream.h + peripheral.h + pvr.h + screensaver.h + vfs.h + videocodec.h + visualization.h + web.h +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface_api_addon-instance) +endif() diff --git a/xbmc/addons/interface/api/addon-instance/audiodecoder.cpp b/xbmc/addons/interface/api/addon-instance/audiodecoder.cpp new file mode 100644 index 0000000000000..a59840fbad212 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/audiodecoder.cpp @@ -0,0 +1,256 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "audiodecoder.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/audiodecoder.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_audiodecoder_h::InitDirect( + directFuncToKodi_addoninstance_audiodecoder_h* ifcToKodi, + directFuncToAddon_addoninstance_audiodecoder_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; +} + +bool CHdl_kodi_addoninstance_audiodecoder_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_audiodecoder_h) + return false; + + switch (func) + { + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_audiodecoder_h::{}: addon called with unknown function id " + "'{}' on group 'addoninstance_audiodecoder_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +bool CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_supports_file_v1( + const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_SUPPORTS_FILE_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audiodecoder_supports_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audiodecoder_supports_file_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_audiodecoder_supports_file_v1(PtrValue(hdl), file)); + if (!m_process->SendMessage(funcGroup_addoninstance_audiodecoder_h, + funcChild_kodi_addon_audiodecoder_supports_file_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_audiodecoder_supports_file_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_audiodecoder_supports_file_v1(m_ifcToAddon->thisClassHdl, hdl, + file); +} + +bool CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_init_v1( + const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file, + unsigned int filecache, + int* channels, + int* samplerate, + int* bitspersample, + int64_t* totaltime, + int* bitrate, + enum AudioEngineDataFormat* format, + enum AudioEngineChannel info[AUDIOENGINE_CH_MAX]) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_INIT_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file, unsigned int filecache, int* channels, int* samplerate, int* bitspersample, int64_t* totaltime, int* bitrate, enum AudioEngineDataFormat* format, enum AudioEngineChannel info[AUDIOENGINE_CH_MAX]); + // Tuple in: typedef std::tuple> msgChild__IN_kodi_addon_audiodecoder_init_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple> msgChild_OUT_kodi_addon_audiodecoder_init_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + std::array ifc_info; + std::memcpy(ifc_info.data(), info, sizeof(enum AudioEngineChannel) * AUDIOENGINE_CH_MAX); + msgpack::pack(in, msgChild__IN_kodi_addon_audiodecoder_init_v1( + PtrValue(hdl), file, filecache, *channels, *samplerate, *bitspersample, + *totaltime, *bitrate, *format, ifc_info)); + if (!m_process->SendMessage(funcGroup_addoninstance_audiodecoder_h, + funcChild_kodi_addon_audiodecoder_init_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_audiodecoder_init_v1 t = ident.get().as(); + *channels = std::get<1>(t); + *samplerate = std::get<2>(t); + *bitspersample = std::get<3>(t); + *totaltime = std::get<4>(t); + *bitrate = std::get<5>(t); + *format = std::get<6>(t); + std::memcpy(info, std::get<7>(t).data(), sizeof(enum AudioEngineChannel) * AUDIOENGINE_CH_MAX); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_audiodecoder_init_v1( + m_ifcToAddon->thisClassHdl, hdl, file, filecache, channels, samplerate, bitspersample, + totaltime, bitrate, format, info); +} + +int CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_read_pcm_v1( + const KODI_ADDON_AUDIODECODER_HDL hdl, uint8_t* buffer, size_t size, size_t* actualsize) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_READ_PCM_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, uint8_t* buffer, size_t size, size_t* actualsize); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audiodecoder_read_pcm_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_audiodecoder_read_pcm_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_audiodecoder_read_pcm_v1(PtrValue(hdl), size, *actualsize)); + if (!m_process->SendMessage(funcGroup_addoninstance_audiodecoder_h, + funcChild_kodi_addon_audiodecoder_read_pcm_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_audiodecoder_read_pcm_v1 t = ident.get().as(); + std::memcpy(buffer, std::get<1>(t).data(), sizeof(uint8_t) * size); + *actualsize = std::get<2>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_audiodecoder_read_pcm_v1(m_ifcToAddon->thisClassHdl, hdl, buffer, + size, actualsize); +} + +int64_t CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_seek_v1( + const KODI_ADDON_AUDIODECODER_HDL hdl, int64_t time) +{ + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_SEEK_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, int64_t time); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audiodecoder_seek_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audiodecoder_seek_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_audiodecoder_seek_v1(PtrValue(hdl), time)); + if (!m_process->SendMessage(funcGroup_addoninstance_audiodecoder_h, + funcChild_kodi_addon_audiodecoder_seek_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_audiodecoder_seek_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_audiodecoder_seek_v1(m_ifcToAddon->thisClassHdl, hdl, time); +} + +bool CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_read_tag_v1( + const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file, + struct KODI_ADDON_AUDIODECODER_INFO_TAG* tag) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_READ_TAG_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file, struct KODI_ADDON_AUDIODECODER_INFO_TAG* tag); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audiodecoder_read_tag_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audiodecoder_read_tag_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_audiodecoder_read_tag_v1(PtrValue(hdl), file)); + if (!m_process->SendMessage(funcGroup_addoninstance_audiodecoder_h, + funcChild_kodi_addon_audiodecoder_read_tag_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_audiodecoder_read_tag_v1 t = ident.get().as(); + std::get<1>(t).SetCStructure(tag); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_audiodecoder_read_tag_v1(m_ifcToAddon->thisClassHdl, hdl, file, + tag); +} + +int CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_track_count_v1( + const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_TRACK_COUNT_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audiodecoder_track_count_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audiodecoder_track_count_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_audiodecoder_track_count_v1(PtrValue(hdl), file)); + if (!m_process->SendMessage(funcGroup_addoninstance_audiodecoder_h, + funcChild_kodi_addon_audiodecoder_track_count_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_audiodecoder_track_count_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_audiodecoder_track_count_v1(m_ifcToAddon->thisClassHdl, hdl, + file); +} + +// Callbacks from addon to Kodi +/* NOTE: unused (no callbacks here) */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/audiodecoder.h b/xbmc/addons/interface/api/addon-instance/audiodecoder.h new file mode 100644 index 0000000000000..f167dff826ef9 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/audiodecoder.h @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/audiodecoder.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_audiodecoder_h; +struct directFuncToKodi_addoninstance_audiodecoder_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_audiodecoder_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_audiodecoder_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_audiodecoder_h* ifcToKodi, + directFuncToAddon_addoninstance_audiodecoder_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + bool kodi_addon_audiodecoder_supports_file_v1(const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file); // Added with API 1 + + bool kodi_addon_audiodecoder_init_v1( + const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file, + unsigned int filecache, + int* channels, + int* samplerate, + int* bitspersample, + int64_t* totaltime, + int* bitrate, + enum AudioEngineDataFormat* format, + enum AudioEngineChannel info[AUDIOENGINE_CH_MAX]); // Added with API 1 + + int kodi_addon_audiodecoder_read_pcm_v1(const KODI_ADDON_AUDIODECODER_HDL hdl, + uint8_t* buffer, + size_t size, + size_t* actualsize); // Added with API 1 + + int64_t kodi_addon_audiodecoder_seek_v1(const KODI_ADDON_AUDIODECODER_HDL hdl, + int64_t time); // Added with API 1 + + bool kodi_addon_audiodecoder_read_tag_v1( + const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file, + struct KODI_ADDON_AUDIODECODER_INFO_TAG* tag); // Added with API 1 + + int kodi_addon_audiodecoder_track_count_v1(const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + + directFuncToAddon_addoninstance_audiodecoder_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/audioencoder.cpp b/xbmc/addons/interface/api/addon-instance/audioencoder.cpp new file mode 100644 index 0000000000000..5634b5efc1710 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/audioencoder.cpp @@ -0,0 +1,213 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "audioencoder.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/audioencoder.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "cdrip/EncoderAddon.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_audioencoder_h::InitDirect( + directFuncToKodi_addoninstance_audioencoder_h* ifcToKodi, + directFuncToAddon_addoninstance_audioencoder_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_addon_audioencoder_write_v1 = kodi_addon_audioencoder_write_v1; + ifcToKodi->kodi_addon_audioencoder_seek_v1 = kodi_addon_audioencoder_seek_v1; +} + +bool CHdl_kodi_addoninstance_audioencoder_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_audioencoder_h) + return false; + + switch (func) + { + case funcParent_kodi_addon_audioencoder_write_v1: + { + // Original API call: ATTR_DLL_EXPORT ssize_t kodi_addon_audioencoder_write(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const uint8_t* data, size_t len) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple, size_t> msgParent__IN_kodi_addon_audioencoder_write_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_audioencoder_write_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_audioencoder_write_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::vector& data = std::get<1>(t); + size_t len = std::get<2>(t); + ssize_t auto_gen_ret = kodi_addon_audioencoder_write_v1(this, hdl, data.data(), len); + msgpack::pack(out, msgParent_OUT_kodi_addon_audioencoder_write_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_audioencoder_seek_v1: + { + // Original API call: ATTR_DLL_EXPORT ssize_t kodi_addon_audioencoder_seek(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, ssize_t pos, int whence) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_audioencoder_seek_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_audioencoder_seek_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_audioencoder_seek_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + ssize_t pos = std::get<1>(t); + int whence = std::get<2>(t); + ssize_t auto_gen_ret = kodi_addon_audioencoder_seek_v1(this, hdl, pos, whence); + msgpack::pack(out, msgParent_OUT_kodi_addon_audioencoder_seek_v1(auto_gen_ret)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_audioencoder_h::{}: addon called with unknown function id " + "'{}' on group 'addoninstance_audioencoder_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +bool CHdl_kodi_addoninstance_audioencoder_h::kodi_addon_audioencoder_start_v1( + KODI_ADDON_AUDIOENCODER_HDL hdl, const struct KODI_ADDON_AUDIOENCODER_INFO_TAG* tag) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIOENCODER_START_V1)(KODI_ADDON_AUDIOENCODER_HDL hdl, const struct KODI_ADDON_AUDIOENCODER_INFO_TAG* tag); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audioencoder_start_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audioencoder_start_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_audioencoder_start_v1(PtrValue(hdl), tag)); + if (!m_process->SendMessage(funcGroup_addoninstance_audioencoder_h, + funcChild_kodi_addon_audioencoder_start_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_audioencoder_start_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_audioencoder_start_v1(m_ifcToAddon->thisClassHdl, hdl, tag); +} + +ssize_t CHdl_kodi_addoninstance_audioencoder_h::kodi_addon_audioencoder_encode_v1( + KODI_ADDON_AUDIOENCODER_HDL hdl, const uint8_t* pbt_stream, size_t num_bytes_read) +{ + // Original API call: typedef ssize_t(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIOENCODER_ENCODE_V1)(KODI_ADDON_AUDIOENCODER_HDL hdl, const uint8_t* pbt_stream, size_t num_bytes_read); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_audioencoder_encode_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audioencoder_encode_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_audioencoder_encode_v1( + PtrValue(hdl), std::vector(pbt_stream, pbt_stream + num_bytes_read), + num_bytes_read)); + if (!m_process->SendMessage(funcGroup_addoninstance_audioencoder_h, + funcChild_kodi_addon_audioencoder_encode_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_audioencoder_encode_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_audioencoder_encode_v1(m_ifcToAddon->thisClassHdl, hdl, + pbt_stream, num_bytes_read); +} + +bool CHdl_kodi_addoninstance_audioencoder_h::kodi_addon_audioencoder_finish_v1( + KODI_ADDON_AUDIOENCODER_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIOENCODER_FINISH_V1)(KODI_ADDON_AUDIOENCODER_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audioencoder_finish_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audioencoder_finish_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_audioencoder_finish_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_audioencoder_h, + funcChild_kodi_addon_audioencoder_finish_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_audioencoder_finish_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_audioencoder_finish_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +// Callbacks from addon to Kodi + +ssize_t CHdl_kodi_addoninstance_audioencoder_h::kodi_addon_audioencoder_write_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const uint8_t* data, size_t len) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::CDRIP::CEncoderAddon" with "ssize_t Write(const uint8_t* data, size_t len)" on "cdrip/EncoderAddon.h". + + KODI::CDRIP::CEncoderAddon* cb = static_cast(hdl); + return cb->Write(data, len); + /*---AUTO_GEN_PARSE---*/ +} + +ssize_t CHdl_kodi_addoninstance_audioencoder_h::kodi_addon_audioencoder_seek_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, ssize_t pos, int whence) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::CDRIP::CEncoderAddon" with "ssize_t Seek(ssize_t pos, int whence)" on "cdrip/EncoderAddon.h". + + KODI::CDRIP::CEncoderAddon* cb = static_cast(hdl); + return cb->Seek(pos, whence); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/audioencoder.h b/xbmc/addons/interface/api/addon-instance/audioencoder.h new file mode 100644 index 0000000000000..5dc64e01ccd4a --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/audioencoder.h @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/audioencoder.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_audioencoder_h; +struct directFuncToKodi_addoninstance_audioencoder_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_audioencoder_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_audioencoder_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_audioencoder_h* ifcToKodi, + directFuncToAddon_addoninstance_audioencoder_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + bool kodi_addon_audioencoder_start_v1( + KODI_ADDON_AUDIOENCODER_HDL hdl, + const struct KODI_ADDON_AUDIOENCODER_INFO_TAG* tag); // Added with API 1 + + ssize_t kodi_addon_audioencoder_encode_v1(KODI_ADDON_AUDIOENCODER_HDL hdl, + const uint8_t* pbt_stream, + size_t num_bytes_read); // Added with API 1 + + bool kodi_addon_audioencoder_finish_v1(KODI_ADDON_AUDIOENCODER_HDL hdl); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static ssize_t kodi_addon_audioencoder_write_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const uint8_t* data, + size_t len); // Added with API 1 + + static ssize_t kodi_addon_audioencoder_seek_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + ssize_t pos, + int whence); // Added with API 1 + + directFuncToAddon_addoninstance_audioencoder_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/game.cpp b/xbmc/addons/interface/api/addon-instance/game.cpp new file mode 100644 index 0000000000000..8d9ae01fe145a --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/game.cpp @@ -0,0 +1,518 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "game.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/game.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "games/addons/GameClient.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_game_h::InitDirect(directFuncToKodi_addoninstance_game_h* ifcToKodi, + directFuncToAddon_addoninstance_game_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_addon_game_close_v1 = kodi_addon_game_close_v1; + ifcToKodi->kodi_addon_game_open_stream_v1 = kodi_addon_game_open_stream_v1; + ifcToKodi->kodi_addon_game_get_stream_buffer_v1 = kodi_addon_game_get_stream_buffer_v1; + ifcToKodi->kodi_addon_game_add_stream_data_v1 = kodi_addon_game_add_stream_data_v1; + ifcToKodi->kodi_addon_game_release_stream_buffer_v1 = kodi_addon_game_release_stream_buffer_v1; + ifcToKodi->kodi_addon_game_close_stream_v1 = kodi_addon_game_close_stream_v1; + ifcToKodi->kodi_addon_game_hw_get_proc_address_v1 = kodi_addon_game_hw_get_proc_address_v1; + ifcToKodi->kodi_addon_game_input_event_v1 = kodi_addon_game_input_event_v1; +} + +bool CHdl_kodi_addoninstance_game_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_game_h) + return false; + + switch (func) + { + /* NOTE: Ignored as direct api only is set! */ + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_game_h::{}: addon called with unknown function id '{}' on " + "group 'addoninstance_game_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +KODI_ADDON_GAME_HDL CHdl_kodi_addoninstance_game_h::kodi_addon_game_create_v1( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl) +{ + // Original API call: typedef KODI_ADDON_GAME_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_CREATE_V1)(KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + + return m_ifcToAddon->kodi_addon_game_create_v1(m_ifcToAddon->thisClassHdl, kodi_hdl); +} + +void CHdl_kodi_addoninstance_game_h::kodi_addon_game_destroy_v1(KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_DESTROY_V1)(KODI_ADDON_GAME_HDL hdl); + + m_ifcToAddon->kodi_addon_game_destroy_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_load_game_v1( + const KODI_ADDON_GAME_HDL hdl, const char* url) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_LOAD_GAME_V1)(const KODI_ADDON_GAME_HDL hdl, const char* url); + + return m_ifcToAddon->kodi_addon_game_load_game_v1(m_ifcToAddon->thisClassHdl, hdl, url); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_load_game_special_v1( + const KODI_ADDON_GAME_HDL hdl, enum SPECIAL_GAME_TYPE type, const char** urls, size_t urlCount) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_LOAD_GAME_SPECIAL_V1)(const KODI_ADDON_GAME_HDL hdl, enum SPECIAL_GAME_TYPE type, const char** urls, size_t urlCount); + + return m_ifcToAddon->kodi_addon_game_load_game_special_v1(m_ifcToAddon->thisClassHdl, hdl, type, + urls, urlCount); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_load_standalone_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_LOAD_STANDALONE_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_load_standalone_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_unload_game_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_UNLOAD_GAME_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_unload_game_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_get_game_timing_v1( + const KODI_ADDON_GAME_HDL hdl, struct game_system_timing* timing_info) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_GET_GAME_TIMING_V1)(const KODI_ADDON_GAME_HDL hdl, struct game_system_timing* timing_info); + + return m_ifcToAddon->kodi_addon_game_get_game_timing_v1(m_ifcToAddon->thisClassHdl, hdl, + timing_info); +} + +enum GAME_REGION CHdl_kodi_addoninstance_game_h::kodi_addon_game_get_region_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef enum GAME_REGION(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_GET_REGION_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_get_region_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_requires_game_loop_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_REQUIRES_GAME_LOOP_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_requires_game_loop_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_run_frame_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RUN_FRAME_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_run_frame_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_reset_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RESET_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_reset_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_hw_context_reset_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_HW_CONTEXT_RESET_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_hw_context_reset_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_hw_context_destroy_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_HW_CONTEXT_DESTROY_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_hw_context_destroy_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_has_feature_v1(const KODI_ADDON_GAME_HDL hdl, + const char* controller_id, + const char* feature_name) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_HAS_FEATURE_V1)(const KODI_ADDON_GAME_HDL hdl, const char* controller_id, const char* feature_name); + + return m_ifcToAddon->kodi_addon_game_has_feature_v1(m_ifcToAddon->thisClassHdl, hdl, + controller_id, feature_name); +} + +struct game_input_topology* CHdl_kodi_addoninstance_game_h::kodi_addon_game_get_topology_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef struct game_input_topology*(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_GET_TOPOLOGY_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_get_topology_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_game_h::kodi_addon_game_free_topology_v1( + const KODI_ADDON_GAME_HDL hdl, struct game_input_topology* topology) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_FREE_TOPOLOGY_V1)(const KODI_ADDON_GAME_HDL hdl, struct game_input_topology* topology); + + m_ifcToAddon->kodi_addon_game_free_topology_v1(m_ifcToAddon->thisClassHdl, hdl, topology); +} + +void CHdl_kodi_addoninstance_game_h::kodi_addon_game_set_controller_layouts_v1( + const KODI_ADDON_GAME_HDL hdl, + const struct game_controller_layout* controllers, + size_t controller_count) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_SET_CONTROLLER_LAYOUTS_V1)(const KODI_ADDON_GAME_HDL hdl, const struct game_controller_layout* controllers, size_t controller_count); + + m_ifcToAddon->kodi_addon_game_set_controller_layouts_v1(m_ifcToAddon->thisClassHdl, hdl, + controllers, controller_count); +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_enable_keyboard_v1( + const KODI_ADDON_GAME_HDL hdl, bool enable, const char* controller_id) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_ENABLE_KEYBOARD_V1)(const KODI_ADDON_GAME_HDL hdl, bool enable, const char* controller_id); + + return m_ifcToAddon->kodi_addon_game_enable_keyboard_v1(m_ifcToAddon->thisClassHdl, hdl, enable, + controller_id); +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_enable_mouse_v1(const KODI_ADDON_GAME_HDL hdl, + bool enable, + const char* controller_id) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_ENABLE_MOUSE_V1)(const KODI_ADDON_GAME_HDL hdl, bool enable, const char* controller_id); + + return m_ifcToAddon->kodi_addon_game_enable_mouse_v1(m_ifcToAddon->thisClassHdl, hdl, enable, + controller_id); +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_connect_controller_v1( + const KODI_ADDON_GAME_HDL hdl, + bool connect, + const char* port_address, + const char* controller_id) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_CONNECT_CONTROLLER_V1)(const KODI_ADDON_GAME_HDL hdl, bool connect, const char* port_address, const char* controller_id); + + return m_ifcToAddon->kodi_addon_game_connect_controller_v1(m_ifcToAddon->thisClassHdl, hdl, + connect, port_address, controller_id); +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_input_event_v1( + const KODI_ADDON_GAME_HDL hdl, const struct game_input_event* event) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_INPUT_EVENT_V1)(const KODI_ADDON_GAME_HDL hdl, const struct game_input_event* event); + + return m_ifcToAddon->kodi_addon_game_input_event_v1(m_ifcToAddon->thisClassHdl, hdl, event); +} + +size_t CHdl_kodi_addoninstance_game_h::kodi_addon_game_serialize_size_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef size_t(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_SERIALIZE_SIZE_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_serialize_size_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_serialize_v1( + const KODI_ADDON_GAME_HDL hdl, uint8_t* data, size_t size) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_SERIALIZE_V1)(const KODI_ADDON_GAME_HDL hdl, uint8_t* data, size_t size); + + return m_ifcToAddon->kodi_addon_game_serialize_v1(m_ifcToAddon->thisClassHdl, hdl, data, size); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_deserialize_v1( + const KODI_ADDON_GAME_HDL hdl, const uint8_t* data, size_t size) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_DESERIALIZE_V1)(const KODI_ADDON_GAME_HDL hdl, const uint8_t* data, size_t size); + + return m_ifcToAddon->kodi_addon_game_deserialize_v1(m_ifcToAddon->thisClassHdl, hdl, data, size); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_cheat_reset_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_CHEAT_RESET_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_cheat_reset_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_get_memory_v1( + const KODI_ADDON_GAME_HDL hdl, enum GAME_MEMORY type, uint8_t** data, size_t* size) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_GET_MEMORY_V1)(const KODI_ADDON_GAME_HDL hdl, enum GAME_MEMORY type, uint8_t** data, size_t* size); + + return m_ifcToAddon->kodi_addon_game_get_memory_v1(m_ifcToAddon->thisClassHdl, hdl, type, data, + size); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_set_cheat_v1( + const KODI_ADDON_GAME_HDL hdl, unsigned int index, bool enabled, const char* code) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_SET_CHEAT_V1)(const KODI_ADDON_GAME_HDL hdl, unsigned int index, bool enabled, const char* code); + + return m_ifcToAddon->kodi_addon_game_set_cheat_v1(m_ifcToAddon->thisClassHdl, hdl, index, enabled, + code); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_generate_hash_from_file_v1( + const KODI_ADDON_GAME_HDL hdl, char** hash, unsigned int console_id, const char* file_path) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_GENERATE_HASH_FROM_FILE_V1)(const KODI_ADDON_GAME_HDL hdl, char** hash, unsigned int console_id, const char* file_path); + + return m_ifcToAddon->kodi_addon_game_rc_generate_hash_from_file_v1( + m_ifcToAddon->thisClassHdl, hdl, hash, console_id, file_path); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_get_game_id_url_v1( + const KODI_ADDON_GAME_HDL hdl, char** url, const char* hash) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_GET_GAME_ID_URL_V1)(const KODI_ADDON_GAME_HDL hdl, char** url, const char* hash); + + return m_ifcToAddon->kodi_addon_game_rc_get_game_id_url_v1(m_ifcToAddon->thisClassHdl, hdl, url, + hash); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_get_patch_file_url_v1( + const KODI_ADDON_GAME_HDL hdl, + char** url, + const char* username, + const char* token, + unsigned int game_id) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_GET_PATCH_FILE_URL_V1)(const KODI_ADDON_GAME_HDL hdl, char** url, const char* username, const char* token, unsigned int game_id); + + return m_ifcToAddon->kodi_addon_game_rc_get_patch_file_url_v1(m_ifcToAddon->thisClassHdl, hdl, + url, username, token, game_id); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_post_rich_presence_url_v1( + const KODI_ADDON_GAME_HDL hdl, + char** url, + char** post_data, + const char* username, + const char* token, + unsigned int game_id, + const char* rich_presence) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_POST_RICH_PRESENCE_URL_V1)(const KODI_ADDON_GAME_HDL hdl, char** url, char** post_data, const char* username, const char* token, unsigned int game_id, const char* rich_presence); + + return m_ifcToAddon->kodi_addon_game_rc_post_rich_presence_url_v1( + m_ifcToAddon->thisClassHdl, hdl, url, post_data, username, token, game_id, rich_presence); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_enable_rich_presence_v1( + const KODI_ADDON_GAME_HDL hdl, const char* script) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_ENABLE_RICH_PRESENCE_V1)(const KODI_ADDON_GAME_HDL hdl, const char* script); + + return m_ifcToAddon->kodi_addon_game_rc_enable_rich_presence_v1(m_ifcToAddon->thisClassHdl, hdl, + script); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_get_rich_presence_evaluation_v1( + const KODI_ADDON_GAME_HDL hdl, char** evaluation, unsigned int console_id) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_GET_RICH_PRESENCE_EVALUATION_V1)(const KODI_ADDON_GAME_HDL hdl, char** evaluation, unsigned int console_id); + + return m_ifcToAddon->kodi_addon_game_rc_get_rich_presence_evaluation_v1( + m_ifcToAddon->thisClassHdl, hdl, evaluation, console_id); +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_reset_runtime_v1( + const KODI_ADDON_GAME_HDL hdl) +{ + // Original API call: typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_RESET_RUNTIME_V1)(const KODI_ADDON_GAME_HDL hdl); + + return m_ifcToAddon->kodi_addon_game_rc_reset_runtime_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +// Callbacks from addon to Kodi + +void CHdl_kodi_addoninstance_game_h::kodi_addon_game_close_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::GAME::CGameClient" with "void cb_close_game()" on "games/addons/GameClient.h". + + KODI::GAME::CGameClient* cb = static_cast(hdl); + cb->cb_close_game(); + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GAME_STREAM_HANDLE CHdl_kodi_addoninstance_game_h::kodi_addon_game_open_stream_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const struct game_stream_properties* properties) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::GAME::CGameClient" with "KODI_GAME_STREAM_HANDLE cb_open_stream(const game_stream_properties* properties)" on "games/addons/GameClient.h". + + KODI::GAME::CGameClient* cb = static_cast(hdl); + return cb->cb_open_stream(properties); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_get_stream_buffer_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + unsigned int width, + unsigned int height, + struct game_stream_buffer* buffer) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::GAME::CGameClient" with "bool cb_get_stream_buffer(KODI_GAME_STREAM_HANDLE stream, unsigned int width, unsigned int height, game_stream_buffer* buffer)" on "games/addons/GameClient.h". + + KODI::GAME::CGameClient* cb = static_cast(hdl); + return cb->cb_get_stream_buffer(game_hdl, width, height, buffer); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_game_h::kodi_addon_game_add_stream_data_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + const struct game_stream_packet* packet) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::GAME::CGameClient" with "void cb_add_stream_data(KODI_GAME_STREAM_HANDLE stream, const game_stream_packet* packet)" on "games/addons/GameClient.h". + + KODI::GAME::CGameClient* cb = static_cast(hdl); + cb->cb_add_stream_data(game_hdl, packet); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_game_h::kodi_addon_game_release_stream_buffer_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + struct game_stream_buffer* buffer) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::GAME::CGameClient" with "void cb_release_stream_buffer(KODI_GAME_STREAM_HANDLE stream, game_stream_buffer* buffer)" on "games/addons/GameClient.h". + + KODI::GAME::CGameClient* cb = static_cast(hdl); + cb->cb_release_stream_buffer(game_hdl, buffer); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_game_h::kodi_addon_game_close_stream_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_GAME_STREAM_HANDLE game_hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::GAME::CGameClient" with "void cb_close_stream(KODI_GAME_STREAM_HANDLE stream)" on "games/addons/GameClient.h". + + KODI::GAME::CGameClient* cb = static_cast(hdl); + cb->cb_close_stream(game_hdl); + /*---AUTO_GEN_PARSE---*/ +} + +game_proc_address_t CHdl_kodi_addoninstance_game_h::kodi_addon_game_hw_get_proc_address_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* symbol) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::GAME::CGameClient" with "game_proc_address_t cb_hw_get_proc_address(const char* sym)" on "games/addons/GameClient.h". + + KODI::GAME::CGameClient* cb = static_cast(hdl); + return cb->cb_hw_get_proc_address(symbol); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_input_event_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const struct game_input_event* event) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::GAME::CGameClient" with "bool cb_input_event(const game_input_event* event)" on "games/addons/GameClient.h". + + KODI::GAME::CGameClient* cb = static_cast(hdl); + return cb->cb_input_event(event); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/game.h b/xbmc/addons/interface/api/addon-instance/game.h new file mode 100644 index 0000000000000..1769c34b68846 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/game.h @@ -0,0 +1,233 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/game.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_game_h; +struct directFuncToKodi_addoninstance_game_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_game_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_game_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_game_h* ifcToKodi, + directFuncToAddon_addoninstance_game_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + KODI_ADDON_GAME_HDL kodi_addon_game_create_v1( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); // Added with API 1 + + void kodi_addon_game_destroy_v1(KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_load_game_v1(const KODI_ADDON_GAME_HDL hdl, + const char* url); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_load_game_special_v1(const KODI_ADDON_GAME_HDL hdl, + enum SPECIAL_GAME_TYPE type, + const char** urls, + size_t urlCount); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_load_standalone_v1( + const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_unload_game_v1(const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_get_game_timing_v1( + const KODI_ADDON_GAME_HDL hdl, struct game_system_timing* timing_info); // Added with API 1 + + enum GAME_REGION kodi_addon_game_get_region_v1(const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + bool kodi_addon_game_requires_game_loop_v1(const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_run_frame_v1(const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_reset_v1(const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_hw_context_reset_v1( + const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_hw_context_destroy_v1( + const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + bool kodi_addon_game_has_feature_v1(const KODI_ADDON_GAME_HDL hdl, + const char* controller_id, + const char* feature_name); // Added with API 1 + + struct game_input_topology* kodi_addon_game_get_topology_v1( + const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + void kodi_addon_game_free_topology_v1(const KODI_ADDON_GAME_HDL hdl, + struct game_input_topology* topology); // Added with API 1 + + void kodi_addon_game_set_controller_layouts_v1(const KODI_ADDON_GAME_HDL hdl, + const struct game_controller_layout* controllers, + size_t controller_count); // Added with API 1 + + bool kodi_addon_game_enable_keyboard_v1(const KODI_ADDON_GAME_HDL hdl, + bool enable, + const char* controller_id); // Added with API 1 + + bool kodi_addon_game_enable_mouse_v1(const KODI_ADDON_GAME_HDL hdl, + bool enable, + const char* controller_id); // Added with API 1 + + bool kodi_addon_game_connect_controller_v1(const KODI_ADDON_GAME_HDL hdl, + bool connect, + const char* port_address, + const char* controller_id); // Added with API 1 + + bool kodi_addon_game_input_event_v1(const KODI_ADDON_GAME_HDL hdl, + const struct game_input_event* event); // Added with API 1 + + size_t kodi_addon_game_serialize_size_v1(const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_serialize_v1(const KODI_ADDON_GAME_HDL hdl, + uint8_t* data, + size_t size); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_deserialize_v1(const KODI_ADDON_GAME_HDL hdl, + const uint8_t* data, + size_t size); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_cheat_reset_v1(const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_get_memory_v1(const KODI_ADDON_GAME_HDL hdl, + enum GAME_MEMORY type, + uint8_t** data, + size_t* size); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_set_cheat_v1(const KODI_ADDON_GAME_HDL hdl, + unsigned int index, + bool enabled, + const char* code); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_rc_generate_hash_from_file_v1( + const KODI_ADDON_GAME_HDL hdl, + char** hash, + unsigned int console_id, + const char* file_path); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_rc_get_game_id_url_v1(const KODI_ADDON_GAME_HDL hdl, + char** url, + const char* hash); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_rc_get_patch_file_url_v1( + const KODI_ADDON_GAME_HDL hdl, + char** url, + const char* username, + const char* token, + unsigned int game_id); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_rc_post_rich_presence_url_v1( + const KODI_ADDON_GAME_HDL hdl, + char** url, + char** post_data, + const char* username, + const char* token, + unsigned int game_id, + const char* rich_presence); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_rc_enable_rich_presence_v1( + const KODI_ADDON_GAME_HDL hdl, const char* script); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_rc_get_rich_presence_evaluation_v1( + const KODI_ADDON_GAME_HDL hdl, + char** evaluation, + unsigned int console_id); // Added with API 1 + + enum GAME_ERROR kodi_addon_game_rc_reset_runtime_v1( + const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_addon_game_close_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + static KODI_GAME_STREAM_HANDLE kodi_addon_game_open_stream_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const struct game_stream_properties* properties); // Added with API 1 + + static bool kodi_addon_game_get_stream_buffer_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + unsigned int width, + unsigned int height, + struct game_stream_buffer* buffer); // Added with API 1 + + static void kodi_addon_game_add_stream_data_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + const struct game_stream_packet* packet); // Added with API 1 + + static void kodi_addon_game_release_stream_buffer_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + struct game_stream_buffer* buffer); // Added with API 1 + + static void kodi_addon_game_close_stream_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl); // Added with API 1 + + static game_proc_address_t kodi_addon_game_hw_get_proc_address_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* symbol); // Added with API 1 + + static bool kodi_addon_game_input_event_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const struct game_input_event* event); // Added with API 1 + + directFuncToAddon_addoninstance_game_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/imagedecoder.cpp b/xbmc/addons/interface/api/addon-instance/imagedecoder.cpp new file mode 100644 index 0000000000000..89bac6e40c3a8 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/imagedecoder.cpp @@ -0,0 +1,201 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "imagedecoder.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/imagedecoder.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +#include "addons/ImageDecoder.h" +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_imagedecoder_h::InitDirect( + directFuncToKodi_addoninstance_imagedecoder_h* ifcToKodi, + directFuncToAddon_addoninstance_imagedecoder_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; +} + +bool CHdl_kodi_addoninstance_imagedecoder_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_imagedecoder_h) + return false; + + switch (func) + { + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_imagedecoder_h::{}: addon called with unknown function id " + "'{}' on group 'addoninstance_imagedecoder_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +bool CHdl_kodi_addoninstance_imagedecoder_h::kodi_addon_imagedecoder_supports_file_v1( + const KODI_ADDON_IMAGEDECODER_HDL hdl, const char* file) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_IMAGEDECODER_SUPPORTS_FILE_V1)(const KODI_ADDON_IMAGEDECODER_HDL hdl, const char* file); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_imagedecoder_supports_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_imagedecoder_supports_file_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_imagedecoder_supports_file_v1(PtrValue(hdl), file)); + if (!m_process->SendMessage(funcGroup_addoninstance_imagedecoder_h, + funcChild_kodi_addon_imagedecoder_supports_file_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_imagedecoder_supports_file_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_imagedecoder_supports_file_v1(m_ifcToAddon->thisClassHdl, hdl, + file); +} + +bool CHdl_kodi_addoninstance_imagedecoder_h::kodi_addon_imagedecoder_read_tag_v1( + const KODI_ADDON_IMAGEDECODER_HDL hdl, + const char* file, + struct KODI_ADDON_IMAGEDECODER_INFO_TAG* info) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_IMAGEDECODER_READ_TAG_V1)(const KODI_ADDON_IMAGEDECODER_HDL hdl, const char* file, struct KODI_ADDON_IMAGEDECODER_INFO_TAG* info); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_imagedecoder_read_tag_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_imagedecoder_read_tag_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_imagedecoder_read_tag_v1(PtrValue(hdl), file)); + if (!m_process->SendMessage(funcGroup_addoninstance_imagedecoder_h, + funcChild_kodi_addon_imagedecoder_read_tag_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_imagedecoder_read_tag_v1 t = ident.get().as(); + std::get<1>(t).SetCStructure(info); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_imagedecoder_read_tag_v1(m_ifcToAddon->thisClassHdl, hdl, file, + info); +} + +bool CHdl_kodi_addoninstance_imagedecoder_h::kodi_addon_imagedecoder_load_image_from_memory_v1( + const KODI_ADDON_IMAGEDECODER_HDL hdl, + const char* mimetype, + const uint8_t* buffer, + size_t buf_size, + unsigned int* width, + unsigned int* height) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_IMAGEDECODER_LOAD_IMAGE_FROM_MEMORY_V1)(const KODI_ADDON_IMAGEDECODER_HDL hdl, const char* mimetype, const uint8_t* buffer, size_t buf_size, unsigned int* width, unsigned int* height); + // Tuple in: typedef std::tuple, size_t, unsigned int, unsigned int> msgChild__IN_kodi_addon_imagedecoder_load_image_from_memory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_imagedecoder_load_image_from_memory_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_imagedecoder_load_image_from_memory_v1( + PtrValue(hdl), mimetype, std::vector(buffer, buffer + buf_size), + buf_size, *width, *height)); + if (!m_process->SendMessage(funcGroup_addoninstance_imagedecoder_h, + funcChild_kodi_addon_imagedecoder_load_image_from_memory_v1, in, + out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_imagedecoder_load_image_from_memory_v1 t = + ident.get().as(); + *width = std::get<1>(t); + *height = std::get<2>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_imagedecoder_load_image_from_memory_v1( + m_ifcToAddon->thisClassHdl, hdl, mimetype, buffer, buf_size, width, height); +} + +bool CHdl_kodi_addoninstance_imagedecoder_h::kodi_addon_imagedecoder_decode_v1( + const KODI_ADDON_IMAGEDECODER_HDL hdl, + uint8_t* pixels, + size_t pixels_size, + unsigned int width, + unsigned int height, + unsigned int pitch, + enum ADDON_IMG_FMT format) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_IMAGEDECODER_DECODE_V1)(const KODI_ADDON_IMAGEDECODER_HDL hdl, uint8_t* pixels, size_t pixels_size, unsigned int width, unsigned int height, unsigned int pitch, enum ADDON_IMG_FMT format); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_imagedecoder_decode_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple> msgChild_OUT_kodi_addon_imagedecoder_decode_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_imagedecoder_decode_v1(PtrValue(hdl), pixels_size, + width, height, pitch, format)); + if (!m_process->SendMessage(funcGroup_addoninstance_imagedecoder_h, + funcChild_kodi_addon_imagedecoder_decode_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_imagedecoder_decode_v1 t = ident.get().as(); + std::memcpy(pixels, std::get<1>(t).data(), sizeof(uint8_t) * pixels_size); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_imagedecoder_decode_v1(m_ifcToAddon->thisClassHdl, hdl, pixels, + pixels_size, width, height, pitch, format); +} + +// Callbacks from addon to Kodi +/* NOTE: unused (no callbacks here) */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/imagedecoder.h b/xbmc/addons/interface/api/addon-instance/imagedecoder.h new file mode 100644 index 0000000000000..09caff9d3aade --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/imagedecoder.h @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/imagedecoder.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_imagedecoder_h; +struct directFuncToKodi_addoninstance_imagedecoder_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_imagedecoder_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_imagedecoder_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_imagedecoder_h* ifcToKodi, + directFuncToAddon_addoninstance_imagedecoder_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + bool kodi_addon_imagedecoder_supports_file_v1(const KODI_ADDON_IMAGEDECODER_HDL hdl, + const char* file); // Added with API 1 + + bool kodi_addon_imagedecoder_read_tag_v1( + const KODI_ADDON_IMAGEDECODER_HDL hdl, + const char* file, + struct KODI_ADDON_IMAGEDECODER_INFO_TAG* info); // Added with API 1 + + bool kodi_addon_imagedecoder_load_image_from_memory_v1(const KODI_ADDON_IMAGEDECODER_HDL hdl, + const char* mimetype, + const uint8_t* buffer, + size_t buf_size, + unsigned int* width, + unsigned int* height); // Added with API 1 + + bool kodi_addon_imagedecoder_decode_v1(const KODI_ADDON_IMAGEDECODER_HDL hdl, + uint8_t* pixels, + size_t pixels_size, + unsigned int width, + unsigned int height, + unsigned int pitch, + enum ADDON_IMG_FMT format); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + + directFuncToAddon_addoninstance_imagedecoder_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/inputstream.cpp b/xbmc/addons/interface/api/addon-instance/inputstream.cpp new file mode 100644 index 0000000000000..92d417faac963 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/inputstream.cpp @@ -0,0 +1,404 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "inputstream.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/inputstream.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "cores/VideoPlayer/DVDInputStreams/InputStreamAddon.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_inputstream_h::InitDirect( + directFuncToKodi_addoninstance_inputstream_h* ifcToKodi, + directFuncToAddon_addoninstance_inputstream_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_addon_inputstream_allocate_demux_packet_v1 = + kodi_addon_inputstream_allocate_demux_packet_v1; + ifcToKodi->kodi_addon_inputstream_allocate_encrypted_demux_packet_v1 = + kodi_addon_inputstream_allocate_encrypted_demux_packet_v1; + ifcToKodi->kodi_addon_inputstream_free_demux_packet_v1 = + kodi_addon_inputstream_free_demux_packet_v1; +} + +bool CHdl_kodi_addoninstance_inputstream_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_inputstream_h) + return false; + + switch (func) + { + /* NOTE: Ignored as direct api only is set! */ + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_inputstream_h::{}: addon called with unknown function id " + "'{}' on group 'addoninstance_inputstream_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +KODI_ADDON_INPUTSTREAM_HDL CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_create_v1( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl) +{ + // Original API call: typedef KODI_ADDON_INPUTSTREAM_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_CREATE_V1)(KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + + return m_ifcToAddon->kodi_addon_inputstream_create_v1(m_ifcToAddon->thisClassHdl, kodi_hdl); +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_destroy_v1( + KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DESTROY_V1)(KODI_ADDON_INPUTSTREAM_HDL hdl); + + m_ifcToAddon->kodi_addon_inputstream_destroy_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_open_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_PROPERTY* props) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_OPEN_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_PROPERTY* props); + + return m_ifcToAddon->kodi_addon_inputstream_open_v1(m_ifcToAddon->thisClassHdl, hdl, props); +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_close_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_CLOSE_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + m_ifcToAddon->kodi_addon_inputstream_close_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +const char* CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_path_list_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef const char*(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_PATH_LIST_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + return m_ifcToAddon->kodi_addon_inputstream_get_path_list_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_capabilities_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_CAPABILITIES* capabilities) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_CAPABILITIES_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_CAPABILITIES* capabilities); + + m_ifcToAddon->kodi_addon_inputstream_get_capabilities_v1(m_ifcToAddon->thisClassHdl, hdl, + capabilities); +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_stream_ids_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_IDS* ids) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_STREAM_IDS_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_IDS* ids); + + return m_ifcToAddon->kodi_addon_inputstream_get_stream_ids_v1(m_ifcToAddon->thisClassHdl, hdl, + ids); +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int streamid, + struct INPUTSTREAM_INFO* info, + KODI_OWN_HDL* demuxStream, + PFN_CB_KODI_ADDON_INPUTSTREAM_TRANSFER_STREAM transfer_stream) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_STREAM_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, int streamid, struct INPUTSTREAM_INFO* info, KODI_OWN_HDL* demuxStream, PFN_CB_KODI_ADDON_INPUTSTREAM_TRANSFER_STREAM transfer_stream); + + return m_ifcToAddon->kodi_addon_inputstream_get_stream_v1( + m_ifcToAddon->thisClassHdl, hdl, streamid, info, demuxStream, transfer_stream); +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_enable_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int streamid, bool enable) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_ENABLE_STREAM_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, int streamid, bool enable); + + m_ifcToAddon->kodi_addon_inputstream_enable_stream_v1(m_ifcToAddon->thisClassHdl, hdl, streamid, + enable); +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_open_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int streamid) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_OPEN_STREAM_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, int streamid); + + return m_ifcToAddon->kodi_addon_inputstream_open_stream_v1(m_ifcToAddon->thisClassHdl, hdl, + streamid); +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_reset_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_RESET_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + m_ifcToAddon->kodi_addon_inputstream_demux_reset_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_abort_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_ABORT_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + m_ifcToAddon->kodi_addon_inputstream_demux_abort_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_flush_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_FLUSH_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + m_ifcToAddon->kodi_addon_inputstream_demux_flush_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +struct DEMUX_PACKET* CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_read_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef struct DEMUX_PACKET*(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_READ_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + return m_ifcToAddon->kodi_addon_inputstream_demux_read_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_seek_time_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, double time, bool backwards, double* startpts) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_SEEK_TIME_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, double time, bool backwards, double* startpts); + + return m_ifcToAddon->kodi_addon_inputstream_demux_seek_time_v1(m_ifcToAddon->thisClassHdl, hdl, + time, backwards, startpts); +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_set_speed_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int speed) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_SET_SPEED_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, int speed); + + m_ifcToAddon->kodi_addon_inputstream_demux_set_speed_v1(m_ifcToAddon->thisClassHdl, hdl, speed); +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_set_video_resolution_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int width, int height) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_SET_VIDEO_RESOLUTION_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, int width, int height); + + m_ifcToAddon->kodi_addon_inputstream_set_video_resolution_v1(m_ifcToAddon->thisClassHdl, hdl, + width, height); +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_total_time_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_TOTAL_TIME_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + return m_ifcToAddon->kodi_addon_inputstream_get_total_time_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_time_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_TIME_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + return m_ifcToAddon->kodi_addon_inputstream_get_time_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_times_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_TIMES* times) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_TIMES_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_TIMES* times); + + return m_ifcToAddon->kodi_addon_inputstream_get_times_v1(m_ifcToAddon->thisClassHdl, hdl, times); +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_pos_time_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int ms) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_POS_TIME_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, int ms); + + return m_ifcToAddon->kodi_addon_inputstream_pos_time_v1(m_ifcToAddon->thisClassHdl, hdl, ms); +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_read_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, uint8_t* buffer, unsigned int bufferSize) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_READ_STREAM_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, uint8_t* buffer, unsigned int bufferSize); + + return m_ifcToAddon->kodi_addon_inputstream_read_stream_v1(m_ifcToAddon->thisClassHdl, hdl, + buffer, bufferSize); +} + +int64_t CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_seek_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int64_t position, int whence) +{ + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_SEEK_STREAM_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, int64_t position, int whence); + + return m_ifcToAddon->kodi_addon_inputstream_seek_stream_v1(m_ifcToAddon->thisClassHdl, hdl, + position, whence); +} + +int64_t CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_position_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_POSITION_STREAM_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + return m_ifcToAddon->kodi_addon_inputstream_position_stream_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +int64_t CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_length_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_LENGTH_STREAM_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + return m_ifcToAddon->kodi_addon_inputstream_length_stream_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_is_real_time_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_IS_REAL_TIME_STREAM_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + return m_ifcToAddon->kodi_addon_inputstream_is_real_time_stream_v1(m_ifcToAddon->thisClassHdl, + hdl); +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_chapter_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + return m_ifcToAddon->kodi_addon_inputstream_get_chapter_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_chapter_count_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_COUNT_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + return m_ifcToAddon->kodi_addon_inputstream_get_chapter_count_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +const char* CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_chapter_name_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch) +{ + // Original API call: typedef const char*(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_NAME_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch); + + return m_ifcToAddon->kodi_addon_inputstream_get_chapter_name_v1(m_ifcToAddon->thisClassHdl, hdl, + ch); +} + +int64_t CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_chapter_pos_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch) +{ + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_POS_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch); + + return m_ifcToAddon->kodi_addon_inputstream_get_chapter_pos_v1(m_ifcToAddon->thisClassHdl, hdl, + ch); +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_seek_chapter_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_SEEK_CHAPTER_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch); + + return m_ifcToAddon->kodi_addon_inputstream_seek_chapter_v1(m_ifcToAddon->thisClassHdl, hdl, ch); +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_block_size_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_BLOCK_SIZE_STREAM_V1)(const KODI_ADDON_INPUTSTREAM_HDL hdl); + + return m_ifcToAddon->kodi_addon_inputstream_block_size_stream_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +// Callbacks from addon to Kodi + +struct DEMUX_PACKET* CHdl_kodi_addoninstance_inputstream_h:: + kodi_addon_inputstream_allocate_demux_packet_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + int data_size) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "CInputStreamAddon" with "DEMUX_PACKET* cb_allocate_demux_packet(int iDataSize = 0)" on "cores/VideoPlayer/DVDInputStreams/InputStreamAddon.h". + + CInputStreamAddon* cb = static_cast(hdl); + return cb->cb_allocate_demux_packet(data_size); + /*---AUTO_GEN_PARSE---*/ +} + +struct DEMUX_PACKET* CHdl_kodi_addoninstance_inputstream_h:: + kodi_addon_inputstream_allocate_encrypted_demux_packet_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + unsigned int data_size, + unsigned int encrypted_subsample_count) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "CInputStreamAddon" with "DEMUX_PACKET* cb_allocate_encrypted_demux_packet(unsigned int dataSize, unsigned int encryptedSubsampleCount)" on "cores/VideoPlayer/DVDInputStreams/InputStreamAddon.h". + + CInputStreamAddon* cb = static_cast(hdl); + return cb->cb_allocate_encrypted_demux_packet(data_size, encrypted_subsample_count); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_free_demux_packet_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct DEMUX_PACKET* packet) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "CInputStreamAddon" with "void cb_free_demux_packet(DEMUX_PACKET* pPacket)" on "cores/VideoPlayer/DVDInputStreams/InputStreamAddon.h". + + CInputStreamAddon* cb = static_cast(hdl); + cb->cb_free_demux_packet(packet); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/inputstream.h b/xbmc/addons/interface/api/addon-instance/inputstream.h new file mode 100644 index 0000000000000..5bd7bbda8e8c4 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/inputstream.h @@ -0,0 +1,185 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/inputstream.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_inputstream_h; +struct directFuncToKodi_addoninstance_inputstream_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_inputstream_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_inputstream_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_inputstream_h* ifcToKodi, + directFuncToAddon_addoninstance_inputstream_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + KODI_ADDON_INPUTSTREAM_HDL kodi_addon_inputstream_create_v1( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); // Added with API 1 + + void kodi_addon_inputstream_destroy_v1(KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + bool kodi_addon_inputstream_open_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_PROPERTY* props); // Added with API 1 + + void kodi_addon_inputstream_close_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + const char* kodi_addon_inputstream_get_path_list_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + void kodi_addon_inputstream_get_capabilities_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_CAPABILITIES* capabilities); // Added with API 1 + + bool kodi_addon_inputstream_get_stream_ids_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_IDS* ids); // Added with API 1 + + bool kodi_addon_inputstream_get_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int streamid, + struct INPUTSTREAM_INFO* info, + KODI_OWN_HDL* demuxStream, + PFN_CB_KODI_ADDON_INPUTSTREAM_TRANSFER_STREAM transfer_stream); // Added with API 1 + + void kodi_addon_inputstream_enable_stream_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + int streamid, + bool enable); // Added with API 1 + + bool kodi_addon_inputstream_open_stream_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + int streamid); // Added with API 1 + + void kodi_addon_inputstream_demux_reset_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + void kodi_addon_inputstream_demux_abort_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + void kodi_addon_inputstream_demux_flush_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + struct DEMUX_PACKET* kodi_addon_inputstream_demux_read_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + bool kodi_addon_inputstream_demux_seek_time_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + double time, + bool backwards, + double* startpts); // Added with API 1 + + void kodi_addon_inputstream_demux_set_speed_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + int speed); // Added with API 1 + + void kodi_addon_inputstream_set_video_resolution_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + int width, + int height); // Added with API 1 + + int kodi_addon_inputstream_get_total_time_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + int kodi_addon_inputstream_get_time_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + bool kodi_addon_inputstream_get_times_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_TIMES* times); // Added with API 1 + + bool kodi_addon_inputstream_pos_time_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + int ms); // Added with API 1 + + int kodi_addon_inputstream_read_stream_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + uint8_t* buffer, + unsigned int bufferSize); // Added with API 1 + + int64_t kodi_addon_inputstream_seek_stream_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + int64_t position, + int whence); // Added with API 1 + + int64_t kodi_addon_inputstream_position_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + int64_t kodi_addon_inputstream_length_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + bool kodi_addon_inputstream_is_real_time_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + int kodi_addon_inputstream_get_chapter_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + int kodi_addon_inputstream_get_chapter_count_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + const char* kodi_addon_inputstream_get_chapter_name_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + int ch); // Added with API 1 + + int64_t kodi_addon_inputstream_get_chapter_pos_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + int ch); // Added with API 1 + + bool kodi_addon_inputstream_seek_chapter_v1(const KODI_ADDON_INPUTSTREAM_HDL hdl, + int ch); // Added with API 1 + + int kodi_addon_inputstream_block_size_stream_v1( + const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static struct DEMUX_PACKET* kodi_addon_inputstream_allocate_demux_packet_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, int data_size); // Added with API 1 + + static struct DEMUX_PACKET* kodi_addon_inputstream_allocate_encrypted_demux_packet_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + unsigned int data_size, + unsigned int encrypted_subsample_count); // Added with API 1 + + static void kodi_addon_inputstream_free_demux_packet_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct DEMUX_PACKET* packet); // Added with API 1 + + directFuncToAddon_addoninstance_inputstream_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/peripheral.cpp b/xbmc/addons/interface/api/addon-instance/peripheral.cpp new file mode 100644 index 0000000000000..99f659c3d67e6 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/peripheral.cpp @@ -0,0 +1,344 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "peripheral.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/peripheral.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "peripherals/addons/PeripheralAddon.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_peripheral_h::InitDirect( + directFuncToKodi_addoninstance_peripheral_h* ifcToKodi, + directFuncToAddon_addoninstance_peripheral_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_addon_peripheral_trigger_scan_v1 = kodi_addon_peripheral_trigger_scan_v1; + ifcToKodi->kodi_addon_peripheral_refresh_button_maps_v1 = + kodi_addon_peripheral_refresh_button_maps_v1; + ifcToKodi->kodi_addon_peripheral_feature_count_v1 = kodi_addon_peripheral_feature_count_v1; + ifcToKodi->kodi_addon_peripheral_feature_type_v1 = kodi_addon_peripheral_feature_type_v1; +} + +bool CHdl_kodi_addoninstance_peripheral_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_peripheral_h) + return false; + + switch (func) + { + /* NOTE: Ignored as direct api only is set! */ + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_peripheral_h::{}: addon called with unknown function id " + "'{}' on group 'addoninstance_peripheral_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +KODI_ADDON_PERIPHERAL_HDL CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_create_v1( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl) +{ + // Original API call: typedef KODI_ADDON_PERIPHERAL_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_CREATE_V1)(KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + + return m_ifcToAddon->kodi_addon_peripheral_create_v1(m_ifcToAddon->thisClassHdl, kodi_hdl); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_destroy_v1( + KODI_ADDON_PERIPHERAL_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_DESTROY_V1)(KODI_ADDON_PERIPHERAL_HDL hdl); + + m_ifcToAddon->kodi_addon_peripheral_destroy_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_get_capabilities_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_CAPABILITIES* capabilities) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_GET_CAPABILITIES_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_CAPABILITIES* capabilities); + + m_ifcToAddon->kodi_addon_peripheral_get_capabilities_v1(m_ifcToAddon->thisClassHdl, hdl, + capabilities); +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h:: + kodi_addon_peripheral_perform_device_scan_v1(KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_INFO** scan_results, + size_t* peripheral_count) +{ + // Original API call: typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_PERFORM_DEVICE_SCAN_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_INFO** scan_results, size_t* peripheral_count); + + return m_ifcToAddon->kodi_addon_peripheral_perform_device_scan_v1(m_ifcToAddon->thisClassHdl, hdl, + scan_results, peripheral_count); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_free_scan_results_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_INFO* scan_results, size_t peripheral_count) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FREE_SCAN_RESULTS_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_INFO* scan_results, size_t peripheral_count); + + m_ifcToAddon->kodi_addon_peripheral_free_scan_results_v1(m_ifcToAddon->thisClassHdl, hdl, + scan_results, peripheral_count); +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_get_events_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_EVENT** events, size_t* event_count) +{ + // Original API call: typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_GET_EVENTS_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_EVENT** events, size_t* event_count); + + return m_ifcToAddon->kodi_addon_peripheral_get_events_v1(m_ifcToAddon->thisClassHdl, hdl, events, + event_count); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_free_events_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_EVENT* events, size_t event_count) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FREE_EVENTS_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_EVENT* events, size_t event_count); + + m_ifcToAddon->kodi_addon_peripheral_free_events_v1(m_ifcToAddon->thisClassHdl, hdl, events, + event_count); +} + +bool CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_send_event_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, const struct PERIPHERAL_EVENT* event) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_SEND_EVENT_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, const struct PERIPHERAL_EVENT* event); + + return m_ifcToAddon->kodi_addon_peripheral_send_event_v1(m_ifcToAddon->thisClassHdl, hdl, event); +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h:: + kodi_addon_peripheral_get_joystick_info_v1(KODI_ADDON_PERIPHERAL_HDL hdl, + unsigned int index, + struct JOYSTICK_INFO* info) +{ + // Original API call: typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_GET_JOYSTICK_INFO_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, unsigned int index, struct JOYSTICK_INFO* info); + + return m_ifcToAddon->kodi_addon_peripheral_get_joystick_info_v1(m_ifcToAddon->thisClassHdl, hdl, + index, info); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_free_joystick_info_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, struct JOYSTICK_INFO* info) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FREE_JOYSTICK_INFO_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, struct JOYSTICK_INFO* info); + + m_ifcToAddon->kodi_addon_peripheral_free_joystick_info_v1(m_ifcToAddon->thisClassHdl, hdl, info); +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_get_features_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id, + struct JOYSTICK_FEATURE** features, + size_t* feature_count) +{ + // Original API call: typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_GET_FEATURES_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick, const char* controller_id, struct JOYSTICK_FEATURE** features, size_t* feature_count); + + return m_ifcToAddon->kodi_addon_peripheral_get_features_v1( + m_ifcToAddon->thisClassHdl, hdl, joystick, controller_id, features, feature_count); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_free_features_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, struct JOYSTICK_FEATURE* features, size_t feature_count) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FREE_FEATURES_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, struct JOYSTICK_FEATURE* features, size_t feature_count); + + m_ifcToAddon->kodi_addon_peripheral_free_features_v1(m_ifcToAddon->thisClassHdl, hdl, features, + feature_count); +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_map_features_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id, + const struct JOYSTICK_FEATURE* features, + size_t feature_count) +{ + // Original API call: typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_MAP_FEATURES_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick, const char* controller_id, const struct JOYSTICK_FEATURE* features, size_t feature_count); + + return m_ifcToAddon->kodi_addon_peripheral_map_features_v1( + m_ifcToAddon->thisClassHdl, hdl, joystick, controller_id, features, feature_count); +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h:: + kodi_addon_peripheral_get_ignored_primitives_v1(KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + struct JOYSTICK_DRIVER_PRIMITIVE** primitives, + size_t* primitive_count) +{ + // Original API call: typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_GET_IGNORED_PRIMITIVES_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick, struct JOYSTICK_DRIVER_PRIMITIVE** primitives, size_t* primitive_count); + + return m_ifcToAddon->kodi_addon_peripheral_get_ignored_primitives_v1( + m_ifcToAddon->thisClassHdl, hdl, joystick, primitives, primitive_count); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_free_primitives_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FREE_PRIMITIVES_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, struct JOYSTICK_DRIVER_PRIMITIVE* primitives, size_t primitive_count); + + m_ifcToAddon->kodi_addon_peripheral_free_primitives_v1(m_ifcToAddon->thisClassHdl, hdl, + primitives, primitive_count); +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h:: + kodi_addon_peripheral_set_ignored_primitives_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const struct JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count) +{ + // Original API call: typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_SET_IGNORED_PRIMITIVES_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick, const struct JOYSTICK_DRIVER_PRIMITIVE* primitives, size_t primitive_count); + + return m_ifcToAddon->kodi_addon_peripheral_set_ignored_primitives_v1( + m_ifcToAddon->thisClassHdl, hdl, joystick, primitives, primitive_count); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_save_button_map_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_SAVE_BUTTON_MAP_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick); + + m_ifcToAddon->kodi_addon_peripheral_save_button_map_v1(m_ifcToAddon->thisClassHdl, hdl, joystick); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_revert_button_map_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_REVERT_BUTTON_MAP_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick); + + m_ifcToAddon->kodi_addon_peripheral_revert_button_map_v1(m_ifcToAddon->thisClassHdl, hdl, + joystick); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_reset_button_map_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick, const char* controller_id) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_RESET_BUTTON_MAP_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick, const char* controller_id); + + m_ifcToAddon->kodi_addon_peripheral_reset_button_map_v1(m_ifcToAddon->thisClassHdl, hdl, joystick, + controller_id); +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_power_off_joystick_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, unsigned int index) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_POWER_OFF_JOYSTICK_V1)(KODI_ADDON_PERIPHERAL_HDL hdl, unsigned int index); + + m_ifcToAddon->kodi_addon_peripheral_power_off_joystick_v1(m_ifcToAddon->thisClassHdl, hdl, index); +} + +// Callbacks from addon to Kodi + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_trigger_scan_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PERIPHERALS::CPeripheralAddon" with "void TriggerDeviceScan()" on "peripherals/addons/PeripheralAddon.h". + + PERIPHERALS::CPeripheralAddon* cb = static_cast(hdl); + cb->TriggerDeviceScan(); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_refresh_button_maps_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* device_name, + const char* controller_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PERIPHERALS::CPeripheralAddon" with "void RefreshButtonMaps(const std::string& strDeviceName, const std::string& controllerId = "")" on "peripherals/addons/PeripheralAddon.h". + + PERIPHERALS::CPeripheralAddon* cb = static_cast(hdl); + cb->RefreshButtonMaps(device_name, controller_id); + /*---AUTO_GEN_PARSE---*/ +} + +unsigned int CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_feature_count_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* controller_id, + enum JOYSTICK_FEATURE_TYPE type) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PERIPHERALS::CPeripheralAddon" with "unsigned int FeatureCount(const std::string& controllerId, JOYSTICK_FEATURE_TYPE type) const" on "peripherals/addons/PeripheralAddon.h". + + PERIPHERALS::CPeripheralAddon* cb = static_cast(hdl); + return cb->FeatureCount(controller_id, type); + /*---AUTO_GEN_PARSE---*/ +} + +enum JOYSTICK_FEATURE_TYPE CHdl_kodi_addoninstance_peripheral_h:: + kodi_addon_peripheral_feature_type_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* controller_id, + const char* feature_name) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return JOYSTICK_FEATURE_TYPE_UNKNOWN; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PERIPHERALS::CPeripheralAddon" with "JOYSTICK_FEATURE_TYPE FeatureType(const std::string& controllerId, const std::string& featureName) const" on "peripherals/addons/PeripheralAddon.h". + + PERIPHERALS::CPeripheralAddon* cb = static_cast(hdl); + return cb->FeatureType(controller_id, feature_name); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/peripheral.h b/xbmc/addons/interface/api/addon-instance/peripheral.h new file mode 100644 index 0000000000000..c027b5e1822fb --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/peripheral.h @@ -0,0 +1,173 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/peripheral.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_peripheral_h; +struct directFuncToKodi_addoninstance_peripheral_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_peripheral_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_peripheral_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_peripheral_h* ifcToKodi, + directFuncToAddon_addoninstance_peripheral_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + KODI_ADDON_PERIPHERAL_HDL kodi_addon_peripheral_create_v1( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); // Added with API 1 + + void kodi_addon_peripheral_destroy_v1(KODI_ADDON_PERIPHERAL_HDL hdl); // Added with API 1 + + void kodi_addon_peripheral_get_capabilities_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_CAPABILITIES* capabilities); // Added with API 1 + + enum PERIPHERAL_ERROR kodi_addon_peripheral_perform_device_scan_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_INFO** scan_results, + size_t* peripheral_count); // Added with API 1 + + void kodi_addon_peripheral_free_scan_results_v1(KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_INFO* scan_results, + size_t peripheral_count); // Added with API 1 + + enum PERIPHERAL_ERROR kodi_addon_peripheral_get_events_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_EVENT** events, + size_t* event_count); // Added with API 1 + + void kodi_addon_peripheral_free_events_v1(KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_EVENT* events, + size_t event_count); // Added with API 1 + + bool kodi_addon_peripheral_send_event_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, const struct PERIPHERAL_EVENT* event); // Added with API 1 + + enum PERIPHERAL_ERROR kodi_addon_peripheral_get_joystick_info_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + unsigned int index, + struct JOYSTICK_INFO* info); // Added with API 1 + + void kodi_addon_peripheral_free_joystick_info_v1(KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_INFO* info); // Added with API 1 + + enum PERIPHERAL_ERROR kodi_addon_peripheral_get_features_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id, + struct JOYSTICK_FEATURE** features, + size_t* feature_count); // Added with API 1 + + void kodi_addon_peripheral_free_features_v1(KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_FEATURE* features, + size_t feature_count); // Added with API 1 + + enum PERIPHERAL_ERROR kodi_addon_peripheral_map_features_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id, + const struct JOYSTICK_FEATURE* features, + size_t feature_count); // Added with API 1 + + enum PERIPHERAL_ERROR kodi_addon_peripheral_get_ignored_primitives_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + struct JOYSTICK_DRIVER_PRIMITIVE** primitives, + size_t* primitive_count); // Added with API 1 + + void kodi_addon_peripheral_free_primitives_v1(KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count); // Added with API 1 + + enum PERIPHERAL_ERROR kodi_addon_peripheral_set_ignored_primitives_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const struct JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count); // Added with API 1 + + void kodi_addon_peripheral_save_button_map_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick); // Added with API 1 + + void kodi_addon_peripheral_revert_button_map_v1( + KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick); // Added with API 1 + + void kodi_addon_peripheral_reset_button_map_v1(KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id); // Added with API 1 + + void kodi_addon_peripheral_power_off_joystick_v1(KODI_ADDON_PERIPHERAL_HDL hdl, + unsigned int index); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_addon_peripheral_trigger_scan_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + static void kodi_addon_peripheral_refresh_button_maps_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* device_name, + const char* controller_id); // Added with API 1 + + static unsigned int kodi_addon_peripheral_feature_count_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* controller_id, + enum JOYSTICK_FEATURE_TYPE type); // Added with API 1 + + static enum JOYSTICK_FEATURE_TYPE kodi_addon_peripheral_feature_type_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* controller_id, + const char* feature_name); // Added with API 1 + + directFuncToAddon_addoninstance_peripheral_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/pvr.cpp b/xbmc/addons/interface/api/addon-instance/pvr.cpp new file mode 100644 index 0000000000000..9c14823f0cfdc --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/pvr.cpp @@ -0,0 +1,2230 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "pvr.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/pvr.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "pvr/addons/PVRClient.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_pvr_h::InitDirect(directFuncToKodi_addoninstance_pvr_h* ifcToKodi, + directFuncToAddon_addoninstance_pvr_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_addon_pvr_get_epg_max_future_days_v1 = kodi_addon_pvr_get_epg_max_future_days_v1; + ifcToKodi->kodi_addon_pvr_get_epg_max_past_days_v1 = kodi_addon_pvr_get_epg_max_past_days_v1; + ifcToKodi->kodi_addon_pvr_add_menu_hook_v1 = kodi_addon_pvr_add_menu_hook_v1; + ifcToKodi->kodi_addon_pvr_recording_notification_v1 = kodi_addon_pvr_recording_notification_v1; + ifcToKodi->kodi_addon_pvr_connection_state_change_v1 = kodi_addon_pvr_connection_state_change_v1; + ifcToKodi->kodi_addon_pvr_epg_event_state_change_v1 = kodi_addon_pvr_epg_event_state_change_v1; + ifcToKodi->kodi_addon_pvr_transfer_channel_entry_v1 = kodi_addon_pvr_transfer_channel_entry_v1; + ifcToKodi->kodi_addon_pvr_transfer_provider_entry_v1 = kodi_addon_pvr_transfer_provider_entry_v1; + ifcToKodi->kodi_addon_pvr_transfer_channel_group_v1 = kodi_addon_pvr_transfer_channel_group_v1; + ifcToKodi->kodi_addon_pvr_transfer_channel_group_member_v1 = + kodi_addon_pvr_transfer_channel_group_member_v1; + ifcToKodi->kodi_addon_pvr_transfer_epg_entry_v1 = kodi_addon_pvr_transfer_epg_entry_v1; + ifcToKodi->kodi_addon_pvr_transfer_recording_entry_v1 = + kodi_addon_pvr_transfer_recording_entry_v1; + ifcToKodi->kodi_addon_pvr_transfer_timer_entry_v1 = kodi_addon_pvr_transfer_timer_entry_v1; + ifcToKodi->kodi_addon_pvr_trigger_channel_update_v1 = kodi_addon_pvr_trigger_channel_update_v1; + ifcToKodi->kodi_addon_pvr_trigger_providers_update_v1 = + kodi_addon_pvr_trigger_providers_update_v1; + ifcToKodi->kodi_addon_pvr_trigger_channel_groups_update_v1 = + kodi_addon_pvr_trigger_channel_groups_update_v1; + ifcToKodi->kodi_addon_pvr_trigger_epg_update_v1 = kodi_addon_pvr_trigger_epg_update_v1; + ifcToKodi->kodi_addon_pvr_trigger_recording_update_v1 = + kodi_addon_pvr_trigger_recording_update_v1; + ifcToKodi->kodi_addon_pvr_trigger_timer_update_v1 = kodi_addon_pvr_trigger_timer_update_v1; +} + +bool CHdl_kodi_addoninstance_pvr_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_pvr_h) + return false; + + switch (func) + { + case funcParent_kodi_addon_pvr_get_epg_max_future_days_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_addon_pvr_get_epg_max_future_days(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_get_epg_max_future_days_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_get_epg_max_future_days_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_get_epg_max_future_days_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_addon_pvr_get_epg_max_future_days_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_addon_pvr_get_epg_max_future_days_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_pvr_get_epg_max_past_days_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_addon_pvr_get_epg_max_past_days(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_get_epg_max_past_days_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_get_epg_max_past_days_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_get_epg_max_past_days_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_addon_pvr_get_epg_max_past_days_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_addon_pvr_get_epg_max_past_days_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_pvr_add_menu_hook_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_add_menu_hook(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const struct PVR_MENUHOOK* hook) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_add_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_add_menu_hook_v1; /* Autogenerated */ + PVR_MENUHOOK hook; + msgParent__IN_kodi_addon_pvr_add_menu_hook_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + std::get<1>(t).SetCStructure(&hook); + kodi_addon_pvr_add_menu_hook_v1(this, hdl, &hook); + return true; + } + case funcParent_kodi_addon_pvr_recording_notification_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_recording_notification(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* name, const char* fileName, bool on) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_recording_notification_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_recording_notification_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_recording_notification_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& name = std::get<1>(t); + const std::string& fileName = std::get<2>(t); + bool on = std::get<3>(t); + kodi_addon_pvr_recording_notification_v1(this, hdl, name.c_str(), fileName.c_str(), on); + return true; + } + case funcParent_kodi_addon_pvr_connection_state_change_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_connection_state_change(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* strConnectionString, enum PVR_CONNECTION_STATE newState, const char* strMessage) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_connection_state_change_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_connection_state_change_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_connection_state_change_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& strConnectionString = std::get<1>(t); + enum PVR_CONNECTION_STATE newState = std::get<2>(t); + const std::string& strMessage = std::get<3>(t); + kodi_addon_pvr_connection_state_change_v1(this, hdl, strConnectionString.c_str(), newState, + strMessage.c_str()); + return true; + } + case funcParent_kodi_addon_pvr_epg_event_state_change_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_epg_event_state_change(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct EPG_TAG* tag, enum EPG_EVENT_STATE newState) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_epg_event_state_change_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_epg_event_state_change_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_epg_event_state_change_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + enum EPG_EVENT_STATE newState = std::get<1>(t); + struct EPG_TAG tag = {}; + kodi_addon_pvr_epg_event_state_change_v1(this, hdl, &tag, newState); + msgpack::pack(out, msgParent_OUT_kodi_addon_pvr_epg_event_state_change_v1(&tag)); + return true; + } + case funcParent_kodi_addon_pvr_transfer_channel_entry_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_entry( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_CHANNEL* chan) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_channel_entry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_channel_entry_v1; /* Autogenerated */ + PVR_CHANNEL chan; + msgParent__IN_kodi_addon_pvr_transfer_channel_entry_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + std::get<2>(t).SetCStructure(&chan); + kodi_addon_pvr_transfer_channel_entry_v1(this, hdl, handle, &chan); + return true; + } + case funcParent_kodi_addon_pvr_transfer_provider_entry_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_provider_entry( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_PROVIDER* chanProvider) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_provider_entry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_provider_entry_v1; /* Autogenerated */ + PVR_PROVIDER chanProvider; + msgParent__IN_kodi_addon_pvr_transfer_provider_entry_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + std::get<2>(t).SetCStructure(&chanProvider); + kodi_addon_pvr_transfer_provider_entry_v1(this, hdl, handle, &chanProvider); + return true; + } + case funcParent_kodi_addon_pvr_transfer_channel_group_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_group( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_CHANNEL_GROUP* group) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_channel_group_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_channel_group_v1; /* Autogenerated */ + PVR_CHANNEL_GROUP group; + msgParent__IN_kodi_addon_pvr_transfer_channel_group_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + std::get<2>(t).SetCStructure(&group); + kodi_addon_pvr_transfer_channel_group_v1(this, hdl, handle, &group); + return true; + } + case funcParent_kodi_addon_pvr_transfer_channel_group_member_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_group_member( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_CHANNEL_GROUP_MEMBER* member) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_channel_group_member_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_channel_group_member_v1; /* Autogenerated */ + PVR_CHANNEL_GROUP_MEMBER member; + msgParent__IN_kodi_addon_pvr_transfer_channel_group_member_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + std::get<2>(t).SetCStructure(&member); + kodi_addon_pvr_transfer_channel_group_member_v1(this, hdl, handle, &member); + return true; + } + case funcParent_kodi_addon_pvr_transfer_epg_entry_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_epg_entry(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct EPG_TAG* epgentry) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_epg_entry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_epg_entry_v1; /* Autogenerated */ + EPG_TAG epgentry; + msgParent__IN_kodi_addon_pvr_transfer_epg_entry_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + std::get<2>(t).SetCStructure(&epgentry); + kodi_addon_pvr_transfer_epg_entry_v1(this, hdl, handle, &epgentry); + return true; + } + case funcParent_kodi_addon_pvr_transfer_recording_entry_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_recording_entry( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_RECORDING* recording) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_recording_entry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_recording_entry_v1; /* Autogenerated */ + PVR_RECORDING recording; + msgParent__IN_kodi_addon_pvr_transfer_recording_entry_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + std::get<2>(t).SetCStructure(&recording); + kodi_addon_pvr_transfer_recording_entry_v1(this, hdl, handle, &recording); + return true; + } + case funcParent_kodi_addon_pvr_transfer_timer_entry_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_timer_entry(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_TIMER* timer) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_timer_entry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_timer_entry_v1; /* Autogenerated */ + PVR_TIMER timer; + msgParent__IN_kodi_addon_pvr_transfer_timer_entry_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + std::get<2>(t).SetCStructure(&timer); + kodi_addon_pvr_transfer_timer_entry_v1(this, hdl, handle, &timer); + return true; + } + case funcParent_kodi_addon_pvr_trigger_channel_update_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_channel_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_channel_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_channel_update_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_trigger_channel_update_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + kodi_addon_pvr_trigger_channel_update_v1(this, hdl); + return true; + } + case funcParent_kodi_addon_pvr_trigger_providers_update_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_providers_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_providers_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_providers_update_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_trigger_providers_update_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + kodi_addon_pvr_trigger_providers_update_v1(this, hdl); + return true; + } + case funcParent_kodi_addon_pvr_trigger_channel_groups_update_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_channel_groups_update( KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_channel_groups_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_channel_groups_update_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_trigger_channel_groups_update_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + kodi_addon_pvr_trigger_channel_groups_update_v1(this, hdl); + return true; + } + case funcParent_kodi_addon_pvr_trigger_epg_update_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_epg_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, unsigned int iChannelUid) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_epg_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_epg_update_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_trigger_epg_update_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + unsigned int iChannelUid = std::get<1>(t); + kodi_addon_pvr_trigger_epg_update_v1(this, hdl, iChannelUid); + return true; + } + case funcParent_kodi_addon_pvr_trigger_recording_update_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_recording_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_recording_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_recording_update_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_trigger_recording_update_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + kodi_addon_pvr_trigger_recording_update_v1(this, hdl); + return true; + } + case funcParent_kodi_addon_pvr_trigger_timer_update_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_timer_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_timer_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_timer_update_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_pvr_trigger_timer_update_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + kodi_addon_pvr_trigger_timer_update_v1(this, hdl); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_pvr_h::{}: addon called with unknown function id '{}' on " + "group 'addoninstance_pvr_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_capabilities_v1( + KODI_ADDON_PVR_HDL hdl, struct PVR_ADDON_CAPABILITIES* capabilities) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CAPABILITIES_V1)(KODI_ADDON_PVR_HDL hdl, struct PVR_ADDON_CAPABILITIES* capabilities); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_capabilities_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_capabilities_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_capabilities_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_capabilities_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_capabilities_v1 t = ident.get().as(); + std::get<1>(t).SetCStructure(capabilities); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_capabilities_v1(m_ifcToAddon->thisClassHdl, hdl, + capabilities); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_backend_name_v1( + KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_BACKEND_NAME_V1)(KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_backend_name_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_backend_name_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_backend_name_v1(PtrValue(hdl), mem_size)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_backend_name_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_backend_name_v1 t = ident.get().as(); + strncpy(str, std::get<1>(t).c_str(), mem_size); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_backend_name_v1(m_ifcToAddon->thisClassHdl, hdl, str, + mem_size); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_backend_version_v1( + KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_BACKEND_VERSION_V1)(KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_backend_version_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_backend_version_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_backend_version_v1(PtrValue(hdl), mem_size)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_backend_version_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_backend_version_v1 t = ident.get().as(); + strncpy(str, std::get<1>(t).c_str(), mem_size); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_backend_version_v1(m_ifcToAddon->thisClassHdl, hdl, str, + mem_size); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_backend_hostname_v1( + KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_BACKEND_HOSTNAME_V1)(KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_backend_hostname_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_backend_hostname_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_backend_hostname_v1(PtrValue(hdl), mem_size)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_backend_hostname_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_backend_hostname_v1 t = ident.get().as(); + strncpy(str, std::get<1>(t).c_str(), mem_size); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_backend_hostname_v1(m_ifcToAddon->thisClassHdl, hdl, str, + mem_size); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_connection_string_v1( + KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CONNECTION_STRING_V1)(KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_connection_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_connection_string_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_get_connection_string_v1(PtrValue(hdl), mem_size)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_connection_string_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_connection_string_v1 t = ident.get().as(); + strncpy(str, std::get<1>(t).c_str(), mem_size); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_connection_string_v1(m_ifcToAddon->thisClassHdl, hdl, str, + mem_size); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_drive_space_v1( + KODI_ADDON_PVR_HDL hdl, uint64_t* total, uint64_t* used) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_DRIVE_SPACE_V1)(KODI_ADDON_PVR_HDL hdl, uint64_t* total, uint64_t* used); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_drive_space_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_drive_space_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_drive_space_v1(PtrValue(hdl), *total, *used)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_drive_space_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_drive_space_v1 t = ident.get().as(); + *total = std::get<1>(t); + *used = std::get<2>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_drive_space_v1(m_ifcToAddon->thisClassHdl, hdl, total, + used); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_call_settings_menu_hook_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_SETTINGS_MENU_HOOK_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_call_settings_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_call_settings_menu_hook_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_call_settings_menu_hook_v1(PtrValue(hdl), menuhook)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_call_settings_menu_hook_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_call_settings_menu_hook_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_call_settings_menu_hook_v1(m_ifcToAddon->thisClassHdl, hdl, + menuhook); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channels_amount_v1( + KODI_ADDON_PVR_HDL hdl, int* amount) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNELS_AMOUNT_V1)(KODI_ADDON_PVR_HDL hdl, int* amount); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channels_amount_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channels_amount_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_channels_amount_v1(PtrValue(hdl), *amount)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_channels_amount_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_channels_amount_v1 t = ident.get().as(); + *amount = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_channels_amount_v1(m_ifcToAddon->thisClassHdl, hdl, + amount); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channels_v1( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool radio) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNELS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool radio); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channels_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channels_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_pvr_get_channels_v1(PtrValue(hdl), PtrValue(handle), radio)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_channels_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_channels_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_channels_v1(m_ifcToAddon->thisClassHdl, hdl, handle, + radio); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channel_stream_properties_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_STREAM_PROPERTIES_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel, struct PVR_NAMED_VALUE* properties, size_t* properties_count); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channel_stream_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channel_stream_properties_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_channel_stream_properties_v1( + PtrValue(hdl), channel, *properties_count)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_channel_stream_properties_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_channel_stream_properties_v1 t = ident.get().as(); + std::get<1>(t).SetCStructure(properties); + *properties_count = std::get<2>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_channel_stream_properties_v1( + m_ifcToAddon->thisClassHdl, hdl, channel, properties, properties_count); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_signal_status_v1( + KODI_ADDON_PVR_HDL hdl, int channel_uid, struct PVR_SIGNAL_STATUS* signal_status) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_SIGNAL_STATUS_V1)(KODI_ADDON_PVR_HDL hdl, int channel_uid, struct PVR_SIGNAL_STATUS* signal_status); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_signal_status_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_signal_status_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_signal_status_v1(PtrValue(hdl), channel_uid)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_signal_status_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_signal_status_v1 t = ident.get().as(); + std::get<1>(t).SetCStructure(signal_status); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_signal_status_v1(m_ifcToAddon->thisClassHdl, hdl, + channel_uid, signal_status); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_descramble_info_v1( + KODI_ADDON_PVR_HDL hdl, int channel_uid, struct PVR_DESCRAMBLE_INFO* descramble_info) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_DESCRAMBLE_INFO_V1)(KODI_ADDON_PVR_HDL hdl, int channel_uid, struct PVR_DESCRAMBLE_INFO* descramble_info); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_descramble_info_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_descramble_info_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_get_descramble_info_v1(PtrValue(hdl), channel_uid)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_descramble_info_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_descramble_info_v1 t = ident.get().as(); + std::get<1>(t).SetCStructure(descramble_info); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_descramble_info_v1(m_ifcToAddon->thisClassHdl, hdl, + channel_uid, descramble_info); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_providers_amount_v1( + KODI_ADDON_PVR_HDL hdl, int* amount) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_PROVIDERS_AMOUNT_V1)(KODI_ADDON_PVR_HDL hdl, int* amount); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_providers_amount_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_providers_amount_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_providers_amount_v1(PtrValue(hdl), *amount)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_providers_amount_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_providers_amount_v1 t = ident.get().as(); + *amount = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_providers_amount_v1(m_ifcToAddon->thisClassHdl, hdl, + amount); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_providers_v1( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_PROVIDERS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_providers_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_providers_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_get_providers_v1(PtrValue(hdl), PtrValue(handle))); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_providers_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_providers_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_providers_v1(m_ifcToAddon->thisClassHdl, hdl, handle); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channel_groups_amount_v1( + KODI_ADDON_PVR_HDL hdl, int* amount) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUPS_AMOUNT_V1)(KODI_ADDON_PVR_HDL hdl, int* amount); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channel_groups_amount_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channel_groups_amount_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_get_channel_groups_amount_v1(PtrValue(hdl), *amount)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_channel_groups_amount_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_channel_groups_amount_v1 t = ident.get().as(); + *amount = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_channel_groups_amount_v1(m_ifcToAddon->thisClassHdl, hdl, + amount); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channel_groups_v1( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool radio) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUPS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool radio); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channel_groups_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channel_groups_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_channel_groups_v1(PtrValue(hdl), + PtrValue(handle), radio)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_channel_groups_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_channel_groups_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_channel_groups_v1(m_ifcToAddon->thisClassHdl, hdl, handle, + radio); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channel_group_members_v1( + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP* group) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUP_MEMBERS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_CHANNEL_GROUP* group); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channel_group_members_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channel_group_members_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_channel_group_members_v1( + PtrValue(hdl), PtrValue(handle), group)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_channel_group_members_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_channel_group_members_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_channel_group_members_v1(m_ifcToAddon->thisClassHdl, hdl, + handle, group); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_delete_channel_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_CHANNEL_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_delete_channel_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_delete_channel_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_delete_channel_v1(PtrValue(hdl), channel)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_delete_channel_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_delete_channel_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_delete_channel_v1(m_ifcToAddon->thisClassHdl, hdl, channel); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_rename_channel_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_RENAME_CHANNEL_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_rename_channel_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_rename_channel_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_rename_channel_v1(PtrValue(hdl), channel)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_rename_channel_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_rename_channel_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_rename_channel_v1(m_ifcToAddon->thisClassHdl, hdl, channel); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_open_dialog_channel_settings_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_SETTINGS_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_open_dialog_channel_settings_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_open_dialog_channel_settings_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_pvr_open_dialog_channel_settings_v1(PtrValue(hdl), channel)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_open_dialog_channel_settings_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_open_dialog_channel_settings_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_open_dialog_channel_settings_v1(m_ifcToAddon->thisClassHdl, + hdl, channel); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_open_dialog_channel_add_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_ADD_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_open_dialog_channel_add_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_open_dialog_channel_add_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_open_dialog_channel_add_v1(PtrValue(hdl), channel)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_open_dialog_channel_add_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_open_dialog_channel_add_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_open_dialog_channel_add_v1(m_ifcToAddon->thisClassHdl, hdl, + channel); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_open_dialog_channel_scan_v1( + KODI_ADDON_PVR_HDL hdl) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_SCAN_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_open_dialog_channel_scan_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_open_dialog_channel_scan_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_open_dialog_channel_scan_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_open_dialog_channel_scan_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_open_dialog_channel_scan_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_open_dialog_channel_scan_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_call_channel_menu_hook_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct PVR_CHANNEL* channel) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_CHANNEL_MENU_HOOK_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct PVR_CHANNEL* channel); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_call_channel_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_call_channel_menu_hook_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_call_channel_menu_hook_v1(PtrValue(hdl), menuhook, + channel)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_call_channel_menu_hook_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_call_channel_menu_hook_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_call_channel_menu_hook_v1(m_ifcToAddon->thisClassHdl, hdl, + menuhook, channel); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_epg_for_channel_v1( + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + int channel_uid, + time_t start, + time_t end) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_FOR_CHANNEL_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, int channel_uid, time_t start, time_t end); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_epg_for_channel_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_epg_for_channel_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_epg_for_channel_v1( + PtrValue(hdl), PtrValue(handle), channel_uid, start, end)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_epg_for_channel_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_epg_for_channel_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_epg_for_channel_v1(m_ifcToAddon->thisClassHdl, hdl, + handle, channel_uid, start, end); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_is_epg_tag_recordable_v1( + KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, bool* is_recordable) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_IS_EPG_TAG_RECORDABLE_V1)(KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, bool* is_recordable); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_is_epg_tag_recordable_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_is_epg_tag_recordable_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_is_epg_tag_recordable_v1(PtrValue(hdl), tag, + *is_recordable)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_is_epg_tag_recordable_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_is_epg_tag_recordable_v1 t = ident.get().as(); + *is_recordable = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_is_epg_tag_recordable_v1(m_ifcToAddon->thisClassHdl, hdl, tag, + is_recordable); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_is_epg_tag_playable_v1( + KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, bool* is_playable) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_IS_EPG_TAG_PLAYABLE_V1)(KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, bool* is_playable); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_is_epg_tag_playable_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_is_epg_tag_playable_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_pvr_is_epg_tag_playable_v1(PtrValue(hdl), tag, *is_playable)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_is_epg_tag_playable_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_is_epg_tag_playable_v1 t = ident.get().as(); + *is_playable = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_is_epg_tag_playable_v1(m_ifcToAddon->thisClassHdl, hdl, tag, + is_playable); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_epg_tag_edl_v1( + KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, struct PVR_EDL_ENTRY edl[], size_t* size) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_TAG_EDL_V1)(KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, struct PVR_EDL_ENTRY edl[], size_t* size); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_pvr_get_epg_tag_edl_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_pvr_get_epg_tag_edl_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + std::vector ifc_edl(*size); + for (size_t i = 0; i < *size; ++i) + { + ifc_edl[i] = IFC_PVR_EDL_ENTRY(&edl[i]); + } + msgpack::pack( + in, msgChild__IN_kodi_addon_pvr_get_epg_tag_edl_v1(PtrValue(hdl), tag, ifc_edl, *size)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_epg_tag_edl_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_epg_tag_edl_v1 t = ident.get().as(); + std::vector& ifc_out_edl = std::get<1>(t); + *size = std::get<2>(t); + for (size_t i = 0; i < *size; ++i) + { + ifc_out_edl[i].SetCStructure(&edl[i]); + } + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_epg_tag_edl_v1(m_ifcToAddon->thisClassHdl, hdl, tag, edl, + size); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_epg_tag_stream_properties_v1( + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_TAG_STREAM_PROPERTIES_V1)(KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, struct PVR_NAMED_VALUE* properties, size_t* properties_count); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_epg_tag_stream_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_epg_tag_stream_properties_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_epg_tag_stream_properties_v1( + PtrValue(hdl), tag, *properties_count)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_epg_tag_stream_properties_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_epg_tag_stream_properties_v1 t = ident.get().as(); + std::get<1>(t).SetCStructure(properties); + *properties_count = std::get<2>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_epg_tag_stream_properties_v1( + m_ifcToAddon->thisClassHdl, hdl, tag, properties, properties_count); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_set_epg_max_past_days_v1( + KODI_ADDON_PVR_HDL hdl, int past_days) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_EPG_MAX_PAST_DAYS_V1)(KODI_ADDON_PVR_HDL hdl, int past_days); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_set_epg_max_past_days_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_set_epg_max_past_days_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_set_epg_max_past_days_v1(PtrValue(hdl), past_days)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_set_epg_max_past_days_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_set_epg_max_past_days_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_set_epg_max_past_days_v1(m_ifcToAddon->thisClassHdl, hdl, + past_days); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_set_epg_max_future_days_v1( + KODI_ADDON_PVR_HDL hdl, int future_days) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_EPG_MAX_FUTURE_DAYS_V1)(KODI_ADDON_PVR_HDL hdl, int future_days); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_set_epg_max_future_days_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_set_epg_max_future_days_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_pvr_set_epg_max_future_days_v1(PtrValue(hdl), future_days)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_set_epg_max_future_days_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_set_epg_max_future_days_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_set_epg_max_future_days_v1(m_ifcToAddon->thisClassHdl, hdl, + future_days); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_call_epg_menu_hook_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct EPG_TAG* tag) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_EPG_MENU_HOOK_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct EPG_TAG* tag); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_call_epg_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_call_epg_menu_hook_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_call_epg_menu_hook_v1(PtrValue(hdl), menuhook, tag)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_call_epg_menu_hook_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_call_epg_menu_hook_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_call_epg_menu_hook_v1(m_ifcToAddon->thisClassHdl, hdl, + menuhook, tag); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recordings_amount_v1( + KODI_ADDON_PVR_HDL hdl, bool deleted, int* amount) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDINGS_AMOUNT_V1)(KODI_ADDON_PVR_HDL hdl, bool deleted, int* amount); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_recordings_amount_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_recordings_amount_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_pvr_get_recordings_amount_v1(PtrValue(hdl), deleted, *amount)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_recordings_amount_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_recordings_amount_v1 t = ident.get().as(); + *amount = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_recordings_amount_v1(m_ifcToAddon->thisClassHdl, hdl, + deleted, amount); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recordings_v1( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool deleted) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDINGS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool deleted); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_recordings_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_recordings_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_recordings_v1(PtrValue(hdl), PtrValue(handle), + deleted)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_recordings_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_recordings_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_recordings_v1(m_ifcToAddon->thisClassHdl, hdl, handle, + deleted); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_delete_recording_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_RECORDING_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_delete_recording_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_delete_recording_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_delete_recording_v1(PtrValue(hdl), recording)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_delete_recording_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_delete_recording_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_delete_recording_v1(m_ifcToAddon->thisClassHdl, hdl, + recording); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_undelete_recording_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_UNDELETE_RECORDING_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_undelete_recording_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_undelete_recording_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_undelete_recording_v1(PtrValue(hdl), recording)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_undelete_recording_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_undelete_recording_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_undelete_recording_v1(m_ifcToAddon->thisClassHdl, hdl, + recording); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_delete_all_recordings_from_trash_v1( + KODI_ADDON_PVR_HDL hdl) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_ALL_RECORDINGS_FROM_TRASH_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_delete_all_recordings_from_trash_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_delete_all_recordings_from_trash_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_delete_all_recordings_from_trash_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_delete_all_recordings_from_trash_v1, in, + out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_delete_all_recordings_from_trash_v1 t = + ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_delete_all_recordings_from_trash_v1( + m_ifcToAddon->thisClassHdl, hdl); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_rename_recording_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_RENAME_RECORDING_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_rename_recording_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_rename_recording_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_rename_recording_v1(PtrValue(hdl), recording)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_rename_recording_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_rename_recording_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_rename_recording_v1(m_ifcToAddon->thisClassHdl, hdl, + recording); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_set_recording_lifetime_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_RECORDING_LIFETIME_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_set_recording_lifetime_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_set_recording_lifetime_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_set_recording_lifetime_v1(PtrValue(hdl), recording)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_set_recording_lifetime_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_set_recording_lifetime_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_set_recording_lifetime_v1(m_ifcToAddon->thisClassHdl, hdl, + recording); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_set_recording_play_count_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int count) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_RECORDING_PLAY_COUNT_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int count); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_set_recording_play_count_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_set_recording_play_count_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_set_recording_play_count_v1(PtrValue(hdl), + recording, count)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_set_recording_play_count_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_set_recording_play_count_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_set_recording_play_count_v1(m_ifcToAddon->thisClassHdl, hdl, + recording, count); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_set_recording_last_played_position_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int last_played_position) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_RECORDING_LAST_PLAYED_POSITION_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int last_played_position); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_set_recording_last_played_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_set_recording_last_played_position_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_set_recording_last_played_position_v1( + PtrValue(hdl), recording, last_played_position)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_set_recording_last_played_position_v1, in, + out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_set_recording_last_played_position_v1 t = + ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_set_recording_last_played_position_v1( + m_ifcToAddon->thisClassHdl, hdl, recording, last_played_position); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recording_last_played_position_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int* last_played_position) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_LAST_PLAYED_POSITION_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int* last_played_position); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_recording_last_played_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_recording_last_played_position_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_recording_last_played_position_v1( + PtrValue(hdl), recording, *last_played_position)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_recording_last_played_position_v1, in, + out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_recording_last_played_position_v1 t = + ident.get().as(); + *last_played_position = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_recording_last_played_position_v1( + m_ifcToAddon->thisClassHdl, hdl, recording, last_played_position); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recording_edl_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + struct PVR_EDL_ENTRY edl[], + size_t* size) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_EDL_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, struct PVR_EDL_ENTRY edl[], size_t* size); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_pvr_get_recording_edl_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_pvr_get_recording_edl_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + std::vector ifc_edl(*size); + for (size_t i = 0; i < *size; ++i) + { + ifc_edl[i] = IFC_PVR_EDL_ENTRY(&edl[i]); + } + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_recording_edl_v1(PtrValue(hdl), recording, + ifc_edl, *size)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_recording_edl_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_recording_edl_v1 t = ident.get().as(); + std::vector& ifc_out_edl = std::get<1>(t); + *size = std::get<2>(t); + for (size_t i = 0; i < *size; ++i) + { + ifc_out_edl[i].SetCStructure(&edl[i]); + } + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_recording_edl_v1(m_ifcToAddon->thisClassHdl, hdl, + recording, edl, size); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recording_size_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int64_t* size) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_SIZE_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int64_t* size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_recording_size_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_recording_size_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_pvr_get_recording_size_v1(PtrValue(hdl), recording, *size)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_recording_size_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_recording_size_v1 t = ident.get().as(); + *size = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_recording_size_v1(m_ifcToAddon->thisClassHdl, hdl, + recording, size); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recording_stream_properties_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_STREAM_PROPERTIES_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, struct PVR_NAMED_VALUE* properties, size_t* properties_count); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_recording_stream_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_recording_stream_properties_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_recording_stream_properties_v1( + PtrValue(hdl), recording, *properties_count)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_recording_stream_properties_v1, in, + out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_recording_stream_properties_v1 t = + ident.get().as(); + std::get<1>(t).SetCStructure(properties); + *properties_count = std::get<2>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_recording_stream_properties_v1( + m_ifcToAddon->thisClassHdl, hdl, recording, properties, properties_count); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_call_recording_menu_hook_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_RECORDING* recording) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_RECORDING_MENU_HOOK_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct PVR_RECORDING* recording); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_call_recording_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_call_recording_menu_hook_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_call_recording_menu_hook_v1(PtrValue(hdl), + menuhook, recording)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_call_recording_menu_hook_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_call_recording_menu_hook_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_call_recording_menu_hook_v1(m_ifcToAddon->thisClassHdl, hdl, + menuhook, recording); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_timer_types_v1( + KODI_ADDON_PVR_HDL hdl, struct PVR_TIMER_TYPE types[], size_t* types_count) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_TIMER_TYPES_V1)(KODI_ADDON_PVR_HDL hdl, struct PVR_TIMER_TYPE types[], size_t* types_count); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_pvr_get_timer_types_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_pvr_get_timer_types_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + std::vector ifc_types(*types_count); + for (size_t i = 0; i < *types_count; ++i) + { + ifc_types[i] = IFC_PVR_TIMER_TYPE(&types[i]); + } + msgpack::pack( + in, msgChild__IN_kodi_addon_pvr_get_timer_types_v1(PtrValue(hdl), ifc_types, *types_count)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_timer_types_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_timer_types_v1 t = ident.get().as(); + std::vector& ifc_out_types = std::get<1>(t); + *types_count = std::get<2>(t); + for (size_t i = 0; i < *types_count; ++i) + { + ifc_out_types[i].SetCStructure(&types[i]); + } + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_timer_types_v1(m_ifcToAddon->thisClassHdl, hdl, types, + types_count); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_timers_amount_v1( + KODI_ADDON_PVR_HDL hdl, int* amount) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_TIMERS_AMOUNT_V1)(KODI_ADDON_PVR_HDL hdl, int* amount); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_timers_amount_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_timers_amount_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_timers_amount_v1(PtrValue(hdl), *amount)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_timers_amount_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_timers_amount_v1 t = ident.get().as(); + *amount = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_timers_amount_v1(m_ifcToAddon->thisClassHdl, hdl, amount); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_timers_v1( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_TIMERS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_timers_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_timers_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_get_timers_v1(PtrValue(hdl), PtrValue(handle))); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_get_timers_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_get_timers_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_get_timers_v1(m_ifcToAddon->thisClassHdl, hdl, handle); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_add_timer_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ADD_TIMER_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_add_timer_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_add_timer_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_add_timer_v1(PtrValue(hdl), timer)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_add_timer_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_add_timer_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_add_timer_v1(m_ifcToAddon->thisClassHdl, hdl, timer); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_delete_timer_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer, bool force_delete) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_TIMER_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer, bool force_delete); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_delete_timer_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_delete_timer_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_pvr_delete_timer_v1(PtrValue(hdl), timer, force_delete)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_delete_timer_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_delete_timer_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_delete_timer_v1(m_ifcToAddon->thisClassHdl, hdl, timer, + force_delete); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_update_timer_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_UPDATE_TIMER_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_update_timer_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_update_timer_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_update_timer_v1(PtrValue(hdl), timer)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_update_timer_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_update_timer_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_update_timer_v1(m_ifcToAddon->thisClassHdl, hdl, timer); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_call_timer_menu_hook_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct PVR_TIMER* timer) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_TIMER_MENU_HOOK_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct PVR_TIMER* timer); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_call_timer_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_call_timer_menu_hook_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_pvr_call_timer_menu_hook_v1(PtrValue(hdl), menuhook, timer)); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_call_timer_menu_hook_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_call_timer_menu_hook_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_call_timer_menu_hook_v1(m_ifcToAddon->thisClassHdl, hdl, + menuhook, timer); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_on_system_sleep_v1( + KODI_ADDON_PVR_HDL hdl) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_SYSTEM_SLEEP_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_on_system_sleep_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_on_system_sleep_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_on_system_sleep_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_on_system_sleep_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_on_system_sleep_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_on_system_sleep_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_on_system_wake_v1( + KODI_ADDON_PVR_HDL hdl) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_SYSTEM_WAKE_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_on_system_wake_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_on_system_wake_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_on_system_wake_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_on_system_wake_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_on_system_wake_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_on_system_wake_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_on_power_saving_activated_v1( + KODI_ADDON_PVR_HDL hdl) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_POWER_SAVING_ACTIVATED_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_on_power_saving_activated_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_on_power_saving_activated_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_on_power_saving_activated_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_on_power_saving_activated_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_on_power_saving_activated_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_on_power_saving_activated_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_on_power_saving_deactivated_v1( + KODI_ADDON_PVR_HDL hdl) +{ + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_POWER_SAVING_DEACTIVATED_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_on_power_saving_deactivated_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_on_power_saving_deactivated_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_pvr_on_power_saving_deactivated_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_pvr_h, + funcChild_kodi_addon_pvr_on_power_saving_deactivated_v1, in, out)) + return PVR_ERROR_NO_ERROR; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_pvr_on_power_saving_deactivated_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_pvr_on_power_saving_deactivated_v1(m_ifcToAddon->thisClassHdl, + hdl); +} + +// Callbacks from addon to Kodi + +int CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_epg_max_future_days_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "int cb_get_epg_max_future_days()" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + return cb->cb_get_epg_max_future_days(); + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_epg_max_past_days_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "int cb_get_epg_max_past_days()" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + return cb->cb_get_epg_max_past_days(); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_add_menu_hook_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const struct PVR_MENUHOOK* hook) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_add_menu_hook(const PVR_MENUHOOK* hook)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_add_menu_hook(hook); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_recording_notification_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* name, + const char* fileName, + bool on) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_recording_notification(const char* strName, const char* strFileName, bool bOnOff)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_recording_notification(name, fileName, on); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_connection_state_change_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* strConnectionString, + enum PVR_CONNECTION_STATE newState, + const char* strMessage) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_connection_state_change(const char* strConnectionString, PVR_CONNECTION_STATE newState, const char* strMessage)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_connection_state_change(strConnectionString, newState, strMessage); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_epg_event_state_change_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct EPG_TAG* tag, + enum EPG_EVENT_STATE newState) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_epg_event_state_change(EPG_TAG* tag, EPG_EVENT_STATE newState)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_epg_event_state_change(tag, newState); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_transfer_channel_entry_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL* chan) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_transfer_channel_entry(const KODI_ADDON_PVR_TRANSFER_HDL handle, const PVR_CHANNEL* entry)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_transfer_channel_entry(handle, chan); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_transfer_provider_entry_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_PROVIDER* chanProvider) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_transfer_provider_entry(const KODI_ADDON_PVR_TRANSFER_HDL handle, const PVR_PROVIDER* entry)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_transfer_provider_entry(handle, chanProvider); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_transfer_channel_group_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP* group) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_transfer_channel_group(const KODI_ADDON_PVR_TRANSFER_HDL handle, const PVR_CHANNEL_GROUP* entry)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_transfer_channel_group(handle, group); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_transfer_channel_group_member_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP_MEMBER* member) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_transfer_channel_group_member(const KODI_ADDON_PVR_TRANSFER_HDL handle, const PVR_CHANNEL_GROUP_MEMBER* entry)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_transfer_channel_group_member(handle, member); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_transfer_epg_entry_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct EPG_TAG* epgentry) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_transfer_epg_entry(const KODI_ADDON_PVR_TRANSFER_HDL handle, const EPG_TAG* entry)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_transfer_epg_entry(handle, epgentry); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_transfer_recording_entry_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_RECORDING* recording) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_transfer_recording_entry(const KODI_ADDON_PVR_TRANSFER_HDL handle, const PVR_RECORDING* entry)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_transfer_recording_entry(handle, recording); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_transfer_timer_entry_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_TIMER* timer) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_transfer_timer_entry(const KODI_ADDON_PVR_TRANSFER_HDL handle, const PVR_TIMER* entry)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_transfer_timer_entry(handle, timer); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_trigger_channel_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_trigger_channel_update()" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_trigger_channel_update(); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_trigger_providers_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_trigger_provider_update()" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_trigger_provider_update(); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_trigger_channel_groups_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_trigger_channel_groups_update()" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_trigger_channel_groups_update(); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_trigger_epg_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, unsigned int iChannelUid) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_trigger_epg_update(unsigned int iChannelUid)" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_trigger_epg_update(iChannelUid); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_trigger_recording_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_trigger_recording_update()" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_trigger_recording_update(); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_trigger_timer_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "PVR::CPVRClient" with "void cb_trigger_timer_update()" on "pvr/addons/PVRClient.h". + + PVR::CPVRClient* cb = static_cast(hdl); + cb->cb_trigger_timer_update(); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/pvr.h b/xbmc/addons/interface/api/addon-instance/pvr.h new file mode 100644 index 0000000000000..afcd4225ad1e0 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/pvr.h @@ -0,0 +1,371 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_pvr_h; +struct directFuncToKodi_addoninstance_pvr_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_pvr_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_pvr_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_pvr_h* ifcToKodi, + directFuncToAddon_addoninstance_pvr_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + enum PVR_ERROR kodi_addon_pvr_get_capabilities_v1( + KODI_ADDON_PVR_HDL hdl, struct PVR_ADDON_CAPABILITIES* capabilities); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_backend_name_v1(KODI_ADDON_PVR_HDL hdl, + char* str, + size_t mem_size); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_backend_version_v1(KODI_ADDON_PVR_HDL hdl, + char* str, + size_t mem_size); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_backend_hostname_v1(KODI_ADDON_PVR_HDL hdl, + char* str, + size_t mem_size); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_connection_string_v1(KODI_ADDON_PVR_HDL hdl, + char* str, + size_t mem_size); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_drive_space_v1(KODI_ADDON_PVR_HDL hdl, + uint64_t* total, + uint64_t* used); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_call_settings_menu_hook_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_channels_amount_v1(KODI_ADDON_PVR_HDL hdl, + int* amount); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_channels_v1(KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + bool radio); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_channel_stream_properties_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_signal_status_v1( + KODI_ADDON_PVR_HDL hdl, + int channel_uid, + struct PVR_SIGNAL_STATUS* signal_status); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_descramble_info_v1( + KODI_ADDON_PVR_HDL hdl, + int channel_uid, + struct PVR_DESCRAMBLE_INFO* descramble_info); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_providers_amount_v1(KODI_ADDON_PVR_HDL hdl, + int* amount); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_providers_v1( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_channel_groups_amount_v1(KODI_ADDON_PVR_HDL hdl, + int* amount); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_channel_groups_v1(KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + bool radio); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_channel_group_members_v1( + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP* group); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_delete_channel_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_rename_channel_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_open_dialog_channel_settings_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_open_dialog_channel_add_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_open_dialog_channel_scan_v1( + KODI_ADDON_PVR_HDL hdl); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_call_channel_menu_hook_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_CHANNEL* channel); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_epg_for_channel_v1(KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + int channel_uid, + time_t start, + time_t end); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_is_epg_tag_recordable_v1(KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + bool* is_recordable); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_is_epg_tag_playable_v1(KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + bool* is_playable); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_epg_tag_edl_v1(KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + struct PVR_EDL_ENTRY edl[], + size_t* size); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_epg_tag_stream_properties_v1( + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_set_epg_max_past_days_v1(KODI_ADDON_PVR_HDL hdl, + int past_days); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_set_epg_max_future_days_v1(KODI_ADDON_PVR_HDL hdl, + int future_days); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_call_epg_menu_hook_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct EPG_TAG* tag); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_recordings_amount_v1(KODI_ADDON_PVR_HDL hdl, + bool deleted, + int* amount); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_recordings_v1(KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + bool deleted); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_delete_recording_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_undelete_recording_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_delete_all_recordings_from_trash_v1( + KODI_ADDON_PVR_HDL hdl); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_rename_recording_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_set_recording_lifetime_v1( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_set_recording_play_count_v1(KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int count); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_set_recording_last_played_position_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int last_played_position); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_recording_last_played_position_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int* last_played_position); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_recording_edl_v1(KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + struct PVR_EDL_ENTRY edl[], + size_t* size); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_recording_size_v1(KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int64_t* size); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_recording_stream_properties_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_call_recording_menu_hook_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_RECORDING* recording); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_timer_types_v1(KODI_ADDON_PVR_HDL hdl, + struct PVR_TIMER_TYPE types[], + size_t* types_count); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_timers_amount_v1(KODI_ADDON_PVR_HDL hdl, + int* amount); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_get_timers_v1( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_add_timer_v1(KODI_ADDON_PVR_HDL hdl, + const struct PVR_TIMER* timer); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_delete_timer_v1(KODI_ADDON_PVR_HDL hdl, + const struct PVR_TIMER* timer, + bool force_delete); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_update_timer_v1(KODI_ADDON_PVR_HDL hdl, + const struct PVR_TIMER* timer); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_call_timer_menu_hook_v1( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_TIMER* timer); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_on_system_sleep_v1(KODI_ADDON_PVR_HDL hdl); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_on_system_wake_v1(KODI_ADDON_PVR_HDL hdl); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_on_power_saving_activated_v1( + KODI_ADDON_PVR_HDL hdl); // Added with API 1 + + enum PVR_ERROR kodi_addon_pvr_on_power_saving_deactivated_v1( + KODI_ADDON_PVR_HDL hdl); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static int kodi_addon_pvr_get_epg_max_future_days_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + static int kodi_addon_pvr_get_epg_max_past_days_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + static void kodi_addon_pvr_add_menu_hook_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const struct PVR_MENUHOOK* hook); // Added with API 1 + + static void kodi_addon_pvr_recording_notification_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* name, + const char* fileName, + bool on); // Added with API 1 + + static void kodi_addon_pvr_connection_state_change_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* strConnectionString, + enum PVR_CONNECTION_STATE newState, + const char* strMessage); // Added with API 1 + + static void kodi_addon_pvr_epg_event_state_change_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct EPG_TAG* tag, + enum EPG_EVENT_STATE newState); // Added with API 1 + + static void kodi_addon_pvr_transfer_channel_entry_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL* chan); // Added with API 1 + + static void kodi_addon_pvr_transfer_provider_entry_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_PROVIDER* chanProvider); // Added with API 1 + + static void kodi_addon_pvr_transfer_channel_group_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP* group); // Added with API 1 + + static void kodi_addon_pvr_transfer_channel_group_member_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP_MEMBER* member); // Added with API 1 + + static void kodi_addon_pvr_transfer_epg_entry_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct EPG_TAG* epgentry); // Added with API 1 + + static void kodi_addon_pvr_transfer_recording_entry_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_RECORDING* recording); // Added with API 1 + + static void kodi_addon_pvr_transfer_timer_entry_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_TIMER* timer); // Added with API 1 + + static void kodi_addon_pvr_trigger_channel_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + static void kodi_addon_pvr_trigger_providers_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + static void kodi_addon_pvr_trigger_channel_groups_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + static void kodi_addon_pvr_trigger_epg_update_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + unsigned int iChannelUid); // Added with API 1 + + static void kodi_addon_pvr_trigger_recording_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + static void kodi_addon_pvr_trigger_timer_update_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + directFuncToAddon_addoninstance_pvr_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/screensaver.cpp b/xbmc/addons/interface/api/addon-instance/screensaver.cpp new file mode 100644 index 0000000000000..2baa722be28a5 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/screensaver.cpp @@ -0,0 +1,202 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "screensaver.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/screensaver.h" + +// Kodi +#include "addons/ScreenSaver.h" +#include "addons/interface/IOffscreenRenderProcess.h" +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_screensaver_h::InitDirect( + directFuncToKodi_addoninstance_screensaver_h* ifcToKodi, + directFuncToAddon_addoninstance_screensaver_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_addon_screensaver_get_properties_v1 = kodi_addon_screensaver_get_properties_v1; +} + +bool CHdl_kodi_addoninstance_screensaver_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_screensaver_h) + return false; + + switch (func) + { + case funcParent_kodi_addon_screensaver_get_properties_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_screensaver_get_properties( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct KODI_ADDON_SCREENSAVER_PROPS* props) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_screensaver_get_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_screensaver_get_properties_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_screensaver_get_properties_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + struct KODI_ADDON_SCREENSAVER_PROPS props = {}; + kodi_addon_screensaver_get_properties_v1(this, hdl, &props); + msgpack::pack(out, msgParent_OUT_kodi_addon_screensaver_get_properties_v1(&props)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_screensaver_h::{}: addon called with unknown function id " + "'{}' on group 'addoninstance_screensaver_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +bool CHdl_kodi_addoninstance_screensaver_h::kodi_addon_screensaver_start_v1( + IOffscreenRenderProcess* proc, const KODI_ADDON_SCREENSAVER_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_START_V1)(const KODI_ADDON_SCREENSAVER_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_screensaver_start_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_screensaver_start_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + int x = 0; + int y = 0; + int width = 0; + int height = 0; + ADDON_HARDWARE_CONTEXT context = nullptr; + if (!proc || !proc->GetOffscreenRenderInfos(x, y, width, height, context) || + !proc->CreateRenderHelper(m_process)) + return false; + + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_screensaver_start_v1( + PtrKodiOffscreen(proc), proc->GetUsedId(), x, y, width, height, + PtrValue(context), PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_screensaver_h, + funcChild_kodi_addon_screensaver_start_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_screensaver_start_v1 t = ident.get().as(); + if (std::get<1>(t) == 0 || std::get<2>(t) == false) + return false; + proc->SetAddonOffscreenHdl(std::get<1>(t)); + proc->GetRenderHelper()->Init(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_screensaver_start_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_screensaver_h::kodi_addon_screensaver_stop_v1( + IOffscreenRenderProcess* proc, const KODI_ADDON_SCREENSAVER_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_STOP_V1)(const KODI_ADDON_SCREENSAVER_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_screensaver_stop_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_screensaver_stop_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + if (!proc) + return; + + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_screensaver_stop_v1(proc->GetAddonOffscreenHdl(), + PtrValue(hdl))); + m_process->SendMessage(funcGroup_addoninstance_screensaver_h, + funcChild_kodi_addon_screensaver_stop_v1, in); + + proc->GetRenderHelper()->Deinit(); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_screensaver_stop_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_screensaver_h::kodi_addon_screensaver_render_v1( + IOffscreenRenderProcess* proc, const KODI_ADDON_SCREENSAVER_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_RENDER_V1)(const KODI_ADDON_SCREENSAVER_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_screensaver_render_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_screensaver_render_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + if (!proc) + return; + + proc->GetRenderHelper()->Begin(); + + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_screensaver_render_v1(proc->GetAddonOffscreenHdl(), + PtrValue(hdl))); + m_process->SendMessage(funcGroup_addoninstance_screensaver_h, + funcChild_kodi_addon_screensaver_render_v1, in); + + proc->GetRenderHelper()->End(); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_screensaver_render_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +// Callbacks from addon to Kodi + +void CHdl_kodi_addoninstance_screensaver_h::kodi_addon_screensaver_get_properties_v1( + void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct KODI_ADDON_SCREENSAVER_PROPS* props) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::CScreenSaver" with "void GetProperties(struct KODI_ADDON_SCREENSAVER_PROPS* props)" on "addons/ScreenSaver.h". + + KODI::ADDONS::CScreenSaver* cb = static_cast(hdl); + cb->GetProperties(props); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/screensaver.h b/xbmc/addons/interface/api/addon-instance/screensaver.h new file mode 100644 index 0000000000000..3ec2d8c0ff177 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/screensaver.h @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/screensaver.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class IOffscreenRenderProcess; +struct directFuncToAddon_addoninstance_screensaver_h; +struct directFuncToKodi_addoninstance_screensaver_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_screensaver_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_screensaver_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_screensaver_h* ifcToKodi, + directFuncToAddon_addoninstance_screensaver_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + bool kodi_addon_screensaver_start_v1(IOffscreenRenderProcess* proc, + const KODI_ADDON_SCREENSAVER_HDL hdl); // Added with API 1 + + void kodi_addon_screensaver_stop_v1(IOffscreenRenderProcess* proc, + const KODI_ADDON_SCREENSAVER_HDL hdl); // Added with API 1 + + void kodi_addon_screensaver_render_v1(IOffscreenRenderProcess* proc, + const KODI_ADDON_SCREENSAVER_HDL hdl); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_addon_screensaver_get_properties_v1( + void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct KODI_ADDON_SCREENSAVER_PROPS* props); // Added with API 1 + + directFuncToAddon_addoninstance_screensaver_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/vfs.cpp b/xbmc/addons/interface/api/addon-instance/vfs.cpp new file mode 100644 index 0000000000000..415d81868dcbe --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/vfs.cpp @@ -0,0 +1,888 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "vfs.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/vfs.h" + +// Kodi +#include "addons/VFSEntry.h" +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_vfs_h::InitDirect(directFuncToKodi_addoninstance_vfs_h* ifcToKodi, + directFuncToAddon_addoninstance_vfs_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1 = + kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1; + ifcToKodi->kodi_addon_vfs_get_dir_cb__set_error_dialog_v1 = + kodi_addon_vfs_get_dir_cb__set_error_dialog_v1; + ifcToKodi->kodi_addon_vfs_get_dir_cb__require_authentication_v1 = + kodi_addon_vfs_get_dir_cb__require_authentication_v1; +} + +bool CHdl_kodi_addoninstance_vfs_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_vfs_h) + return false; + + switch (func) + { + case funcParent_kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_vfs_get_dir_cb__get_keyboard_input( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_CTX_CB_HDL ctx_cb_hdl, const char* heading, char** input, bool hidden_input) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + KODI_CTX_CB_HDL ctx_cb_hdl = reinterpret_cast(std::get<1>(t)); + const std::string& heading = std::get<2>(t); + char* input = nullptr; + bool hidden_input = std::get<3>(t); + bool auto_gen_ret = kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1( + this, hdl, ctx_cb_hdl, heading.c_str(), &input, hidden_input); + msgpack::pack(out, msgParent_OUT_kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1( + auto_gen_ret, input ? input : "")); + if (input) + free(input); + return true; + } + case funcParent_kodi_addon_vfs_get_dir_cb__set_error_dialog_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_vfs_get_dir_cb__set_error_dialog( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_CTX_CB_HDL ctx_cb_hdl, const char* heading, const char* line1, const char* line2, const char* line3) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_vfs_get_dir_cb__set_error_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_vfs_get_dir_cb__set_error_dialog_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_vfs_get_dir_cb__set_error_dialog_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + KODI_CTX_CB_HDL ctx_cb_hdl = reinterpret_cast(std::get<1>(t)); + const std::string& heading = std::get<2>(t); + const std::string& line1 = std::get<3>(t); + const std::string& line2 = std::get<4>(t); + const std::string& line3 = std::get<5>(t); + kodi_addon_vfs_get_dir_cb__set_error_dialog_v1(this, hdl, ctx_cb_hdl, heading.c_str(), + line1.c_str(), line2.c_str(), line3.c_str()); + return true; + } + case funcParent_kodi_addon_vfs_get_dir_cb__require_authentication_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_vfs_get_dir_cb__require_authentication( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_CTX_CB_HDL ctx_cb_hdl, const char* url) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_vfs_get_dir_cb__require_authentication_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_vfs_get_dir_cb__require_authentication_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_vfs_get_dir_cb__require_authentication_v1 t = + in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + KODI_CTX_CB_HDL ctx_cb_hdl = reinterpret_cast(std::get<1>(t)); + const std::string& url = std::get<2>(t); + kodi_addon_vfs_get_dir_cb__require_authentication_v1(this, hdl, ctx_cb_hdl, url.c_str()); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_vfs_h::{}: addon called with unknown function id '{}' on " + "group 'addoninstance_vfs_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +KODI_VFS_FILE_HDL CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_open_v1( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url) +{ + // Original API call: typedef KODI_VFS_FILE_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_OPEN_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_open_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_file_open_v1(PtrValue(hdl), url)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_open_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_open_v1 t = ident.get().as(); + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_open_v1(m_ifcToAddon->thisClassHdl, hdl, url); +} + +KODI_VFS_FILE_HDL CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_open_for_write_v1( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, bool overwrite) +{ + // Original API call: typedef KODI_VFS_FILE_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_OPEN_FOR_WRITE_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, bool overwrite); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_open_for_write_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_open_for_write_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_vfs_file_open_for_write_v1(PtrValue(hdl), url, overwrite)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_open_for_write_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_open_for_write_v1 t = ident.get().as(); + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_open_for_write_v1(m_ifcToAddon->thisClassHdl, hdl, url, + overwrite); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_close_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_CLOSE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_close_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_close_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_file_close_v1(PtrValue(hdl), PtrValue(context))); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_close_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_close_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_close_v1(m_ifcToAddon->thisClassHdl, hdl, context); +} + +ssize_t CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_read_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + uint8_t* buffer, + size_t buf_size) +{ + // Original API call: typedef ssize_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_READ_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, uint8_t* buffer, size_t buf_size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_read_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple> msgChild_OUT_kodi_addon_vfs_file_read_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_vfs_file_read_v1(PtrValue(hdl), PtrValue(context), buf_size)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_read_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_read_v1 t = ident.get().as(); + std::memcpy(buffer, std::get<1>(t).data(), sizeof(uint8_t) * buf_size); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_read_v1(m_ifcToAddon->thisClassHdl, hdl, context, buffer, + buf_size); +} + +ssize_t CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_write_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + const uint8_t* buffer, + size_t buf_size) +{ + // Original API call: typedef ssize_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_WRITE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, const uint8_t* buffer, size_t buf_size); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_vfs_file_write_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_write_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_file_write_v1( + PtrValue(hdl), PtrValue(context), + std::vector(buffer, buffer + buf_size), buf_size)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_write_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_write_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_write_v1(m_ifcToAddon->thisClassHdl, hdl, context, + buffer, buf_size); +} + +int64_t CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_seek_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t position, + int whence) +{ + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_SEEK_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, int64_t position, int whence); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_seek_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_seek_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_file_seek_v1(PtrValue(hdl), PtrValue(context), + position, whence)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_seek_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_seek_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_seek_v1(m_ifcToAddon->thisClassHdl, hdl, context, + position, whence); +} + +int CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_truncate_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t size) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_TRUNCATE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, int64_t size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_truncate_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_truncate_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_vfs_file_truncate_v1(PtrValue(hdl), PtrValue(context), size)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_truncate_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_truncate_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_truncate_v1(m_ifcToAddon->thisClassHdl, hdl, context, + size); +} + +int64_t CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_get_length_v1( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context) +{ + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_GET_LENGTH_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_get_length_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_get_length_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_vfs_file_get_length_v1(PtrValue(hdl), PtrValue(context))); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_get_length_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_get_length_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_get_length_v1(m_ifcToAddon->thisClassHdl, hdl, context); +} + +int64_t CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_get_position_v1( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context) +{ + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_GET_POSITION_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_get_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_get_position_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_vfs_file_get_position_v1(PtrValue(hdl), PtrValue(context))); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_get_position_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_get_position_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_get_position_v1(m_ifcToAddon->thisClassHdl, hdl, + context); +} + +int CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_get_chunk_size_v1( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_GET_CHUNK_SIZE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_get_chunk_size_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_get_chunk_size_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_vfs_file_get_chunk_size_v1(PtrValue(hdl), PtrValue(context))); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_get_chunk_size_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_get_chunk_size_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_get_chunk_size_v1(m_ifcToAddon->thisClassHdl, hdl, + context); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_io_control_get_seek_possible_v1( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_GET_SEEK_POSSIBLE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_io_control_get_seek_possible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_io_control_get_seek_possible_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_file_io_control_get_seek_possible_v1( + PtrValue(hdl), PtrValue(context))); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_io_control_get_seek_possible_v1, in, + out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_io_control_get_seek_possible_v1 t = + ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_io_control_get_seek_possible_v1( + m_ifcToAddon->thisClassHdl, hdl, context); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_io_control_get_cache_status_v1( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, struct VFS_CACHE_STATUS* status) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_GET_CACHE_STATUS_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, struct VFS_CACHE_STATUS* status); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_io_control_get_cache_status_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_io_control_get_cache_status_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_file_io_control_get_cache_status_v1( + PtrValue(hdl), PtrValue(context))); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_io_control_get_cache_status_v1, in, + out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_io_control_get_cache_status_v1 t = + ident.get().as(); + std::get<1>(t).SetCStructure(status); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_io_control_get_cache_status_v1( + m_ifcToAddon->thisClassHdl, hdl, context, status); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_io_control_set_cache_rate_v1( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, uint32_t rate) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_SET_CACHE_RATE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, uint32_t rate); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_io_control_set_cache_rate_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_io_control_set_cache_rate_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_file_io_control_set_cache_rate_v1( + PtrValue(hdl), PtrValue(context), rate)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_io_control_set_cache_rate_v1, in, + out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_io_control_set_cache_rate_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_io_control_set_cache_rate_v1(m_ifcToAddon->thisClassHdl, + hdl, context, rate); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_io_control_set_retry_v1( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, bool retry) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_SET_RETRY_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, bool retry); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_io_control_set_retry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_io_control_set_retry_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_file_io_control_set_retry_v1( + PtrValue(hdl), PtrValue(context), retry)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_file_io_control_set_retry_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_file_io_control_set_retry_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_file_io_control_set_retry_v1(m_ifcToAddon->thisClassHdl, hdl, + context, retry); +} + +int CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_stat_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_STAT_STRUCTURE* buffer) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_STAT_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, struct VFS_STAT_STRUCTURE* buffer); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_stat_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_stat_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_stat_v1(PtrValue(hdl), url)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, funcChild_kodi_addon_vfs_stat_v1, in, + out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_stat_v1 t = ident.get().as(); + std::get<1>(t).SetCStructure(buffer); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_stat_v1(m_ifcToAddon->thisClassHdl, hdl, url, buffer); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_exists_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_EXISTS_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_exists_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_exists_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_exists_v1(PtrValue(hdl), url)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, funcChild_kodi_addon_vfs_exists_v1, + in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_exists_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_exists_v1(m_ifcToAddon->thisClassHdl, hdl, url); +} + +void CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_clear_out_idle_v1(const KODI_ADDON_VFS_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_CLEAR_OUT_IDLE_V1)(const KODI_ADDON_VFS_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_clear_out_idle_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_clear_out_idle_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_clear_out_idle_v1(PtrValue(hdl))); + m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_clear_out_idle_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_vfs_clear_out_idle_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_disconnect_all_v1(const KODI_ADDON_VFS_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DISCONNECT_ALL_V1)(const KODI_ADDON_VFS_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_disconnect_all_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_disconnect_all_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_disconnect_all_v1(PtrValue(hdl))); + m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_disconnect_all_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_vfs_disconnect_all_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_delete_it_v1( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DELETE_IT_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_delete_it_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_delete_it_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_delete_it_v1(PtrValue(hdl), url)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_delete_it_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_delete_it_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_delete_it_v1(m_ifcToAddon->thisClassHdl, hdl, url); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_rename_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + const struct KODI_ADDON_VFS_URL* url2) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_RENAME_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, const struct KODI_ADDON_VFS_URL* url2); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_rename_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_rename_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_rename_v1(PtrValue(hdl), url, url2)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, funcChild_kodi_addon_vfs_rename_v1, + in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_rename_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_rename_v1(m_ifcToAddon->thisClassHdl, hdl, url, url2); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_exists_v1( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_EXISTS_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_directory_exists_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_directory_exists_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_directory_exists_v1(PtrValue(hdl), url)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_directory_exists_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_directory_exists_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_directory_exists_v1(m_ifcToAddon->thisClassHdl, hdl, url); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_remove_v1( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_REMOVE_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_directory_remove_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_directory_remove_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_directory_remove_v1(PtrValue(hdl), url)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_directory_remove_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_directory_remove_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_directory_remove_v1(m_ifcToAddon->thisClassHdl, hdl, url); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_create_v1( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_CREATE_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_directory_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_directory_create_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_directory_create_v1(PtrValue(hdl), url)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_directory_create_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_directory_create_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_directory_create_v1(m_ifcToAddon->thisClassHdl, hdl, url); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_get_v1( + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** entries, + size_t* num_entries, + KODI_CTX_CB_HDL ctx_cb_hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_GET_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, struct VFS_DIR_ENTRY** entries, size_t* num_entries, KODI_CTX_CB_HDL ctx_cb_hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_directory_get_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_vfs_directory_get_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_directory_get_v1(PtrValue(hdl), url, *num_entries, + PtrValue(ctx_cb_hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_directory_get_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_directory_get_v1 t = ident.get().as(); + std::vector& ifc_entries = std::get<1>(t); + *num_entries = std::get<2>(t); + *entries = static_cast(malloc(sizeof(VFS_DIR_ENTRY) * ifc_entries.size())); + for (size_t i = 0; i < ifc_entries.size(); ++i) + ifc_entries[i].SetCStructure(&(*entries)[i]); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_directory_get_v1(m_ifcToAddon->thisClassHdl, hdl, url, + entries, num_entries, ctx_cb_hdl); +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_contains_files_v1( + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** entries, + size_t* num_entries, + char** rootpath) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_CONTAINS_FILES_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, struct VFS_DIR_ENTRY** entries, size_t* num_entries, char** rootpath); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_directory_contains_files_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t, std::string> msgChild_OUT_kodi_addon_vfs_directory_contains_files_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_vfs_directory_contains_files_v1(PtrValue(hdl), url, + *num_entries)); + if (!m_process->SendMessage(funcGroup_addoninstance_vfs_h, + funcChild_kodi_addon_vfs_directory_contains_files_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_vfs_directory_contains_files_v1 t = ident.get().as(); + std::vector& ifc_entries = std::get<1>(t); + *num_entries = std::get<2>(t); + *rootpath = strdup(std::get<3>(t).c_str()); + *entries = static_cast(malloc(sizeof(VFS_DIR_ENTRY) * ifc_entries.size())); + for (size_t i = 0; i < ifc_entries.size(); ++i) + ifc_entries[i].SetCStructure(&(*entries)[i]); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_vfs_directory_contains_files_v1( + m_ifcToAddon->thisClassHdl, hdl, url, entries, num_entries, rootpath); +} + +// Callbacks from addon to Kodi + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_CTX_CB_HDL ctx_cb_hdl, + const char* heading, + char** input, + bool hidden_input) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "ADDON::CVFSEntry" with "bool DoGetKeyboardInput(KODI_CTX_CB_HDL context, const char* heading, char** input, bool hidden_input)" on "addons/VFSEntry.h". + + ADDON::CVFSEntry* cb = static_cast(hdl); + return cb->DoGetKeyboardInput(ctx_cb_hdl, heading, input, hidden_input); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_get_dir_cb__set_error_dialog_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_CTX_CB_HDL ctx_cb_hdl, + const char* heading, + const char* line1, + const char* line2, + const char* line3) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "ADDON::CVFSEntry" with "void DoSetErrorDialog(KODI_CTX_CB_HDL ctx, const char* heading, const char* line1, const char* line2, const char* line3)" on "addons/VFSEntry.h". + + ADDON::CVFSEntry* cb = static_cast(hdl); + cb->DoSetErrorDialog(ctx_cb_hdl, heading, line1, line2, line3); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_get_dir_cb__require_authentication_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_CTX_CB_HDL ctx_cb_hdl, + const char* url) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "ADDON::CVFSEntry" with "void DoRequireAuthentication(KODI_CTX_CB_HDL ctx, const char* url)" on "addons/VFSEntry.h". + + ADDON::CVFSEntry* cb = static_cast(hdl); + cb->DoRequireAuthentication(ctx_cb_hdl, url); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +void CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_free_v1(struct VFS_DIR_ENTRY* entries, + size_t num_entries) +{ + for (size_t i = 0; i < num_entries; ++i) + { + if (entries[i].properties) + { + for (size_t j = 0; j < entries[i].num_props; ++j) + { + free(entries[i].properties[j].name); + free(entries[i].properties[j].val); + } + free(entries[i].properties); + } + free(entries[i].label); + free(entries[i].title); + free(entries[i].path); + } + free(entries); +} +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/vfs.h b/xbmc/addons/interface/api/addon-instance/vfs.h new file mode 100644 index 0000000000000..218097c86b9f4 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/vfs.h @@ -0,0 +1,183 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/vfs.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_vfs_h; +struct directFuncToKodi_addoninstance_vfs_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_vfs_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_vfs_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_vfs_h* ifcToKodi, + directFuncToAddon_addoninstance_vfs_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + void kodi_addon_vfs_directory_free_v1(struct VFS_DIR_ENTRY* entries, size_t num_entries); + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + KODI_VFS_FILE_HDL kodi_addon_vfs_file_open_v1( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + KODI_VFS_FILE_HDL kodi_addon_vfs_file_open_for_write_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + bool overwrite); // Added with API 1 + + bool kodi_addon_vfs_file_close_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context); // Added with API 1 + + ssize_t kodi_addon_vfs_file_read_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + uint8_t* buffer, + size_t buf_size); // Added with API 1 + + ssize_t kodi_addon_vfs_file_write_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + const uint8_t* buffer, + size_t buf_size); // Added with API 1 + + int64_t kodi_addon_vfs_file_seek_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t position, + int whence); // Added with API 1 + + int kodi_addon_vfs_file_truncate_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t size); // Added with API 1 + + int64_t kodi_addon_vfs_file_get_length_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context); // Added with API 1 + + int64_t kodi_addon_vfs_file_get_position_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context); // Added with API 1 + + int kodi_addon_vfs_file_get_chunk_size_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context); // Added with API 1 + + bool kodi_addon_vfs_file_io_control_get_seek_possible_v1( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); // Added with API 1 + + bool kodi_addon_vfs_file_io_control_get_cache_status_v1( + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + struct VFS_CACHE_STATUS* status); // Added with API 1 + + bool kodi_addon_vfs_file_io_control_set_cache_rate_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + uint32_t rate); // Added with API 1 + + bool kodi_addon_vfs_file_io_control_set_retry_v1(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + bool retry); // Added with API 1 + + int kodi_addon_vfs_stat_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_STAT_STRUCTURE* buffer); // Added with API 1 + + bool kodi_addon_vfs_exists_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + void kodi_addon_vfs_clear_out_idle_v1(const KODI_ADDON_VFS_HDL hdl); // Added with API 1 + + void kodi_addon_vfs_disconnect_all_v1(const KODI_ADDON_VFS_HDL hdl); // Added with API 1 + + bool kodi_addon_vfs_delete_it_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + bool kodi_addon_vfs_rename_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + const struct KODI_ADDON_VFS_URL* url2); // Added with API 1 + + bool kodi_addon_vfs_directory_exists_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + bool kodi_addon_vfs_directory_remove_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + bool kodi_addon_vfs_directory_create_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + bool kodi_addon_vfs_directory_get_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** entries, + size_t* num_entries, + KODI_CTX_CB_HDL ctx_cb_hdl); // Added with API 1 + + bool kodi_addon_vfs_directory_contains_files_v1(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** entries, + size_t* num_entries, + char** rootpath); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static bool kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_CTX_CB_HDL ctx_cb_hdl, + const char* heading, + char** input, + bool hidden_input); // Added with API 1 + + static void kodi_addon_vfs_get_dir_cb__set_error_dialog_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_CTX_CB_HDL ctx_cb_hdl, + const char* heading, + const char* line1, + const char* line2, + const char* line3); // Added with API 1 + + static void kodi_addon_vfs_get_dir_cb__require_authentication_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_CTX_CB_HDL ctx_cb_hdl, + const char* url); // Added with API 1 + + directFuncToAddon_addoninstance_vfs_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/videocodec.cpp b/xbmc/addons/interface/api/addon-instance/videocodec.cpp new file mode 100644 index 0000000000000..614877e7c77e9 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/videocodec.cpp @@ -0,0 +1,174 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "videocodec.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/videocodec.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "cores/VideoPlayer/DVDCodecs/Video/AddonVideoCodec.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_videocodec_h::InitDirect( + directFuncToKodi_addoninstance_videocodec_h* ifcToKodi, + directFuncToAddon_addoninstance_videocodec_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_addon_videocodec_get_frame_buffer_v1 = kodi_addon_videocodec_get_frame_buffer_v1; + ifcToKodi->kodi_addon_videocodec_release_frame_buffer_v1 = + kodi_addon_videocodec_release_frame_buffer_v1; +} + +bool CHdl_kodi_addoninstance_videocodec_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_videocodec_h) + return false; + + switch (func) + { + /* NOTE: Ignored as direct api only is set! */ + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_videocodec_h::{}: addon called with unknown function id " + "'{}' on group 'addoninstance_videocodec_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +KODI_ADDON_VIDEOCODEC_HDL CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_create_v1( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl) +{ + // Original API call: typedef KODI_ADDON_VIDEOCODEC_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_CREATE_V1)(KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + + return m_ifcToAddon->kodi_addon_videocodec_create_v1(m_ifcToAddon->thisClassHdl, kodi_hdl); +} + +void CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_destroy_v1( + KODI_ADDON_VIDEOCODEC_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_DESTROY_V1)(KODI_ADDON_VIDEOCODEC_HDL hdl); + + m_ifcToAddon->kodi_addon_videocodec_destroy_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_open_v1( + KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_INITDATA* initData) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_OPEN_V1)(KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_INITDATA* initData); + + return m_ifcToAddon->kodi_addon_videocodec_open_v1(m_ifcToAddon->thisClassHdl, hdl, initData); +} + +bool CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_reconfigure_v1( + KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_INITDATA* initData) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_RECONFIGURE_V1)(KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_INITDATA* initData); + + return m_ifcToAddon->kodi_addon_videocodec_reconfigure_v1(m_ifcToAddon->thisClassHdl, hdl, + initData); +} + +bool CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_add_data_v1( + KODI_ADDON_VIDEOCODEC_HDL hdl, const struct DEMUX_PACKET* packet) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_ADD_DATA_V1)(KODI_ADDON_VIDEOCODEC_HDL hdl, const struct DEMUX_PACKET* packet); + + return m_ifcToAddon->kodi_addon_videocodec_add_data_v1(m_ifcToAddon->thisClassHdl, hdl, packet); +} + +enum VIDEOCODEC_RETVAL CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_get_picture_v1( + KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_PICTURE* picture) +{ + // Original API call: typedef enum VIDEOCODEC_RETVAL(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_GET_PICTURE_V1)(KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_PICTURE* picture); + + return m_ifcToAddon->kodi_addon_videocodec_get_picture_v1(m_ifcToAddon->thisClassHdl, hdl, + picture); +} + +const char* CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_get_name_v1( + KODI_ADDON_VIDEOCODEC_HDL hdl) +{ + // Original API call: typedef const char*(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_GET_NAME_V1)(KODI_ADDON_VIDEOCODEC_HDL hdl); + + return m_ifcToAddon->kodi_addon_videocodec_get_name_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_reset_v1( + KODI_ADDON_VIDEOCODEC_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_RESET_V1)(KODI_ADDON_VIDEOCODEC_HDL hdl); + + m_ifcToAddon->kodi_addon_videocodec_reset_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +// Callbacks from addon to Kodi + +bool CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_get_frame_buffer_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct VIDEOCODEC_PICTURE* picture) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "CAddonVideoCodec" with "bool GetFrameBuffer(VIDEOCODEC_PICTURE* picture)" on "cores/VideoPlayer/DVDCodecs/Video/AddonVideoCodec.h". + + CAddonVideoCodec* cb = static_cast(hdl); + return cb->GetFrameBuffer(picture); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_release_frame_buffer_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct VIDEOCODEC_PICTURE* picture) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "CAddonVideoCodec" with "void ReleaseFrameBuffer(KODI_HANDLE videoBufferHandle)" on "cores/VideoPlayer/DVDCodecs/Video/AddonVideoCodec.h". + + CAddonVideoCodec* cb = static_cast(hdl); + cb->ReleaseFrameBuffer(picture); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/videocodec.h b/xbmc/addons/interface/api/addon-instance/videocodec.h new file mode 100644 index 0000000000000..42976aa4ab3a1 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/videocodec.h @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/videocodec.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_videocodec_h; +struct directFuncToKodi_addoninstance_videocodec_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_videocodec_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_videocodec_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_videocodec_h* ifcToKodi, + directFuncToAddon_addoninstance_videocodec_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + KODI_ADDON_VIDEOCODEC_HDL kodi_addon_videocodec_create_v1( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); // Added with API 1 + + void kodi_addon_videocodec_destroy_v1(KODI_ADDON_VIDEOCODEC_HDL hdl); // Added with API 1 + + bool kodi_addon_videocodec_open_v1(KODI_ADDON_VIDEOCODEC_HDL hdl, + struct VIDEOCODEC_INITDATA* initData); // Added with API 1 + + bool kodi_addon_videocodec_reconfigure_v1( + KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_INITDATA* initData); // Added with API 1 + + bool kodi_addon_videocodec_add_data_v1(KODI_ADDON_VIDEOCODEC_HDL hdl, + const struct DEMUX_PACKET* packet); // Added with API 1 + + enum VIDEOCODEC_RETVAL kodi_addon_videocodec_get_picture_v1( + KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_PICTURE* picture); // Added with API 1 + + const char* kodi_addon_videocodec_get_name_v1(KODI_ADDON_VIDEOCODEC_HDL hdl); // Added with API 1 + + void kodi_addon_videocodec_reset_v1(KODI_ADDON_VIDEOCODEC_HDL hdl); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static bool kodi_addon_videocodec_get_frame_buffer_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct VIDEOCODEC_PICTURE* picture); // Added with API 1 + + static void kodi_addon_videocodec_release_frame_buffer_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct VIDEOCODEC_PICTURE* picture); // Added with API 1 + + directFuncToAddon_addoninstance_videocodec_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/visualization.cpp b/xbmc/addons/interface/api/addon-instance/visualization.cpp new file mode 100644 index 0000000000000..14775f17979fe --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/visualization.cpp @@ -0,0 +1,623 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "visualization.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/visualization.h" + +// Kodi +#include "addons/Visualization.h" +#include "addons/interface/IOffscreenRenderProcess.h" +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_visualization_h::InitDirect( + directFuncToKodi_addoninstance_visualization_h* ifcToKodi, + directFuncToAddon_addoninstance_visualization_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_addon_visualization_get_properties_v1 = + kodi_addon_visualization_get_properties_v1; + ifcToKodi->kodi_addon_visualization_transfer_preset_v1 = + kodi_addon_visualization_transfer_preset_v1; + ifcToKodi->kodi_addon_visualization_clear_presets_v1 = kodi_addon_visualization_clear_presets_v1; +} + +bool CHdl_kodi_addoninstance_visualization_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_visualization_h) + return false; + + switch (func) + { + case funcParent_kodi_addon_visualization_get_properties_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_visualization_get_properties(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct KODI_ADDON_VISUALIZATION_PROPS* props) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_visualization_get_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_visualization_get_properties_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_visualization_get_properties_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + struct KODI_ADDON_VISUALIZATION_PROPS props = {}; + kodi_addon_visualization_get_properties_v1(this, hdl, &props); + msgpack::pack(out, msgParent_OUT_kodi_addon_visualization_get_properties_v1(&props)); + return true; + } + case funcParent_kodi_addon_visualization_transfer_preset_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_visualization_transfer_preset(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* preset) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_visualization_transfer_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_visualization_transfer_preset_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_visualization_transfer_preset_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& preset = std::get<1>(t); + kodi_addon_visualization_transfer_preset_v1(this, hdl, preset.c_str()); + return true; + } + case funcParent_kodi_addon_visualization_clear_presets_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_visualization_clear_presets(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_visualization_clear_presets_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_visualization_clear_presets_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_visualization_clear_presets_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + kodi_addon_visualization_clear_presets_v1(this, hdl); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_visualization_h::{}: addon called with unknown function " + "id '{}' on group 'addoninstance_visualization_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_start_v1( + IOffscreenRenderProcess* proc, + const KODI_ADDON_VISUALIZATION_HDL hdl, + int channels, + int samples_per_sec, + int bits_per_sample, + const char* song_name) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_START_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, int channels, int samples_per_sec, int bits_per_sample, const char* song_name); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_start_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_start_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + int x = 0; + int y = 0; + int width = 0; + int height = 0; + ADDON_HARDWARE_CONTEXT context = nullptr; + if (!proc || !proc->GetOffscreenRenderInfos(x, y, width, height, context) || + !proc->CreateRenderHelper(m_process)) + return false; + + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_start_v1( + PtrKodiOffscreen(proc), proc->GetUsedId(), x, y, width, height, + PtrValue(context), PtrValue(hdl), channels, samples_per_sec, + bits_per_sample, song_name)); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_start_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_start_v1 t = ident.get().as(); + if (std::get<1>(t) == 0 || std::get<2>(t) == false) + return false; + proc->SetAddonOffscreenHdl(std::get<1>(t)); + proc->GetRenderHelper()->Init(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_start_v1( + m_ifcToAddon->thisClassHdl, hdl, channels, samples_per_sec, bits_per_sample, song_name); +} + +void CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_stop_v1( + IOffscreenRenderProcess* proc, const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_STOP_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_stop_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_stop_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + if (!proc) + return; + + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_stop_v1(proc->GetAddonOffscreenHdl(), + PtrValue(hdl))); + m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_stop_v1, in); + + proc->GetRenderHelper()->Deinit(); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_visualization_stop_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +int CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_get_sync_delay_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_GET_SYNC_DELAY_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_get_sync_delay_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_get_sync_delay_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_get_sync_delay_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_get_sync_delay_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_get_sync_delay_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_get_sync_delay_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_audio_data_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl, const float* audio_data, size_t audio_data_length) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_AUDIO_DATA_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, const float* audio_data, size_t audio_data_length); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_visualization_audio_data_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_audio_data_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgChild__IN_kodi_addon_visualization_audio_data_v1( + PtrValue(hdl), std::vector(audio_data, audio_data + audio_data_length), + audio_data_length)); + m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_audio_data_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_visualization_audio_data_v1(m_ifcToAddon->thisClassHdl, hdl, audio_data, + audio_data_length); +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_is_dirty_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_IS_DIRTY_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_is_dirty_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_is_dirty_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_is_dirty_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_is_dirty_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_is_dirty_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_is_dirty_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_render_v1( + IOffscreenRenderProcess* proc, const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_RENDER_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_render_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_render_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + if (!proc) + return; + + proc->GetRenderHelper()->Begin(); + + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_render_v1(proc->GetAddonOffscreenHdl(), + PtrValue(hdl))); + m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_render_v1, in); + + proc->GetRenderHelper()->End(); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_visualization_render_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +unsigned int CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_get_presets_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef unsigned int(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_GET_PRESETS_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_get_presets_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_get_presets_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_get_presets_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_get_presets_v1, in, out)) + return 0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_get_presets_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_get_presets_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +int CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_get_active_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_GET_ACTIVE_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_get_active_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_get_active_preset_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_get_active_preset_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_get_active_preset_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_get_active_preset_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_get_active_preset_v1(m_ifcToAddon->thisClassHdl, + hdl); +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_prev_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_PREV_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_prev_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_prev_preset_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_prev_preset_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_prev_preset_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_prev_preset_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_prev_preset_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_next_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_NEXT_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_next_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_next_preset_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_next_preset_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_next_preset_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_next_preset_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_next_preset_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_load_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl, int select) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_LOAD_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, int select); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_load_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_load_preset_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_load_preset_v1(PtrValue(hdl), select)); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_load_preset_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_load_preset_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_load_preset_v1(m_ifcToAddon->thisClassHdl, hdl, + select); +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_random_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_RANDOM_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_random_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_random_preset_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_random_preset_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_random_preset_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_random_preset_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_random_preset_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_lock_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_LOCK_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_lock_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_lock_preset_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_lock_preset_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_lock_preset_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_lock_preset_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_lock_preset_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_rate_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl, bool plus_minus) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_RATE_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, bool plus_minus); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_rate_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_rate_preset_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_visualization_rate_preset_v1(PtrValue(hdl), plus_minus)); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_rate_preset_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_rate_preset_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_rate_preset_v1(m_ifcToAddon->thisClassHdl, hdl, + plus_minus); +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_is_locked_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_IS_LOCKED_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_is_locked_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_is_locked_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_is_locked_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_is_locked_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_is_locked_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_is_locked_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_update_albumart_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl, const char* albumart) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_UPDATE_ALBUMART_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, const char* albumart); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_update_albumart_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_update_albumart_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgChild__IN_kodi_addon_visualization_update_albumart_v1(PtrValue(hdl), albumart)); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_update_albumart_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_update_albumart_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_update_albumart_v1(m_ifcToAddon->thisClassHdl, hdl, + albumart); +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_update_track_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl, const struct KODI_ADDON_VISUALIZATION_TRACK* track) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_UPDATE_TRACK_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, const struct KODI_ADDON_VISUALIZATION_TRACK* track); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_update_track_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_update_track_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_visualization_update_track_v1(PtrValue(hdl), track)); + if (!m_process->SendMessage(funcGroup_addoninstance_visualization_h, + funcChild_kodi_addon_visualization_update_track_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_visualization_update_track_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_visualization_update_track_v1(m_ifcToAddon->thisClassHdl, hdl, + track); +} + +// Callbacks from addon to Kodi + +void CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_get_properties_v1( + void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct KODI_ADDON_VISUALIZATION_PROPS* props) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::CVisualization" with "void get_properties(KODI_ADDON_VISUALIZATION_PROPS* props)" on "addons/Visualization.h". + + KODI::ADDONS::CVisualization* cb = static_cast(hdl); + cb->get_properties(props); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_transfer_preset_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* preset) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::CVisualization" with "void transfer_preset(const char* preset)" on "addons/Visualization.h". + + KODI::ADDONS::CVisualization* cb = static_cast(hdl); + cb->transfer_preset(preset); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_clear_presets_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::CVisualization" with "void clear_presets()" on "addons/Visualization.h". + + KODI::ADDONS::CVisualization* cb = static_cast(hdl); + cb->clear_presets(); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/visualization.h b/xbmc/addons/interface/api/addon-instance/visualization.h new file mode 100644 index 0000000000000..bb457f3acad42 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/visualization.h @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/visualization.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class IOffscreenRenderProcess; +struct directFuncToAddon_addoninstance_visualization_h; +struct directFuncToKodi_addoninstance_visualization_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_visualization_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_visualization_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_visualization_h* ifcToKodi, + directFuncToAddon_addoninstance_visualization_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + bool kodi_addon_visualization_start_v1(IOffscreenRenderProcess* proc, + const KODI_ADDON_VISUALIZATION_HDL hdl, + int channels, + int samples_per_sec, + int bits_per_sample, + const char* song_name); // Added with API 1 + + void kodi_addon_visualization_stop_v1(IOffscreenRenderProcess* proc, + const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + int kodi_addon_visualization_get_sync_delay_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + void kodi_addon_visualization_audio_data_v1(const KODI_ADDON_VISUALIZATION_HDL hdl, + const float* audio_data, + size_t audio_data_length); // Added with API 1 + + bool kodi_addon_visualization_is_dirty_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + void kodi_addon_visualization_render_v1( + IOffscreenRenderProcess* proc, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + unsigned int kodi_addon_visualization_get_presets_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + int kodi_addon_visualization_get_active_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + bool kodi_addon_visualization_prev_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + bool kodi_addon_visualization_next_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + bool kodi_addon_visualization_load_preset_v1(const KODI_ADDON_VISUALIZATION_HDL hdl, + int select); // Added with API 1 + + bool kodi_addon_visualization_random_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + bool kodi_addon_visualization_lock_preset_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + bool kodi_addon_visualization_rate_preset_v1(const KODI_ADDON_VISUALIZATION_HDL hdl, + bool plus_minus); // Added with API 1 + + bool kodi_addon_visualization_is_locked_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + bool kodi_addon_visualization_update_albumart_v1(const KODI_ADDON_VISUALIZATION_HDL hdl, + const char* albumart); // Added with API 1 + + bool kodi_addon_visualization_update_track_v1( + const KODI_ADDON_VISUALIZATION_HDL hdl, + const struct KODI_ADDON_VISUALIZATION_TRACK* track); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_addon_visualization_get_properties_v1( + void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct KODI_ADDON_VISUALIZATION_PROPS* props); // Added with API 1 + + static void kodi_addon_visualization_transfer_preset_v1(void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* preset); // Added with API 1 + + static void kodi_addon_visualization_clear_presets_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + directFuncToAddon_addoninstance_visualization_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/web.cpp b/xbmc/addons/interface/api/addon-instance/web.cpp new file mode 100644 index 0000000000000..38105b8358761 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/web.cpp @@ -0,0 +1,1147 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "web.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon-instance/web.h" + +// Kodi +#include "addons/interface/IOffscreenRenderProcess.h" +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" +#include "web/WebAddon.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_web_h::InitDirect(directFuncToKodi_addoninstance_web_h* ifcToKodi, + directFuncToAddon_addoninstance_web_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_addon_web_inhibit_shutdown_v1 = kodi_addon_web_inhibit_shutdown_v1; + ifcToKodi->kodi_addon_web_inhibit_screensaver_v1 = kodi_addon_web_inhibit_screensaver_v1; + ifcToKodi->kodi_addon_web_is_muted_v1 = kodi_addon_web_is_muted_v1; + ifcToKodi->kodi_addon_web_control_set_control_ready_v1 = + kodi_addon_web_control_set_control_ready_v1; + ifcToKodi->kodi_addon_web_control_set_opened_address_v1 = + kodi_addon_web_control_set_opened_address_v1; + ifcToKodi->kodi_addon_web_control_set_opened_title_v1 = + kodi_addon_web_control_set_opened_title_v1; + ifcToKodi->kodi_addon_web_control_set_icon_url_v1 = kodi_addon_web_control_set_icon_url_v1; + ifcToKodi->kodi_addon_web_control_set_fullscreen_v1 = kodi_addon_web_control_set_fullscreen_v1; + ifcToKodi->kodi_addon_web_control_set_loading_state_v1 = + kodi_addon_web_control_set_loading_state_v1; + ifcToKodi->kodi_addon_web_control_set_tooltip_v1 = kodi_addon_web_control_set_tooltip_v1; + ifcToKodi->kodi_addon_web_control_set_status_message_v1 = + kodi_addon_web_control_set_status_message_v1; + ifcToKodi->kodi_addon_web_control_request_open_site_in_new_tab_v1 = + kodi_addon_web_control_request_open_site_in_new_tab_v1; +} + +bool CHdl_kodi_addoninstance_web_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_web_h) + return false; + + switch (func) + { + case funcParent_kodi_addon_web_inhibit_shutdown_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_inhibit_shutdown(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, bool inhibit); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_inhibit_shutdown_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_inhibit_shutdown_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_inhibit_shutdown_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + bool inhibit = std::get<1>(t); + kodi_addon_web_inhibit_shutdown_v1(this, hdl, inhibit); + return true; + } + case funcParent_kodi_addon_web_inhibit_screensaver_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_inhibit_screensaver(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, bool inhibit); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_inhibit_screensaver_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_inhibit_screensaver_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_inhibit_screensaver_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + bool inhibit = std::get<1>(t); + kodi_addon_web_inhibit_screensaver_v1(this, hdl, inhibit); + return true; + } + case funcParent_kodi_addon_web_is_muted_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_web_is_muted(KODI_ADDON_INSTANCE_BACKEND_HDL hdl); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_is_muted_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_is_muted_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_is_muted_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_addon_web_is_muted_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_addon_web_is_muted_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_web_control_set_control_ready_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_control_ready(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, bool ready); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_control_ready_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_control_ready_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_control_set_control_ready_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + bool ready = std::get<2>(t); + kodi_addon_web_control_set_control_ready_v1(this, hdl, handle, ready); + return true; + } + case funcParent_kodi_addon_web_control_set_opened_address_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_opened_address(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* title); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_opened_address_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_opened_address_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_control_set_opened_address_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + const std::string& title = std::get<2>(t); + kodi_addon_web_control_set_opened_address_v1(this, hdl, handle, title.c_str()); + return true; + } + case funcParent_kodi_addon_web_control_set_opened_title_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_opened_title(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* title); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_opened_title_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_opened_title_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_control_set_opened_title_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + const std::string& title = std::get<2>(t); + kodi_addon_web_control_set_opened_title_v1(this, hdl, handle, title.c_str()); + return true; + } + case funcParent_kodi_addon_web_control_set_icon_url_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_icon_url(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* icon); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_icon_url_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_icon_url_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_control_set_icon_url_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + const std::string& icon = std::get<2>(t); + kodi_addon_web_control_set_icon_url_v1(this, hdl, handle, icon.c_str()); + return true; + } + case funcParent_kodi_addon_web_control_set_fullscreen_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_fullscreen(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, bool fullscreen); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_fullscreen_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_fullscreen_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_control_set_fullscreen_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + bool fullscreen = std::get<2>(t); + kodi_addon_web_control_set_fullscreen_v1(this, hdl, handle, fullscreen); + return true; + } + case funcParent_kodi_addon_web_control_set_loading_state_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_loading_state(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, bool isLoading, bool canGoBack, bool canGoForward); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_loading_state_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_loading_state_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_control_set_loading_state_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + bool isLoading = std::get<2>(t); + bool canGoBack = std::get<3>(t); + bool canGoForward = std::get<4>(t); + kodi_addon_web_control_set_loading_state_v1(this, hdl, handle, isLoading, canGoBack, + canGoForward); + return true; + } + case funcParent_kodi_addon_web_control_set_tooltip_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_tooltip(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* tooltip); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_tooltip_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_tooltip_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_control_set_tooltip_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + const std::string& tooltip = std::get<2>(t); + kodi_addon_web_control_set_tooltip_v1(this, hdl, handle, tooltip.c_str()); + return true; + } + case funcParent_kodi_addon_web_control_set_status_message_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_status_message(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* status); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_status_message_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_status_message_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_control_set_status_message_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + const std::string& status = std::get<2>(t); + kodi_addon_web_control_set_status_message_v1(this, hdl, handle, status.c_str()); + return true; + } + case funcParent_kodi_addon_web_control_request_open_site_in_new_tab_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_request_open_site_in_new_tab(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* url); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_request_open_site_in_new_tab_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_request_open_site_in_new_tab_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_web_control_request_open_site_in_new_tab_v1 t = + in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + const std::string& url = std::get<2>(t); + kodi_addon_web_control_request_open_site_in_new_tab_v1(this, hdl, handle, url.c_str()); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addoninstance_web_h::{}: addon called with unknown function id '{}' on " + "group 'addoninstance_web_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +enum WEB_ADDON_ERROR CHdl_kodi_addoninstance_web_h::kodi_addon_web_start_instance_v1( + const KODI_ADDON_WEB_HDL hdl) +{ + // Original API call: typedef enum WEB_ADDON_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_START_INSTANCE_V1)(const KODI_ADDON_WEB_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_start_instance_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_start_instance_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_web_start_instance_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_start_instance_v1, in, out)) + return WEB_ADDON_ERROR_PERMANENT_FAILED; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_start_instance_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_start_instance_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_stop_instance_v1(const KODI_ADDON_WEB_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_STOP_INSTANCE_V1)(const KODI_ADDON_WEB_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_stop_instance_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_stop_instance_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_stop_instance_v1(PtrValue(hdl))); + m_process->SendMessage(funcGroup_addoninstance_web_h, funcChild_kodi_addon_web_stop_instance_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_stop_instance_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_main_initialize_v1(const KODI_ADDON_WEB_HDL hdl) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_MAIN_INITIALIZE_V1)(const KODI_ADDON_WEB_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_main_initialize_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_main_initialize_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_web_main_initialize_v1(PtrValue(hdl))); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_main_initialize_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_main_initialize_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_main_initialize_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_main_loop_v1(const KODI_ADDON_WEB_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_MAIN_LOOP_V1)(const KODI_ADDON_WEB_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_main_loop_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_main_loop_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_main_loop_v1(PtrValue(hdl))); + m_process->SendMessage(funcGroup_addoninstance_web_h, funcChild_kodi_addon_web_main_loop_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_main_loop_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_main_shutdown_v1(const KODI_ADDON_WEB_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_MAIN_SHUTDOWN_V1)(const KODI_ADDON_WEB_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_main_shutdown_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_main_shutdown_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_main_shutdown_v1(PtrValue(hdl))); + m_process->SendMessage(funcGroup_addoninstance_web_h, funcChild_kodi_addon_web_main_shutdown_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_main_shutdown_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_set_mute_v1(const KODI_ADDON_WEB_HDL hdl, + bool mute) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_SET_MUTE_V1)(const KODI_ADDON_WEB_HDL hdl, bool mute); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_set_mute_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_set_mute_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_set_mute_v1(PtrValue(hdl), mute)); + m_process->SendMessage(funcGroup_addoninstance_web_h, funcChild_kodi_addon_web_set_mute_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_set_mute_v1(m_ifcToAddon->thisClassHdl, hdl, mute); +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_set_language_v1(const KODI_ADDON_WEB_HDL hdl, + const char* language) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_SET_LANGUAGE_V1)(const KODI_ADDON_WEB_HDL hdl, const char* language); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_set_language_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_set_language_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_web_set_language_v1(PtrValue(hdl), language)); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_set_language_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_set_language_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_set_language_v1(m_ifcToAddon->thisClassHdl, hdl, language); +} + +enum WEB_ADDON_ERROR CHdl_kodi_addoninstance_web_h::kodi_addon_web_create_control_v1( + const KODI_ADDON_WEB_HDL hdl, + const struct WEB_ADDON_GUI_PROPS* props, + const char* start_url, + WEB_KODI_CONTROL* handle) +{ + // Original API call: typedef enum WEB_ADDON_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CREATE_CONTROL_V1)(const KODI_ADDON_WEB_HDL hdl, const struct WEB_ADDON_GUI_PROPS* props, const char* start_url, WEB_KODI_CONTROL* handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_create_control_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_create_control_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_web_create_control_v1(PtrValue(hdl), props, start_url)); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_create_control_v1, in, out)) + return WEB_ADDON_ERROR_PERMANENT_FAILED; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_create_control_v1 t = ident.get().as(); + *handle = reinterpret_cast(std::get<1>(t)); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_create_control_v1(m_ifcToAddon->thisClassHdl, hdl, props, + start_url, handle); +} + +enum WEB_ADDON_ERROR CHdl_kodi_addoninstance_web_h::kodi_addon_web_destroy_control_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, bool complete) +{ + // Original API call: typedef enum WEB_ADDON_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_DESTROY_CONTROL_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, bool complete); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_destroy_control_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_destroy_control_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_web_destroy_control_v1(PtrValue(hdl), + PtrValue(handle), complete)); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_destroy_control_v1, in, out)) + return WEB_ADDON_ERROR_PERMANENT_FAILED; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_destroy_control_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_destroy_control_v1(m_ifcToAddon->thisClassHdl, hdl, handle, + complete); +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_render_init_v1( + IOffscreenRenderProcess* proc, const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_RENDER_INIT_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_render_init_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_render_init_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + int x = 0; + int y = 0; + int width = 0; + int height = 0; + ADDON_HARDWARE_CONTEXT context = nullptr; + if (!proc || !proc->GetOffscreenRenderInfos(x, y, width, height, context) || + !proc->CreateRenderHelper(m_process)) + return false; + + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_render_init_v1( + PtrKodiOffscreen(proc), proc->GetUsedId(), x, y, width, height, + PtrValue(context), PtrValue(hdl), PtrValue(handle))); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_render_init_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_control_render_init_v1 t = ident.get().as(); + if (std::get<1>(t) == 0 || std::get<2>(t) == false) + return false; + proc->SetAddonOffscreenHdl(std::get<1>(t)); + proc->GetRenderHelper()->Init(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_control_render_init_v1(m_ifcToAddon->thisClassHdl, hdl, + handle); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_render_deinit_v1( + IOffscreenRenderProcess* proc, const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_RENDER_DEINIT_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_render_deinit_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_render_deinit_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + if (!proc) + return; + + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_render_deinit_v1( + proc->GetAddonOffscreenHdl(), PtrValue(hdl), PtrValue(handle))); + m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_render_deinit_v1, in); + + proc->GetRenderHelper()->Deinit(); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_control_render_deinit_v1(m_ifcToAddon->thisClassHdl, hdl, handle); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_render_v1(IOffscreenRenderProcess* proc, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_RENDER_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_render_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_render_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + if (!proc) + return; + + proc->GetRenderHelper()->Begin(); + + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_render_v1( + proc->GetAddonOffscreenHdl(), PtrValue(hdl), PtrValue(handle))); + m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_render_v1, in); + + proc->GetRenderHelper()->End(); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_control_render_v1(m_ifcToAddon->thisClassHdl, hdl, handle); +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_dirty_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_DIRTY_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_dirty_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_dirty_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_web_control_dirty_v1(PtrValue(hdl), PtrValue(handle))); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_dirty_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_control_dirty_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_control_dirty_v1(m_ifcToAddon->thisClassHdl, hdl, handle); +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_on_init_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_ON_INIT_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_on_init_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_on_init_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_web_control_on_init_v1(PtrValue(hdl), PtrValue(handle))); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_on_init_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_control_on_init_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_control_on_init_v1(m_ifcToAddon->thisClassHdl, hdl, handle); +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_on_action_v1( + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const struct KODI_ADDON_ACTION_DATA* action, + int* nextItem) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_ON_ACTION_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, const struct KODI_ADDON_ACTION_DATA* action, int* nextItem); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_on_action_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_on_action_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_on_action_v1( + PtrValue(hdl), PtrValue(handle), action, *nextItem)); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_on_action_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_control_on_action_v1 t = ident.get().as(); + *nextItem = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_control_on_action_v1(m_ifcToAddon->thisClassHdl, hdl, handle, + action, nextItem); +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_on_mouse_event_v1( + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + int id, + double x, + double y, + double offsetX, + double offsetY, + int state) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_ON_MOUSE_EVENT_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, int id, double x, double y, double offsetX, double offsetY, int state); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_on_mouse_event_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_on_mouse_event_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_on_mouse_event_v1( + PtrValue(hdl), PtrValue(handle), id, x, y, offsetX, offsetY, state)); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_on_mouse_event_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_control_on_mouse_event_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_control_on_mouse_event_v1( + m_ifcToAddon->thisClassHdl, hdl, handle, id, x, y, offsetX, offsetY, state); +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_open_website_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, const char* url) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_OPEN_WEBSITE_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, const char* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_open_website_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_open_website_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_open_website_v1(PtrValue(hdl), + PtrValue(handle), url)); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_open_website_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_control_open_website_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_control_open_website_v1(m_ifcToAddon->thisClassHdl, hdl, + handle, url); +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_get_history_v1( + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + char*** list, + size_t* entries, + bool behind_current) +{ + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_GET_HISTORY_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, char*** list, size_t* entries, bool behind_current); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_get_history_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_web_control_get_history_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_get_history_v1( + PtrValue(hdl), PtrValue(handle), *entries, behind_current)); + if (!m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_get_history_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_web_control_get_history_v1 t = ident.get().as(); + const std::vector& cpp_list = std::get<1>(t); + + *entries = std::get<2>(t); + assert(cpp_list.size() == *entries); + if (!cpp_list.empty()) + { + *list = static_cast(malloc(*entries * sizeof(char*))); + for (size_t i = 0; i < *entries; ++i) + (*list)[i] = strdup(cpp_list[i].c_str()); + } + else + { + *list = nullptr; + } + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_web_control_get_history_v1(m_ifcToAddon->thisClassHdl, hdl, + handle, list, entries, behind_current); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_search_text_v1( + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* text, + bool forward, + bool matchCase, + bool findNext) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SEARCH_TEXT_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, const char* text, bool forward, bool matchCase, bool findNext); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_search_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_search_text_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_search_text_v1( + PtrValue(hdl), PtrValue(handle), text, forward, matchCase, findNext)); + m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_search_text_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_control_search_text_v1(m_ifcToAddon->thisClassHdl, hdl, handle, text, + forward, matchCase, findNext); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_stop_search_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, bool clearSelection) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_STOP_SEARCH_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, bool clearSelection); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_stop_search_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_stop_search_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_stop_search_v1( + PtrValue(hdl), PtrValue(handle), clearSelection)); + m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_stop_search_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_control_stop_search_v1(m_ifcToAddon->thisClassHdl, hdl, handle, + clearSelection); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_web_cmd_reload_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_RELOAD_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_web_cmd_reload_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_web_cmd_reload_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgChild__IN_kodi_addon_web_control_web_cmd_reload_v1(PtrValue(hdl), PtrValue(handle))); + m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_web_cmd_reload_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_control_web_cmd_reload_v1(m_ifcToAddon->thisClassHdl, hdl, handle); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_web_cmd_stop_load_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_STOP_LOAD_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_web_cmd_stop_load_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_web_cmd_stop_load_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_web_cmd_stop_load_v1(PtrValue(hdl), + PtrValue(handle))); + m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_web_cmd_stop_load_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_control_web_cmd_stop_load_v1(m_ifcToAddon->thisClassHdl, hdl, + handle); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_web_cmd_nav_back_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_NAV_BACK_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_web_cmd_nav_back_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_web_cmd_nav_back_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_web_cmd_nav_back_v1(PtrValue(hdl), + PtrValue(handle))); + m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_web_cmd_nav_back_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_control_web_cmd_nav_back_v1(m_ifcToAddon->thisClassHdl, hdl, handle); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_web_cmd_nav_forward_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_NAV_FORWARD_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_web_cmd_nav_forward_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_web_cmd_nav_forward_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_web_cmd_nav_forward_v1(PtrValue(hdl), + PtrValue(handle))); + m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_web_cmd_nav_forward_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_control_web_cmd_nav_forward_v1(m_ifcToAddon->thisClassHdl, hdl, + handle); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_web_open_own_context_menu_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_OPEN_OWN_CONTEXT_MENU_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_web_open_own_context_menu_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_web_open_own_context_menu_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_web_open_own_context_menu_v1( + PtrValue(hdl), PtrValue(handle))); + m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_web_open_own_context_menu_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_control_web_open_own_context_menu_v1(m_ifcToAddon->thisClassHdl, hdl, + handle); +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_screen_size_change_v1( + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + float x, + float y, + float width, + float height, + bool fullscreen) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SCREEN_SIZE_CHANGE_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, float x, float y, float width, float height, bool fullscreen); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_screen_size_change_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_screen_size_change_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_web_control_screen_size_change_v1( + PtrValue(hdl), PtrValue(handle), x, y, width, height, fullscreen)); + m_process->SendMessage(funcGroup_addoninstance_web_h, + funcChild_kodi_addon_web_control_screen_size_change_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_web_control_screen_size_change_v1( + m_ifcToAddon->thisClassHdl, hdl, handle, x, y, width, height, fullscreen); +} + +// Callbacks from addon to Kodi + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_inhibit_shutdown_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, bool inhibit) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_inhibit_shutdown(bool inhibit)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_inhibit_shutdown(inhibit); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_inhibit_screensaver_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, bool inhibit) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_inhibit_screensaver(bool inhibit)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_inhibit_screensaver(inhibit); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_is_muted_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "bool cb_is_muted()" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + return cb->cb_is_muted(); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_set_control_ready_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, bool ready) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_control_set_control_ready(WEB_KODI_CONTROL handle, bool ready)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_control_set_control_ready(handle, ready); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_set_opened_address_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* title) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_control_set_opened_address(WEB_KODI_CONTROL handle, const char* address)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_control_set_opened_address(handle, title); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_set_opened_title_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* title) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_control_set_opened_title(WEB_KODI_CONTROL handle, const char* title)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_control_set_opened_title(handle, title); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_set_icon_url_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* icon) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_control_set_icon_url(WEB_KODI_CONTROL handle, const char* icon)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_control_set_icon_url(handle, icon); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_set_fullscreen_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool fullscreen) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_control_set_fullscreen(WEB_KODI_CONTROL handle, bool fullscreen)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_control_set_fullscreen(handle, fullscreen); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_set_loading_state_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool isLoading, + bool canGoBack, + bool canGoForward) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_control_set_loading_state(WEB_KODI_CONTROL handle, bool isLoading, bool canGoBack, bool canGoForward)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_control_set_loading_state(handle, isLoading, canGoBack, canGoForward); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_set_tooltip_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* tooltip) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_control_set_tooltip(WEB_KODI_CONTROL handle, const char* tooltip)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_control_set_tooltip(handle, tooltip); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_set_status_message_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* status) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_control_set_status_message(WEB_KODI_CONTROL handle, const char* status)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_control_set_status_message(handle, status); + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_request_open_site_in_new_tab_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* url) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::WEB::CWebAddon" with "void cb_control_request_open_site_in_new_tab(WEB_KODI_CONTROL handle, const char* url)" on "web/WebAddon.h". + + KODI::WEB::CWebAddon* cb = static_cast(hdl); + cb->cb_control_request_open_site_in_new_tab(handle, url); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon-instance/web.h b/xbmc/addons/interface/api/addon-instance/web.h new file mode 100644 index 0000000000000..48a3a2846ca95 --- /dev/null +++ b/xbmc/addons/interface/api/addon-instance/web.h @@ -0,0 +1,229 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/web.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class IOffscreenRenderProcess; +struct directFuncToAddon_addoninstance_web_h; +struct directFuncToKodi_addoninstance_web_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addoninstance_web_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_web_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addoninstance_web_h* ifcToKodi, + directFuncToAddon_addoninstance_web_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + enum WEB_ADDON_ERROR kodi_addon_web_start_instance_v1( + const KODI_ADDON_WEB_HDL hdl); // Added with API 1 + + void kodi_addon_web_stop_instance_v1(const KODI_ADDON_WEB_HDL hdl); // Added with API 1 + + bool kodi_addon_web_main_initialize_v1(const KODI_ADDON_WEB_HDL hdl); // Added with API 1 + + void kodi_addon_web_main_loop_v1(const KODI_ADDON_WEB_HDL hdl); // Added with API 1 + + void kodi_addon_web_main_shutdown_v1(const KODI_ADDON_WEB_HDL hdl); // Added with API 1 + + void kodi_addon_web_set_mute_v1(const KODI_ADDON_WEB_HDL hdl, bool mute); // Added with API 1 + + bool kodi_addon_web_set_language_v1(const KODI_ADDON_WEB_HDL hdl, + const char* language); // Added with API 1 + + enum WEB_ADDON_ERROR kodi_addon_web_create_control_v1( + const KODI_ADDON_WEB_HDL hdl, + const struct WEB_ADDON_GUI_PROPS* props, + const char* start_url, + WEB_KODI_CONTROL* handle); // Added with API 1 + + enum WEB_ADDON_ERROR kodi_addon_web_destroy_control_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + bool complete); // Added with API 1 + + bool kodi_addon_web_control_render_init_v1(IOffscreenRenderProcess* proc, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + void kodi_addon_web_control_render_deinit_v1(IOffscreenRenderProcess* proc, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + void kodi_addon_web_control_render_v1(IOffscreenRenderProcess* proc, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + bool kodi_addon_web_control_dirty_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + bool kodi_addon_web_control_on_init_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + bool kodi_addon_web_control_on_action_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const struct KODI_ADDON_ACTION_DATA* action, + int* nextItem); // Added with API 1 + + bool kodi_addon_web_control_on_mouse_event_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + int id, + double x, + double y, + double offsetX, + double offsetY, + int state); // Added with API 1 + + bool kodi_addon_web_control_open_website_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* url); // Added with API 1 + + bool kodi_addon_web_control_get_history_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + char*** list, + size_t* entries, + bool behind_current); // Added with API 1 + + void kodi_addon_web_control_search_text_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* text, + bool forward, + bool matchCase, + bool findNext); // Added with API 1 + + void kodi_addon_web_control_stop_search_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + bool clearSelection); // Added with API 1 + + void kodi_addon_web_control_web_cmd_reload_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + void kodi_addon_web_control_web_cmd_stop_load_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); // Added with API 1 + + void kodi_addon_web_control_web_cmd_nav_back_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); // Added with API 1 + + void kodi_addon_web_control_web_cmd_nav_forward_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); // Added with API 1 + + void kodi_addon_web_control_web_open_own_context_menu_v1( + const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); // Added with API 1 + + void kodi_addon_web_control_screen_size_change_v1(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + float x, + float y, + float width, + float height, + bool fullscreen); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_addon_web_inhibit_shutdown_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + bool inhibit); // Added with API 1 + + static void kodi_addon_web_inhibit_screensaver_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + bool inhibit); // Added with API 1 + + static bool kodi_addon_web_is_muted_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + static void kodi_addon_web_control_set_control_ready_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool ready); // Added with API 1 + + static void kodi_addon_web_control_set_opened_address_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* title); // Added with API 1 + + static void kodi_addon_web_control_set_opened_title_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* title); // Added with API 1 + + static void kodi_addon_web_control_set_icon_url_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* icon); // Added with API 1 + + static void kodi_addon_web_control_set_fullscreen_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool fullscreen); // Added with API 1 + + static void kodi_addon_web_control_set_loading_state_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool isLoading, + bool canGoBack, + bool canGoForward); // Added with API 1 + + static void kodi_addon_web_control_set_tooltip_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* tooltip); // Added with API 1 + + static void kodi_addon_web_control_set_status_message_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* status); // Added with API 1 + + static void kodi_addon_web_control_request_open_site_in_new_tab_v1( + void* thisClassHdl, + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* url); // Added with API 1 + + directFuncToAddon_addoninstance_web_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon_base.cpp b/xbmc/addons/interface/api/addon_base.cpp new file mode 100644 index 0000000000000..6e281cc86279d --- /dev/null +++ b/xbmc/addons/interface/api/addon_base.cpp @@ -0,0 +1,1515 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "addon_base.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/addon_base.h" + +// Kodi +#include "addons/interface/InstanceHandler.h" +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +#include "Application.h" +#include "GUIUserMessages.h" +#include "addons/AddonManager.h" +#include "addons/gui/GUIDialogAddonSettings.h" +#include "addons/settings/AddonSettings.h" +#include "filesystem/Directory.h" +#include "filesystem/File.h" +#include "filesystem/SpecialProtocol.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/LocalizeStrings.h" +#include "utils/URIUtils.h" +#include "utils/log.h" +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +bool CHdl_kodi_addon_base_h::UpdateSettingInActiveDialog(const std::string& addonId, + const std::string& id, + const std::string& value) +{ + if (!CServiceBroker::GetGUI()->GetWindowManager().IsWindowActive(WINDOW_DIALOG_ADDON_SETTINGS)) + return false; + + CGUIDialogAddonSettings* dialog = + CServiceBroker::GetGUI()->GetWindowManager().GetWindow( + WINDOW_DIALOG_ADDON_SETTINGS); + if (dialog->GetCurrentAddonID() != addonId) + return false; + + CGUIMessage message(GUI_MSG_SETTING_UPDATED, 0, 0); + std::vector params; + params.emplace_back(id); + params.push_back(value); + message.SetStringParams(params); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(message, + WINDOW_DIALOG_ADDON_SETTINGS); + + return true; +} + +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addon_base_h::InitDirect(directFuncToKodi_addon_base_h* ifcToKodi, + directFuncToAddon_addon_base_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + // Unused "kodi_check_main_shared", done only in addon lib + // Unused "kodi_init", done only in addon lib + // Unused "kodi_deinit", done only in addon lib + // Unused "kodi_process", done only in addon lib + ifcToKodi->kodi_log_v1 = kodi_log_v1; + ifcToKodi->kodi_addon_get_addon_path_v1 = kodi_addon_get_addon_path_v1; + ifcToKodi->kodi_addon_get_lib_path_v1 = kodi_addon_get_lib_path_v1; + ifcToKodi->kodi_addon_get_user_path_v1 = kodi_addon_get_user_path_v1; + ifcToKodi->kodi_addon_get_temp_path_v1 = kodi_addon_get_temp_path_v1; + ifcToKodi->kodi_addon_localized_string_v1 = kodi_addon_localized_string_v1; + ifcToKodi->kodi_addon_get_info_v1 = kodi_addon_get_info_v1; + ifcToKodi->kodi_addon_open_settings_dialog_v1 = kodi_addon_open_settings_dialog_v1; + ifcToKodi->kodi_addon_is_setting_using_default_v1 = kodi_addon_is_setting_using_default_v1; + ifcToKodi->kodi_addon_get_setting_bool_v1 = kodi_addon_get_setting_bool_v1; + ifcToKodi->kodi_addon_get_setting_int_v1 = kodi_addon_get_setting_int_v1; + ifcToKodi->kodi_addon_get_setting_float_v1 = kodi_addon_get_setting_float_v1; + ifcToKodi->kodi_addon_get_setting_string_v1 = kodi_addon_get_setting_string_v1; + ifcToKodi->kodi_addon_set_setting_bool_v1 = kodi_addon_set_setting_bool_v1; + ifcToKodi->kodi_addon_set_setting_int_v1 = kodi_addon_set_setting_int_v1; + ifcToKodi->kodi_addon_set_setting_float_v1 = kodi_addon_set_setting_float_v1; + ifcToKodi->kodi_addon_set_setting_string_v1 = kodi_addon_set_setting_string_v1; + ifcToKodi->kodi_addon_instance_get_user_path_v1 = kodi_addon_instance_get_user_path_v1; + ifcToKodi->kodi_addon_instance_is_setting_using_default_v1 = + kodi_addon_instance_is_setting_using_default_v1; + ifcToKodi->kodi_addon_instance_get_setting_bool_v1 = kodi_addon_instance_get_setting_bool_v1; + ifcToKodi->kodi_addon_instance_get_setting_int_v1 = kodi_addon_instance_get_setting_int_v1; + ifcToKodi->kodi_addon_instance_get_setting_float_v1 = kodi_addon_instance_get_setting_float_v1; + ifcToKodi->kodi_addon_instance_get_setting_string_v1 = kodi_addon_instance_get_setting_string_v1; + ifcToKodi->kodi_addon_instance_set_setting_bool_v1 = kodi_addon_instance_set_setting_bool_v1; + ifcToKodi->kodi_addon_instance_set_setting_int_v1 = kodi_addon_instance_set_setting_int_v1; + ifcToKodi->kodi_addon_instance_set_setting_float_v1 = kodi_addon_instance_set_setting_float_v1; + ifcToKodi->kodi_addon_instance_set_setting_string_v1 = kodi_addon_instance_set_setting_string_v1; +} + +bool CHdl_kodi_addon_base_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addon_base_h) + return false; + + switch (func) + { + case funcParent_kodi_log_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_log(enum ADDON_LOG loglevel, const char* format, ...) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_log_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_log_v1; /* Autogenerated */ + msgParent__IN_kodi_log_v1 t = in.get().as(); + enum ADDON_LOG loglevel = std::get<0>(t); + const std::string& format = std::get<1>(t); + kodi_log_v1(this, loglevel, format.c_str()); + return true; + } + case funcParent_kodi_addon_get_addon_path_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_get_addon_path() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_addon_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_addon_path_v1; /* Autogenerated */ + char* auto_gen_ret = kodi_addon_get_addon_path_v1(this); + msgpack::pack(out, + msgParent_OUT_kodi_addon_get_addon_path_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_addon_get_lib_path_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_get_lib_path() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_lib_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_lib_path_v1; /* Autogenerated */ + char* auto_gen_ret = kodi_addon_get_lib_path_v1(this); + msgpack::pack(out, + msgParent_OUT_kodi_addon_get_lib_path_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_addon_get_user_path_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_get_user_path() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_user_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_user_path_v1; /* Autogenerated */ + char* auto_gen_ret = kodi_addon_get_user_path_v1(this); + msgpack::pack(out, + msgParent_OUT_kodi_addon_get_user_path_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_addon_get_temp_path_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_get_temp_path() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_temp_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_temp_path_v1; /* Autogenerated */ + char* auto_gen_ret = kodi_addon_get_temp_path_v1(this); + msgpack::pack(out, + msgParent_OUT_kodi_addon_get_temp_path_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_addon_localized_string_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_localized_string(long label_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_localized_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_localized_string_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_localized_string_v1 t = in.get().as(); + long label_id = std::get<0>(t); + char* auto_gen_ret = kodi_addon_localized_string_v1(this, label_id); + msgpack::pack(out, + msgParent_OUT_kodi_addon_localized_string_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_addon_get_info_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_get_info(const char* id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_info_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_info_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_get_info_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + char* auto_gen_ret = kodi_addon_get_info_v1(this, id.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_addon_get_info_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_addon_open_settings_dialog_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_open_settings_dialog() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_open_settings_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_open_settings_dialog_v1; /* Autogenerated */ + bool auto_gen_ret = kodi_addon_open_settings_dialog_v1(this); + msgpack::pack(out, msgParent_OUT_kodi_addon_open_settings_dialog_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_is_setting_using_default_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_is_setting_using_default(const char* id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_is_setting_using_default_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_is_setting_using_default_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_is_setting_using_default_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + bool auto_gen_ret = kodi_addon_is_setting_using_default_v1(this, id.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_addon_is_setting_using_default_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_get_setting_bool_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_get_setting_bool(const char* id, bool* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_setting_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_setting_bool_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_get_setting_bool_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + bool value = std::get<1>(t); + bool auto_gen_ret = kodi_addon_get_setting_bool_v1(this, id.c_str(), &value); + msgpack::pack(out, msgParent_OUT_kodi_addon_get_setting_bool_v1(auto_gen_ret, value)); + return true; + } + case funcParent_kodi_addon_get_setting_int_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_get_setting_int(const char* id, int* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_setting_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_setting_int_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_get_setting_int_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + int value = std::get<1>(t); + bool auto_gen_ret = kodi_addon_get_setting_int_v1(this, id.c_str(), &value); + msgpack::pack(out, msgParent_OUT_kodi_addon_get_setting_int_v1(auto_gen_ret, value)); + return true; + } + case funcParent_kodi_addon_get_setting_float_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_get_setting_float(const char* id, double* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_setting_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_setting_float_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_get_setting_float_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + double value = std::get<1>(t); + bool auto_gen_ret = kodi_addon_get_setting_float_v1(this, id.c_str(), &value); + msgpack::pack(out, msgParent_OUT_kodi_addon_get_setting_float_v1(auto_gen_ret, value)); + return true; + } + case funcParent_kodi_addon_get_setting_string_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_get_setting_string(const char* id, char** value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_setting_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_setting_string_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_get_setting_string_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + char* value = nullptr; + bool auto_gen_ret = kodi_addon_get_setting_string_v1(this, id.c_str(), &value); + msgpack::pack( + out, msgParent_OUT_kodi_addon_get_setting_string_v1(auto_gen_ret, value ? value : "")); + if (value) + free(value); + return true; + } + case funcParent_kodi_addon_set_setting_bool_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_set_setting_bool(const char* id, bool value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_set_setting_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_set_setting_bool_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_set_setting_bool_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + bool value = std::get<1>(t); + bool auto_gen_ret = kodi_addon_set_setting_bool_v1(this, id.c_str(), value); + msgpack::pack(out, msgParent_OUT_kodi_addon_set_setting_bool_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_set_setting_int_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_set_setting_int(const char* id, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_set_setting_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_set_setting_int_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_set_setting_int_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + int value = std::get<1>(t); + bool auto_gen_ret = kodi_addon_set_setting_int_v1(this, id.c_str(), value); + msgpack::pack(out, msgParent_OUT_kodi_addon_set_setting_int_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_set_setting_float_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_set_setting_float(const char* id, double value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_set_setting_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_set_setting_float_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_set_setting_float_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + double value = std::get<1>(t); + bool auto_gen_ret = kodi_addon_set_setting_float_v1(this, id.c_str(), value); + msgpack::pack(out, msgParent_OUT_kodi_addon_set_setting_float_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_set_setting_string_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_set_setting_string(const char* id, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_set_setting_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_set_setting_string_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_set_setting_string_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + const std::string& value = std::get<1>(t); + bool auto_gen_ret = kodi_addon_set_setting_string_v1(this, id.c_str(), value.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_addon_set_setting_string_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_instance_get_user_path_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_instance_get_user_path(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_get_user_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_get_user_path_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_instance_get_user_path_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_addon_instance_get_user_path_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_addon_instance_get_user_path_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_addon_instance_is_setting_using_default_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_is_setting_using_default( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_is_setting_using_default_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_is_setting_using_default_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_instance_is_setting_using_default_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& id = std::get<1>(t); + bool auto_gen_ret = kodi_addon_instance_is_setting_using_default_v1(this, hdl, id.c_str()); + msgpack::pack(out, + msgParent_OUT_kodi_addon_instance_is_setting_using_default_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_instance_get_setting_bool_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_bool( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, bool* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_get_setting_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_get_setting_bool_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_instance_get_setting_bool_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& id = std::get<1>(t); + bool value = std::get<2>(t); + bool auto_gen_ret = kodi_addon_instance_get_setting_bool_v1(this, hdl, id.c_str(), &value); + msgpack::pack(out, + msgParent_OUT_kodi_addon_instance_get_setting_bool_v1(auto_gen_ret, value)); + return true; + } + case funcParent_kodi_addon_instance_get_setting_int_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_int( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, int* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_get_setting_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_get_setting_int_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_instance_get_setting_int_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& id = std::get<1>(t); + int value = std::get<2>(t); + bool auto_gen_ret = kodi_addon_instance_get_setting_int_v1(this, hdl, id.c_str(), &value); + msgpack::pack(out, msgParent_OUT_kodi_addon_instance_get_setting_int_v1(auto_gen_ret, value)); + return true; + } + case funcParent_kodi_addon_instance_get_setting_float_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_float( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, double* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_get_setting_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_get_setting_float_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_instance_get_setting_float_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& id = std::get<1>(t); + double value = std::get<2>(t); + bool auto_gen_ret = kodi_addon_instance_get_setting_float_v1(this, hdl, id.c_str(), &value); + msgpack::pack(out, + msgParent_OUT_kodi_addon_instance_get_setting_float_v1(auto_gen_ret, value)); + return true; + } + case funcParent_kodi_addon_instance_get_setting_string_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_string( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, char** value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_get_setting_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_get_setting_string_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_instance_get_setting_string_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& id = std::get<1>(t); + char* value = nullptr; + bool auto_gen_ret = kodi_addon_instance_get_setting_string_v1(this, hdl, id.c_str(), &value); + msgpack::pack(out, msgParent_OUT_kodi_addon_instance_get_setting_string_v1( + auto_gen_ret, value ? value : "")); + if (value) + free(value); + return true; + } + case funcParent_kodi_addon_instance_set_setting_bool_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_bool( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, bool value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_set_setting_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_set_setting_bool_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_instance_set_setting_bool_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& id = std::get<1>(t); + bool value = std::get<2>(t); + bool auto_gen_ret = kodi_addon_instance_set_setting_bool_v1(this, hdl, id.c_str(), value); + msgpack::pack(out, msgParent_OUT_kodi_addon_instance_set_setting_bool_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_instance_set_setting_int_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_int( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_set_setting_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_set_setting_int_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_instance_set_setting_int_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& id = std::get<1>(t); + int value = std::get<2>(t); + bool auto_gen_ret = kodi_addon_instance_set_setting_int_v1(this, hdl, id.c_str(), value); + msgpack::pack(out, msgParent_OUT_kodi_addon_instance_set_setting_int_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_instance_set_setting_float_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_float( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, double value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_set_setting_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_set_setting_float_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_instance_set_setting_float_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& id = std::get<1>(t); + double value = std::get<2>(t); + bool auto_gen_ret = kodi_addon_instance_set_setting_float_v1(this, hdl, id.c_str(), value); + msgpack::pack(out, msgParent_OUT_kodi_addon_instance_set_setting_float_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_addon_instance_set_setting_string_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_string( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_set_setting_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_set_setting_string_v1; /* Autogenerated */ + msgParent__IN_kodi_addon_instance_set_setting_string_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_BACKEND_HDL hdl = + reinterpret_cast(std::get<0>(t)); + const std::string& id = std::get<1>(t); + const std::string& value = std::get<2>(t); + bool auto_gen_ret = + kodi_addon_instance_set_setting_string_v1(this, hdl, id.c_str(), value.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_addon_instance_set_setting_string_v1(auto_gen_ret)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_addon_base_h::{}: addon called with unknown function id '{}' on group " + "'addon_base_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_create_v1( + const struct KODI_ADDON_INSTANCE_INFO* first_instance, KODI_ADDON_HDL* hdl) +{ + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_CREATE_V1)(const struct KODI_ADDON_INSTANCE_INFO* first_instance, KODI_ADDON_HDL* hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_create_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_create_v1(first_instance)); + if (!m_process->SendMessage(funcGroup_addon_base_h, funcChild_kodi_addon_create_v1, in, out)) + return ADDON_STATUS_OK; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_create_v1 t = ident.get().as(); + *hdl = reinterpret_cast(std::get<1>(t)); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_create_v1(m_ifcToAddon->thisClassHdl, first_instance, hdl); +} + +void CHdl_kodi_addon_base_h::kodi_addon_destroy_v1(KODI_ADDON_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_DESTROY_V1)(KODI_ADDON_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_destroy_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_destroy_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_destroy_v1(PtrValue(hdl))); + m_process->SendMessage(funcGroup_addon_base_h, funcChild_kodi_addon_destroy_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_destroy_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_setting_change_string_v1( + const KODI_ADDON_HDL hdl, const char* name, const char* value) +{ + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_STRING_V1)(const KODI_ADDON_HDL hdl, const char* name, const char* value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_setting_change_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_setting_change_string_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_setting_change_string_v1(PtrValue(hdl), name, value)); + if (!m_process->SendMessage(funcGroup_addon_base_h, + funcChild_kodi_addon_setting_change_string_v1, in, out)) + return ADDON_STATUS_OK; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_setting_change_string_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_setting_change_string_v1(m_ifcToAddon->thisClassHdl, hdl, name, + value); +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_setting_change_boolean_v1( + const KODI_ADDON_HDL hdl, const char* name, bool value) +{ + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_BOOLEAN_V1)(const KODI_ADDON_HDL hdl, const char* name, bool value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_setting_change_boolean_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_setting_change_boolean_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_setting_change_boolean_v1(PtrValue(hdl), name, value)); + if (!m_process->SendMessage(funcGroup_addon_base_h, + funcChild_kodi_addon_setting_change_boolean_v1, in, out)) + return ADDON_STATUS_OK; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_setting_change_boolean_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_setting_change_boolean_v1(m_ifcToAddon->thisClassHdl, hdl, name, + value); +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_setting_change_integer_v1( + const KODI_ADDON_HDL hdl, const char* name, int value) +{ + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_INTEGER_V1)(const KODI_ADDON_HDL hdl, const char* name, int value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_setting_change_integer_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_setting_change_integer_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgChild__IN_kodi_addon_setting_change_integer_v1(PtrValue(hdl), name, value)); + if (!m_process->SendMessage(funcGroup_addon_base_h, + funcChild_kodi_addon_setting_change_integer_v1, in, out)) + return ADDON_STATUS_OK; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_setting_change_integer_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_setting_change_integer_v1(m_ifcToAddon->thisClassHdl, hdl, name, + value); +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_setting_change_float_v1( + const KODI_ADDON_HDL hdl, const char* name, double value) +{ + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_FLOAT_V1)(const KODI_ADDON_HDL hdl, const char* name, double value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_setting_change_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_setting_change_float_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_setting_change_float_v1(PtrValue(hdl), name, value)); + if (!m_process->SendMessage(funcGroup_addon_base_h, + funcChild_kodi_addon_setting_change_float_v1, in, out)) + return ADDON_STATUS_OK; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_setting_change_float_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_setting_change_float_v1(m_ifcToAddon->thisClassHdl, hdl, name, + value); +} + +/*---AUTO_GEN_PARSE---*/ +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_create_instance_v1( + const KODI_ADDON_HDL hdl, const struct KODI_ADDON_INSTANCE_INFO* info, KODI_HANDLE* instance) +{ + // This function is set by "OVERRIDE;USE_HAND_MAKE" and must be complete set here and other places by hand!!! +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_create_instance_v1(PtrValue(hdl), info)); + if (!m_process->SendMessage(funcGroup_addon_base_h, funcChild_kodi_addon_create_instance_v1, in, + out)) + return ADDON_STATUS_UNKNOWN; + + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_create_instance_v1 t = ident.get().as(); + *instance = KODI_HANDLE(std::get<1>(t)); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_create_instance_v1(m_ifcToAddon->thisClassHdl, hdl, info, + instance); +} +/*---AUTO_GEN_PARSE---*/ + +/*---AUTO_GEN_PARSE---*/ +void CHdl_kodi_addon_base_h::kodi_addon_destroy_instance_v1( + const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + const KODI_HANDLE instance) +{ + // This function is set by "OVERRIDE;USE_HAND_MAKE" and must be complete set here and other places by hand!!! + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgChild__IN_kodi_addon_destroy_instance_v1(PtrValue(hdl), info, PtrValue(instance))); + m_process->SendMessage(funcGroup_addon_base_h, funcChild_kodi_addon_destroy_instance_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_destroy_instance_v1(m_ifcToAddon->thisClassHdl, hdl, info, instance); +} +/*---AUTO_GEN_PARSE---*/ + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_instance_setting_change_string_v1( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + const char* value) +{ + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_STRING_V1)(const KODI_ADDON_HDL hdl, const KODI_ADDON_INSTANCE_HDL instance_hdl, const char* name, const char* value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_setting_change_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_setting_change_string_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_instance_setting_change_string_v1( + PtrValue(hdl), PtrValue(instance_hdl), name, value)); + if (!m_process->SendMessage(funcGroup_addon_base_h, + funcChild_kodi_addon_instance_setting_change_string_v1, in, out)) + return ADDON_STATUS_OK; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_instance_setting_change_string_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_instance_setting_change_string_v1(m_ifcToAddon->thisClassHdl, hdl, + instance_hdl, name, value); +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_instance_setting_change_boolean_v1( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + bool value) +{ + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_BOOLEAN_V1)(const KODI_ADDON_HDL hdl, const KODI_ADDON_INSTANCE_HDL instance_hdl, const char* name, bool value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_setting_change_boolean_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_setting_change_boolean_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_instance_setting_change_boolean_v1( + PtrValue(hdl), PtrValue(instance_hdl), name, value)); + if (!m_process->SendMessage(funcGroup_addon_base_h, + funcChild_kodi_addon_instance_setting_change_boolean_v1, in, out)) + return ADDON_STATUS_OK; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_instance_setting_change_boolean_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_instance_setting_change_boolean_v1( + m_ifcToAddon->thisClassHdl, hdl, instance_hdl, name, value); +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_instance_setting_change_integer_v1( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + int value) +{ + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_INTEGER_V1)(const KODI_ADDON_HDL hdl, const KODI_ADDON_INSTANCE_HDL instance_hdl, const char* name, int value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_setting_change_integer_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_setting_change_integer_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_instance_setting_change_integer_v1( + PtrValue(hdl), PtrValue(instance_hdl), name, value)); + if (!m_process->SendMessage(funcGroup_addon_base_h, + funcChild_kodi_addon_instance_setting_change_integer_v1, in, out)) + return ADDON_STATUS_OK; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_instance_setting_change_integer_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_instance_setting_change_integer_v1( + m_ifcToAddon->thisClassHdl, hdl, instance_hdl, name, value); +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_instance_setting_change_float_v1( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + double value) +{ + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_FLOAT_V1)(const KODI_ADDON_HDL hdl, const KODI_ADDON_INSTANCE_HDL instance_hdl, const char* name, double value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_setting_change_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_setting_change_float_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_instance_setting_change_float_v1( + PtrValue(hdl), PtrValue(instance_hdl), name, value)); + if (!m_process->SendMessage(funcGroup_addon_base_h, + funcChild_kodi_addon_instance_setting_change_float_v1, in, out)) + return ADDON_STATUS_OK; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_instance_setting_change_float_v1 t = ident.get().as(); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_instance_setting_change_float_v1(m_ifcToAddon->thisClassHdl, hdl, + instance_hdl, name, value); +} + +KODI_ADDON_INSTANCE_HDL CHdl_kodi_addon_base_h::kodi_addon_instance_create_v1( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl) +{ + // Original API call: typedef KODI_ADDON_INSTANCE_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_CREATE_V1)(KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_create_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgChild__IN_kodi_addon_instance_create_v1(PtrValue(kodi_hdl))); + if (!m_process->SendMessage(funcGroup_addon_base_h, funcChild_kodi_addon_instance_create_v1, in, + out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgChild_OUT_kodi_addon_instance_create_v1 t = ident.get().as(); + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + return m_ifcToAddon->kodi_addon_instance_create_v1(m_ifcToAddon->thisClassHdl, kodi_hdl); +} + +void CHdl_kodi_addon_base_h::kodi_addon_instance_destroy_v1(KODI_ADDON_INSTANCE_HDL hdl) +{ + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_DESTROY_V1)(KODI_ADDON_INSTANCE_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_destroy_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_destroy_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!m_interface.m_directDll) + { + msgpack::sbuffer in; + msgpack::pack(in, msgChild__IN_kodi_addon_instance_destroy_v1(PtrValue(hdl))); + m_process->SendMessage(funcGroup_addon_base_h, funcChild_kodi_addon_instance_destroy_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + m_ifcToAddon->kodi_addon_instance_destroy_v1(m_ifcToAddon->thisClassHdl, hdl); +} + +// Callbacks from addon to Kodi + +void CHdl_kodi_addon_base_h::kodi_log_v1(void* thisClassHdl, + enum ADDON_LOG loglevel, + const char* format, + ...) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + int kodiLogLevel = LOGNONE; + switch (loglevel) + { + case ADDON_LOG_DEBUG: + kodiLogLevel = LOGDEBUG; + break; + case ADDON_LOG_INFO: + kodiLogLevel = LOGINFO; + break; + case ADDON_LOG_WARNING: + kodiLogLevel = LOGWARNING; + break; + case ADDON_LOG_ERROR: + kodiLogLevel = LOGERROR; + break; + case ADDON_LOG_FATAL: + kodiLogLevel = LOGFATAL; + break; + default: + kodiLogLevel = LOGDEBUG; + break; + } + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + CLog::Log(kodiLogLevel, "AddOnLog: {}: {}", addon->ID(), format); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_addon_base_h::kodi_addon_get_addon_path_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + return strdup(CSpecialProtocol::TranslatePath(addon->Path()).c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_addon_base_h::kodi_addon_get_lib_path_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + return strdup(CSpecialProtocol::TranslatePath(addon->Path()).c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_addon_base_h::kodi_addon_get_user_path_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + return strdup(CSpecialProtocol::TranslatePath(addon->Profile()).c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_addon_base_h::kodi_addon_get_temp_path_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + std::string tempPath = + URIUtils::AddFileToFolder(CServiceBroker::GetAddonMgr().GetTempAddonBasePath(), addon->ID()); + tempPath += "-temp"; + XFILE::CDirectory::Create(tempPath); + + return strdup(CSpecialProtocol::TranslatePath(tempPath).c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_addon_base_h::kodi_addon_localized_string_v1(void* thisClassHdl, long label_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + // Code below must be set manually by hand to make work to Kodi + + if (g_application.m_bStop) + return nullptr; + + std::string label = + g_localizeStrings.GetAddonString(thisClass->m_process->GetAddonID(), label_id); + if (label.empty()) + label = g_localizeStrings.Get(label_id); + char* buffer = strdup(label.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_addon_base_h::kodi_addon_get_info_v1(void* thisClassHdl, const char* id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + std::string str; + if (StringUtils::CompareNoCase(id, "author") == 0) + str = addon->Author(); + else if (StringUtils::CompareNoCase(id, "changelog") == 0) + str = addon->ChangeLog(); + else if (StringUtils::CompareNoCase(id, "description") == 0) + str = addon->Description(); + else if (StringUtils::CompareNoCase(id, "disclaimer") == 0) + str = addon->Disclaimer(); + else if (StringUtils::CompareNoCase(id, "fanart") == 0) + str = addon->FanArt(); + else if (StringUtils::CompareNoCase(id, "icon") == 0) + str = addon->Icon(); + else if (StringUtils::CompareNoCase(id, "id") == 0) + str = addon->ID(); + else if (StringUtils::CompareNoCase(id, "name") == 0) + str = addon->Name(); + else if (StringUtils::CompareNoCase(id, "path") == 0) + str = addon->Path(); + else if (StringUtils::CompareNoCase(id, "profile") == 0) + str = addon->Profile(); + else if (StringUtils::CompareNoCase(id, "summary") == 0) + str = addon->Summary(); + else if (StringUtils::CompareNoCase(id, "type") == 0) + str = ADDON::CAddonInfo::TranslateType(addon->Type()); + else if (StringUtils::CompareNoCase(id, "version") == 0) + str = addon->Version().asString(); + else + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - add-on '{}' requests invalid id '{}'", __func__, + addon->ID(), id); + return nullptr; + } + + return strdup(str.c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_open_settings_dialog_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + return CGUIDialogAddonSettings::ShowForAddon(addon); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_is_setting_using_default_v1(void* thisClassHdl, + const char* id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + if (!addon->HasSettings()) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - couldn't get settings for add-on '{}'", __func__, + addon->ID()); + return false; + } + + auto setting = addon->GetSettings()->GetSetting(id); + if (setting == nullptr) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - can't find setting '{}' in '{}'", __func__, id, + addon->ID()); + return false; + } + + return setting->IsDefault(); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_get_setting_bool_v1(void* thisClassHdl, + const char* id, + bool* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + if (!addon->HasSettings()) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - couldn't get settings for add-on '{}'", __func__, + addon->ID()); + return false; + } + + auto setting = addon->GetSettings()->GetSetting(id); + if (setting == nullptr) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - can't find setting '{}' in '{}'", __func__, id, + addon->ID()); + return false; + } + + if (setting->GetType() != SettingType::Boolean) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - setting '{}' is not a boolean in '{}'", __func__, + id, addon->ID()); + return false; + } + + *value = std::static_pointer_cast(setting)->GetValue(); + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_get_setting_int_v1(void* thisClassHdl, + const char* id, + int* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + if (!addon->HasSettings()) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - couldn't get settings for add-on '{}'", __func__, + addon->ID()); + return false; + } + + auto setting = addon->GetSettings()->GetSetting(id); + if (setting == nullptr) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - can't find setting '{}' in '{}'", __func__, id, + addon->ID()); + return false; + } + + if (setting->GetType() != SettingType::Integer && setting->GetType() != SettingType::Number) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - setting '{}' is not a integer in '{}'", __func__, + id, addon->ID()); + return false; + } + + if (setting->GetType() == SettingType::Integer) + *value = std::static_pointer_cast(setting)->GetValue(); + else + *value = static_cast(std::static_pointer_cast(setting)->GetValue()); + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_get_setting_float_v1(void* thisClassHdl, + const char* id, + double* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + if (!addon->HasSettings()) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - couldn't get settings for add-on '{}'", __func__, + addon->ID()); + return false; + } + + auto setting = addon->GetSettings()->GetSetting(id); + if (setting == nullptr) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - can't find setting '{}' in '{}'", __func__, id, + addon->ID()); + return false; + } + + if (setting->GetType() != SettingType::Number) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - setting '{}' is not a number in '{}'", __func__, + id, addon->ID()); + return false; + } + + *value = std::static_pointer_cast(setting)->GetValue(); + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_get_setting_string_v1(void* thisClassHdl, + const char* id, + char** value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + if (!addon->HasSettings()) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - couldn't get settings for add-on '{}'", __func__, + addon->ID()); + return false; + } + + auto setting = addon->GetSettings()->GetSetting(id); + if (setting == nullptr) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - can't find setting '{}' in '{}'", __func__, id, + addon->ID()); + return false; + } + + if (setting->GetType() != SettingType::String) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - setting '{}' is not a string in '{}'", __func__, + id, addon->ID()); + return false; + } + + *value = strdup(std::static_pointer_cast(setting)->GetValue().c_str()); + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_set_setting_bool_v1(void* thisClassHdl, + const char* id, + bool value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + if (UpdateSettingInActiveDialog(addon->ID(), id, StringUtils::Format("%d", value))) + return true; + + if (!addon->UpdateSettingBool(id, value)) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - invalid setting type", __func__); + return false; + } + + addon->SaveSettings(); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_set_setting_int_v1(void* thisClassHdl, + const char* id, + int value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + if (UpdateSettingInActiveDialog(addon->ID(), id, StringUtils::Format("%i", value))) + return true; + + if (!addon->UpdateSettingInt(id, value)) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - invalid setting type", __func__); + return false; + } + + addon->SaveSettings(); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_set_setting_float_v1(void* thisClassHdl, + const char* id, + double value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + if (UpdateSettingInActiveDialog(addon->ID(), id, StringUtils::Format("%f", value))) + return true; + + if (!addon->UpdateSettingNumber(id, value)) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - invalid setting type", __func__); + return false; + } + + addon->SaveSettings(); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_set_setting_string_v1(void* thisClassHdl, + const char* id, + const char* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::shared_ptr addon = thisClass->m_interface.m_process->GetAddon(); + + if (UpdateSettingInActiveDialog(addon->ID(), id, value)) + return true; + + if (!addon->UpdateSettingString(id, value)) + { + CLog::Log(LOGERROR, "CHdlIn_addon_base_h::{} - invalid setting type", __func__); + return false; + } + + addon->SaveSettings(); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_addon_base_h::kodi_addon_instance_get_user_path_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::INTERFACE::IInstanceHandler" with "char* get_instance_user_path()" on "addons/interface/InstanceHandler.h". + + KODI::ADDONS::INTERFACE::IInstanceHandler* cb = + static_cast(hdl); + return cb->get_instance_user_path(); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_instance_is_setting_using_default_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::INTERFACE::IInstanceHandler" with "bool is_instance_setting_using_default(const char* id)" on "addons/interface/InstanceHandler.h". + + KODI::ADDONS::INTERFACE::IInstanceHandler* cb = + static_cast(hdl); + return cb->is_instance_setting_using_default(id); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_instance_get_setting_bool_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, bool* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::INTERFACE::IInstanceHandler" with "bool get_instance_setting_bool(const char* id, bool* value)" on "addons/interface/InstanceHandler.h". + + KODI::ADDONS::INTERFACE::IInstanceHandler* cb = + static_cast(hdl); + return cb->get_instance_setting_bool(id, value); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_instance_get_setting_int_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, int* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::INTERFACE::IInstanceHandler" with "bool get_instance_setting_int(const char* id, int* value)" on "addons/interface/InstanceHandler.h". + + KODI::ADDONS::INTERFACE::IInstanceHandler* cb = + static_cast(hdl); + return cb->get_instance_setting_int(id, value); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_instance_get_setting_float_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, double* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::INTERFACE::IInstanceHandler" with "bool get_instance_setting_float(const char* id, double* value)" on "addons/interface/InstanceHandler.h". + + KODI::ADDONS::INTERFACE::IInstanceHandler* cb = + static_cast(hdl); + return cb->get_instance_setting_float(id, value); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_instance_get_setting_string_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, char** value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::INTERFACE::IInstanceHandler" with "bool get_instance_setting_string(const char* id, char** value)" on "addons/interface/InstanceHandler.h". + + KODI::ADDONS::INTERFACE::IInstanceHandler* cb = + static_cast(hdl); + return cb->get_instance_setting_string(id, value); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_instance_set_setting_bool_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, bool value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::INTERFACE::IInstanceHandler" with "bool set_instance_setting_bool(const char* id, bool value)" on "addons/interface/InstanceHandler.h". + + KODI::ADDONS::INTERFACE::IInstanceHandler* cb = + static_cast(hdl); + return cb->set_instance_setting_bool(id, value); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_instance_set_setting_int_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, int value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::INTERFACE::IInstanceHandler" with "bool set_instance_setting_int(const char* id, int value)" on "addons/interface/InstanceHandler.h". + + KODI::ADDONS::INTERFACE::IInstanceHandler* cb = + static_cast(hdl); + return cb->set_instance_setting_int(id, value); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_instance_set_setting_float_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, double value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::INTERFACE::IInstanceHandler" with "bool set_instance_setting_float(const char* id, double value)" on "addons/interface/InstanceHandler.h". + + KODI::ADDONS::INTERFACE::IInstanceHandler* cb = + static_cast(hdl); + return cb->set_instance_setting_float(id, value); + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_addon_base_h::kodi_addon_instance_set_setting_string_v1( + void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + const char* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + // AUTOGENERATED - Used by class "KODI::ADDONS::INTERFACE::IInstanceHandler" with "bool set_instance_setting_string(const char* id, const char* value)" on "addons/interface/InstanceHandler.h". + + KODI::ADDONS::INTERFACE::IInstanceHandler* cb = + static_cast(hdl); + return cb->set_instance_setting_string(id, value); + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/addon_base.h b/xbmc/addons/interface/api/addon_base.h new file mode 100644 index 0000000000000..b08010af72131 --- /dev/null +++ b/xbmc/addons/interface/api/addon_base.h @@ -0,0 +1,235 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/addon_base.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addon_base_h; +struct directFuncToKodi_addon_base_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_addon_base_h : public IMsgHdl +{ +public: + CHdl_kodi_addon_base_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_addon_base_h* ifcToKodi, + directFuncToAddon_addon_base_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + static bool UpdateSettingInActiveDialog(const std::string& addonId, + const std::string& id, + const std::string& value); + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + + enum ADDON_STATUS kodi_addon_create_v1(const struct KODI_ADDON_INSTANCE_INFO* first_instance, + KODI_ADDON_HDL* hdl); // Added with API 1 + + void kodi_addon_destroy_v1(KODI_ADDON_HDL hdl); // Added with API 1 + + enum ADDON_STATUS kodi_addon_setting_change_string_v1(const KODI_ADDON_HDL hdl, + const char* name, + const char* value); // Added with API 1 + + enum ADDON_STATUS kodi_addon_setting_change_boolean_v1(const KODI_ADDON_HDL hdl, + const char* name, + bool value); // Added with API 1 + + enum ADDON_STATUS kodi_addon_setting_change_integer_v1(const KODI_ADDON_HDL hdl, + const char* name, + int value); // Added with API 1 + + enum ADDON_STATUS kodi_addon_setting_change_float_v1(const KODI_ADDON_HDL hdl, + const char* name, + double value); // Added with API 1 + + /*---AUTO_GEN_PARSE---*/ + enum ADDON_STATUS kodi_addon_create_instance_v1(const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + KODI_HANDLE* instance); // Added with API 1 + /*---AUTO_GEN_PARSE---*/ + + /*---AUTO_GEN_PARSE---*/ + void kodi_addon_destroy_instance_v1(const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + const KODI_HANDLE instance); // Added with API 1 + /*---AUTO_GEN_PARSE---*/ + + enum ADDON_STATUS kodi_addon_instance_setting_change_string_v1( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + const char* value); // Added with API 1 + + enum ADDON_STATUS kodi_addon_instance_setting_change_boolean_v1( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + bool value); // Added with API 1 + + enum ADDON_STATUS kodi_addon_instance_setting_change_integer_v1( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + int value); // Added with API 1 + + enum ADDON_STATUS kodi_addon_instance_setting_change_float_v1( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + double value); // Added with API 1 + + KODI_ADDON_INSTANCE_HDL kodi_addon_instance_create_v1( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); // Added with API 1 + + void kodi_addon_instance_destroy_v1(KODI_ADDON_INSTANCE_HDL hdl); // Added with API 1 + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_log_v1(void* thisClassHdl, + enum ADDON_LOG loglevel, + const char* format, + ...); // Added with API 1 + + static char* kodi_addon_get_addon_path_v1(void* thisClassHdl); // Added with API 1 + + static char* kodi_addon_get_lib_path_v1(void* thisClassHdl); // Added with API 1 + + static char* kodi_addon_get_user_path_v1(void* thisClassHdl); // Added with API 1 + + static char* kodi_addon_get_temp_path_v1(void* thisClassHdl); // Added with API 1 + + static char* kodi_addon_localized_string_v1(void* thisClassHdl, + long label_id); // Added with API 1 + + static char* kodi_addon_get_info_v1(void* thisClassHdl, const char* id); // Added with API 1 + + static bool kodi_addon_open_settings_dialog_v1(void* thisClassHdl); // Added with API 1 + + static bool kodi_addon_is_setting_using_default_v1(void* thisClassHdl, + const char* id); // Added with API 1 + + static bool kodi_addon_get_setting_bool_v1(void* thisClassHdl, + const char* id, + bool* value); // Added with API 1 + + static bool kodi_addon_get_setting_int_v1(void* thisClassHdl, + const char* id, + int* value); // Added with API 1 + + static bool kodi_addon_get_setting_float_v1(void* thisClassHdl, + const char* id, + double* value); // Added with API 1 + + static bool kodi_addon_get_setting_string_v1(void* thisClassHdl, + const char* id, + char** value); // Added with API 1 + + static bool kodi_addon_set_setting_bool_v1(void* thisClassHdl, + const char* id, + bool value); // Added with API 1 + + static bool kodi_addon_set_setting_int_v1(void* thisClassHdl, + const char* id, + int value); // Added with API 1 + + static bool kodi_addon_set_setting_float_v1(void* thisClassHdl, + const char* id, + double value); // Added with API 1 + + static bool kodi_addon_set_setting_string_v1(void* thisClassHdl, + const char* id, + const char* value); // Added with API 1 + + static char* kodi_addon_instance_get_user_path_v1( + void* thisClassHdl, const KODI_ADDON_INSTANCE_BACKEND_HDL hdl); // Added with API 1 + + static bool kodi_addon_instance_is_setting_using_default_v1( + void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id); // Added with API 1 + + static bool kodi_addon_instance_get_setting_bool_v1(void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + bool* value); // Added with API 1 + + static bool kodi_addon_instance_get_setting_int_v1(void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + int* value); // Added with API 1 + + static bool kodi_addon_instance_get_setting_float_v1(void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + double* value); // Added with API 1 + + static bool kodi_addon_instance_get_setting_string_v1(void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + char** value); // Added with API 1 + + static bool kodi_addon_instance_set_setting_bool_v1(void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + bool value); // Added with API 1 + + static bool kodi_addon_instance_set_setting_int_v1(void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + int value); // Added with API 1 + + static bool kodi_addon_instance_set_setting_float_v1(void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + double value); // Added with API 1 + + static bool kodi_addon_instance_set_setting_string_v1(void* thisClassHdl, + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + const char* value); // Added with API 1 + + directFuncToAddon_addon_base_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/audio_engine.cpp b/xbmc/addons/interface/api/audio_engine.cpp new file mode 100644 index 0000000000000..fde6c49a97930 --- /dev/null +++ b/xbmc/addons/interface/api/audio_engine.cpp @@ -0,0 +1,1186 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "audio_engine.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/audio_engine.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +#include "ServiceBroker.h" +#include "cores/AudioEngine/Interfaces/AE.h" +#include "cores/AudioEngine/Interfaces/AEStream.h" +#include "cores/AudioEngine/Utils/AEStreamData.h" +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +AEChannel TranslateAEChannelToKodi(AudioEngineChannel channel) +{ + switch (channel) + { + case AUDIOENGINE_CH_RAW: + return AE_CH_RAW; + case AUDIOENGINE_CH_FL: + return AE_CH_FL; + case AUDIOENGINE_CH_FR: + return AE_CH_FR; + case AUDIOENGINE_CH_FC: + return AE_CH_FC; + case AUDIOENGINE_CH_LFE: + return AE_CH_LFE; + case AUDIOENGINE_CH_BL: + return AE_CH_BL; + case AUDIOENGINE_CH_BR: + return AE_CH_BR; + case AUDIOENGINE_CH_FLOC: + return AE_CH_FLOC; + case AUDIOENGINE_CH_FROC: + return AE_CH_FROC; + case AUDIOENGINE_CH_BC: + return AE_CH_BC; + case AUDIOENGINE_CH_SL: + return AE_CH_SL; + case AUDIOENGINE_CH_SR: + return AE_CH_SR; + case AUDIOENGINE_CH_TFL: + return AE_CH_TFL; + case AUDIOENGINE_CH_TFR: + return AE_CH_TFR; + case AUDIOENGINE_CH_TFC: + return AE_CH_TFC; + case AUDIOENGINE_CH_TC: + return AE_CH_TC; + case AUDIOENGINE_CH_TBL: + return AE_CH_TBL; + case AUDIOENGINE_CH_TBR: + return AE_CH_TBR; + case AUDIOENGINE_CH_TBC: + return AE_CH_TBC; + case AUDIOENGINE_CH_BLOC: + return AE_CH_BLOC; + case AUDIOENGINE_CH_BROC: + return AE_CH_BROC; + case AUDIOENGINE_CH_MAX: + return AE_CH_MAX; + case AUDIOENGINE_CH_NULL: + default: + return AE_CH_NULL; + } +} + +AudioEngineChannel TranslateAEChannelToAddon(AEChannel channel) +{ + switch (channel) + { + case AE_CH_RAW: + return AUDIOENGINE_CH_RAW; + case AE_CH_FL: + return AUDIOENGINE_CH_FL; + case AE_CH_FR: + return AUDIOENGINE_CH_FR; + case AE_CH_FC: + return AUDIOENGINE_CH_FC; + case AE_CH_LFE: + return AUDIOENGINE_CH_LFE; + case AE_CH_BL: + return AUDIOENGINE_CH_BL; + case AE_CH_BR: + return AUDIOENGINE_CH_BR; + case AE_CH_FLOC: + return AUDIOENGINE_CH_FLOC; + case AE_CH_FROC: + return AUDIOENGINE_CH_FROC; + case AE_CH_BC: + return AUDIOENGINE_CH_BC; + case AE_CH_SL: + return AUDIOENGINE_CH_SL; + case AE_CH_SR: + return AUDIOENGINE_CH_SR; + case AE_CH_TFL: + return AUDIOENGINE_CH_TFL; + case AE_CH_TFR: + return AUDIOENGINE_CH_TFR; + case AE_CH_TFC: + return AUDIOENGINE_CH_TFC; + case AE_CH_TC: + return AUDIOENGINE_CH_TC; + case AE_CH_TBL: + return AUDIOENGINE_CH_TBL; + case AE_CH_TBR: + return AUDIOENGINE_CH_TBR; + case AE_CH_TBC: + return AUDIOENGINE_CH_TBC; + case AE_CH_BLOC: + return AUDIOENGINE_CH_BLOC; + case AE_CH_BROC: + return AUDIOENGINE_CH_BROC; + case AE_CH_MAX: + return AUDIOENGINE_CH_MAX; + case AE_CH_NULL: + default: + return AUDIOENGINE_CH_NULL; + } +} + +AEDataFormat TranslateAEFormatToKodi(AudioEngineDataFormat format) +{ + switch (format) + { + case AUDIOENGINE_FMT_U8: + return AE_FMT_U8; + case AUDIOENGINE_FMT_S16BE: + return AE_FMT_S16BE; + case AUDIOENGINE_FMT_S16LE: + return AE_FMT_S16LE; + case AUDIOENGINE_FMT_S16NE: + return AE_FMT_S16NE; + case AUDIOENGINE_FMT_S32BE: + return AE_FMT_S32BE; + case AUDIOENGINE_FMT_S32LE: + return AE_FMT_S32LE; + case AUDIOENGINE_FMT_S32NE: + return AE_FMT_S32NE; + case AUDIOENGINE_FMT_S24BE4: + return AE_FMT_S24BE4; + case AUDIOENGINE_FMT_S24LE4: + return AE_FMT_S24LE4; + case AUDIOENGINE_FMT_S24NE4: + return AE_FMT_S24NE4; + case AUDIOENGINE_FMT_S24NE4MSB: + return AE_FMT_S24NE4MSB; + case AUDIOENGINE_FMT_S24BE3: + return AE_FMT_S24BE3; + case AUDIOENGINE_FMT_S24LE3: + return AE_FMT_S24LE3; + case AUDIOENGINE_FMT_S24NE3: + return AE_FMT_S24NE3; + case AUDIOENGINE_FMT_DOUBLE: + return AE_FMT_DOUBLE; + case AUDIOENGINE_FMT_FLOAT: + return AE_FMT_FLOAT; + case AUDIOENGINE_FMT_RAW: + return AE_FMT_RAW; + case AUDIOENGINE_FMT_U8P: + return AE_FMT_U8P; + case AUDIOENGINE_FMT_S16NEP: + return AE_FMT_S16NEP; + case AUDIOENGINE_FMT_S32NEP: + return AE_FMT_S32NEP; + case AUDIOENGINE_FMT_S24NE4P: + return AE_FMT_S24NE4P; + case AUDIOENGINE_FMT_S24NE4MSBP: + return AE_FMT_S24NE4MSBP; + case AUDIOENGINE_FMT_S24NE3P: + return AE_FMT_S24NE3P; + case AUDIOENGINE_FMT_DOUBLEP: + return AE_FMT_DOUBLEP; + case AUDIOENGINE_FMT_FLOATP: + return AE_FMT_FLOATP; + case AUDIOENGINE_FMT_MAX: + return AE_FMT_MAX; + case AUDIOENGINE_FMT_INVALID: + default: + return AE_FMT_INVALID; + } +} + +AudioEngineDataFormat TranslateAEFormatToAddon(AEDataFormat format) +{ + switch (format) + { + case AE_FMT_U8: + return AUDIOENGINE_FMT_U8; + case AE_FMT_S16BE: + return AUDIOENGINE_FMT_S16BE; + case AE_FMT_S16LE: + return AUDIOENGINE_FMT_S16LE; + case AE_FMT_S16NE: + return AUDIOENGINE_FMT_S16NE; + case AE_FMT_S32BE: + return AUDIOENGINE_FMT_S32BE; + case AE_FMT_S32LE: + return AUDIOENGINE_FMT_S32LE; + case AE_FMT_S32NE: + return AUDIOENGINE_FMT_S32NE; + case AE_FMT_S24BE4: + return AUDIOENGINE_FMT_S24BE4; + case AE_FMT_S24LE4: + return AUDIOENGINE_FMT_S24LE4; + case AE_FMT_S24NE4: + return AUDIOENGINE_FMT_S24NE4; + case AE_FMT_S24NE4MSB: + return AUDIOENGINE_FMT_S24NE4MSB; + case AE_FMT_S24BE3: + return AUDIOENGINE_FMT_S24BE3; + case AE_FMT_S24LE3: + return AUDIOENGINE_FMT_S24LE3; + case AE_FMT_S24NE3: + return AUDIOENGINE_FMT_S24NE3; + case AE_FMT_DOUBLE: + return AUDIOENGINE_FMT_DOUBLE; + case AE_FMT_FLOAT: + return AUDIOENGINE_FMT_FLOAT; + case AE_FMT_RAW: + return AUDIOENGINE_FMT_RAW; + case AE_FMT_U8P: + return AUDIOENGINE_FMT_U8P; + case AE_FMT_S16NEP: + return AUDIOENGINE_FMT_S16NEP; + case AE_FMT_S32NEP: + return AUDIOENGINE_FMT_S32NEP; + case AE_FMT_S24NE4P: + return AUDIOENGINE_FMT_S24NE4P; + case AE_FMT_S24NE4MSBP: + return AUDIOENGINE_FMT_S24NE4MSBP; + case AE_FMT_S24NE3P: + return AUDIOENGINE_FMT_S24NE3P; + case AE_FMT_DOUBLEP: + return AUDIOENGINE_FMT_DOUBLEP; + case AE_FMT_FLOATP: + return AUDIOENGINE_FMT_FLOATP; + case AE_FMT_MAX: + return AUDIOENGINE_FMT_MAX; + case AE_FMT_INVALID: + default: + return AUDIOENGINE_FMT_INVALID; + } +} + +class CAddonAudioStream : public IInterfaceClassHdl +{ +public: + CAddonAudioStream() : IInterfaceClassHdl(InterfaceKodiClass::IAEStream) {} + + IAEStream* m_stream; +}; + +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_audio_engine_h::InitDirect(directFuncToKodi_audio_engine_h* ifcToKodi, + directFuncToAddon_audio_engine_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_audioengine_get_current_sink_format_v1 = + kodi_audioengine_get_current_sink_format_v1; + ifcToKodi->kodi_audioengine_is_planar_format_v1 = kodi_audioengine_is_planar_format_v1; + ifcToKodi->kodi_audioengine_stream_make_v1 = kodi_audioengine_stream_make_v1; + ifcToKodi->kodi_audioengine_stream_free_v1 = kodi_audioengine_stream_free_v1; + ifcToKodi->kodi_audioengine_stream_get_space_v1 = kodi_audioengine_stream_get_space_v1; + ifcToKodi->kodi_audioengine_stream_add_data_v1 = kodi_audioengine_stream_add_data_v1; + ifcToKodi->kodi_audioengine_stream_get_delay_v1 = kodi_audioengine_stream_get_delay_v1; + ifcToKodi->kodi_audioengine_stream_is_buffering_v1 = kodi_audioengine_stream_is_buffering_v1; + ifcToKodi->kodi_audioengine_stream_get_cache_time_v1 = kodi_audioengine_stream_get_cache_time_v1; + ifcToKodi->kodi_audioengine_stream_get_cache_total_v1 = + kodi_audioengine_stream_get_cache_total_v1; + ifcToKodi->kodi_audioengine_stream_pause_v1 = kodi_audioengine_stream_pause_v1; + ifcToKodi->kodi_audioengine_stream_resume_v1 = kodi_audioengine_stream_resume_v1; + ifcToKodi->kodi_audioengine_stream_drain_v1 = kodi_audioengine_stream_drain_v1; + ifcToKodi->kodi_audioengine_stream_is_draining_v1 = kodi_audioengine_stream_is_draining_v1; + ifcToKodi->kodi_audioengine_stream_is_drained_v1 = kodi_audioengine_stream_is_drained_v1; + ifcToKodi->kodi_audioengine_stream_flush_v1 = kodi_audioengine_stream_flush_v1; + ifcToKodi->kodi_audioengine_stream_get_volume_v1 = kodi_audioengine_stream_get_volume_v1; + ifcToKodi->kodi_audioengine_stream_set_volume_v1 = kodi_audioengine_stream_set_volume_v1; + ifcToKodi->kodi_audioengine_stream_get_amplification_v1 = + kodi_audioengine_stream_get_amplification_v1; + ifcToKodi->kodi_audioengine_stream_set_amplification_v1 = + kodi_audioengine_stream_set_amplification_v1; + ifcToKodi->kodi_audioengine_stream_get_frame_size_v1 = kodi_audioengine_stream_get_frame_size_v1; + ifcToKodi->kodi_audioengine_stream_get_channel_count_v1 = + kodi_audioengine_stream_get_channel_count_v1; + ifcToKodi->kodi_audioengine_stream_get_sample_rate_v1 = + kodi_audioengine_stream_get_sample_rate_v1; + ifcToKodi->kodi_audioengine_stream_get_data_format_v1 = + kodi_audioengine_stream_get_data_format_v1; + ifcToKodi->kodi_audioengine_stream_get_resample_ratio_v1 = + kodi_audioengine_stream_get_resample_ratio_v1; + ifcToKodi->kodi_audioengine_stream_set_resample_ratio_v1 = + kodi_audioengine_stream_set_resample_ratio_v1; +} + +bool CHdl_kodi_audio_engine_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_audio_engine_h) + return false; + + switch (func) + { + case funcParent_kodi_audioengine_get_current_sink_format_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_audioengine_get_current_sink_format(struct AUDIO_ENGINE_FMT* fmt) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_get_current_sink_format_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_get_current_sink_format_v1; /* Autogenerated */ + struct AUDIO_ENGINE_FMT fmt = {}; + bool auto_gen_ret = kodi_audioengine_get_current_sink_format_v1(this, &fmt); + msgpack::pack(out, + msgParent_OUT_kodi_audioengine_get_current_sink_format_v1(auto_gen_ret, &fmt)); + return true; + } + case funcParent_kodi_audioengine_is_planar_format_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_audioengine_is_planar_format(enum AudioEngineDataFormat format) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_is_planar_format_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_is_planar_format_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_is_planar_format_v1 t = in.get().as(); + enum AudioEngineDataFormat format = std::get<0>(t); + bool auto_gen_ret = kodi_audioengine_is_planar_format_v1(this, format); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_is_planar_format_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_make_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_AE_HDL kodi_audioengine_stream_make(const struct AUDIO_ENGINE_FMT* fmt, unsigned int options) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_make_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_make_v1; /* Autogenerated */ + AUDIO_ENGINE_FMT fmt; + msgParent__IN_kodi_audioengine_stream_make_v1 t = in.get().as(); + std::get<0>(t).SetCStructure(&fmt); + unsigned int options = std::get<1>(t); + KODI_AE_HDL auto_gen_ret = kodi_audioengine_stream_make_v1(this, &fmt, options); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_make_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_audioengine_stream_free_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_free(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_free_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_free_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_free_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + kodi_audioengine_stream_free_v1(this, hdl); + return true; + } + case funcParent_kodi_audioengine_stream_get_space_v1: + { + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_space(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_space_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_space_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_space_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + unsigned int auto_gen_ret = kodi_audioengine_stream_get_space_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_space_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_add_data_v1: + { + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_add_data(KODI_AE_HDL hdl, uint8_t* const* data, size_t planes, size_t data_size, unsigned int offset, unsigned int frames, unsigned int frame_size, double pts, bool hasDownmix, double centerMixLevel) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple>, size_t, size_t, unsigned int, unsigned int, unsigned int, double, bool, double> msgParent__IN_kodi_audioengine_stream_add_data_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_add_data_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_add_data_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + std::vector>& ifc_data = std::get<1>(t); + size_t planes = std::get<2>(t); + size_t data_size = std::get<3>(t); + unsigned int offset = std::get<4>(t); + unsigned int frames = std::get<5>(t); + unsigned int frame_size = std::get<6>(t); + double pts = std::get<7>(t); + bool hasDownmix = std::get<8>(t); + double centerMixLevel = std::get<9>(t); + uint8_t** data = new uint8_t*[ifc_data.size()]; + for (size_t i = 0; i < ifc_data.size(); ++i) + data[i] = ifc_data[i].data(); + unsigned int auto_gen_ret = + kodi_audioengine_stream_add_data_v1(this, hdl, data, planes, data_size, offset, frames, + frame_size, pts, hasDownmix, centerMixLevel); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_add_data_v1(auto_gen_ret)); + delete[] data; + return true; + } + case funcParent_kodi_audioengine_stream_get_delay_v1: + { + // Original API call: ATTR_DLL_EXPORT double kodi_audioengine_stream_get_delay(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_delay_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_delay_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_delay_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + double auto_gen_ret = kodi_audioengine_stream_get_delay_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_delay_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_is_buffering_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_buffering(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_is_buffering_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_is_buffering_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_is_buffering_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_audioengine_stream_is_buffering_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_is_buffering_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_get_cache_time_v1: + { + // Original API call: ATTR_DLL_EXPORT double kodi_audioengine_stream_get_cache_time(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_cache_time_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_cache_time_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_cache_time_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + double auto_gen_ret = kodi_audioengine_stream_get_cache_time_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_cache_time_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_get_cache_total_v1: + { + // Original API call: ATTR_DLL_EXPORT double kodi_audioengine_stream_get_cache_total(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_cache_total_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_cache_total_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_cache_total_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + double auto_gen_ret = kodi_audioengine_stream_get_cache_total_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_cache_total_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_pause_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_pause(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_pause_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_pause_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_pause_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + kodi_audioengine_stream_pause_v1(this, hdl); + return true; + } + case funcParent_kodi_audioengine_stream_resume_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_resume(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_resume_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_resume_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_resume_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + kodi_audioengine_stream_resume_v1(this, hdl); + return true; + } + case funcParent_kodi_audioengine_stream_drain_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_drain(KODI_AE_HDL hdl, bool wait) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_drain_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_drain_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_drain_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + bool wait = std::get<1>(t); + kodi_audioengine_stream_drain_v1(this, hdl, wait); + return true; + } + case funcParent_kodi_audioengine_stream_is_draining_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_draining(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_is_draining_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_is_draining_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_is_draining_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_audioengine_stream_is_draining_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_is_draining_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_is_drained_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_drained(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_is_drained_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_is_drained_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_is_drained_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_audioengine_stream_is_drained_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_is_drained_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_flush_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_flush(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_flush_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_flush_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_flush_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + kodi_audioengine_stream_flush_v1(this, hdl); + return true; + } + case funcParent_kodi_audioengine_stream_get_volume_v1: + { + // Original API call: ATTR_DLL_EXPORT float kodi_audioengine_stream_get_volume(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_volume_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_volume_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_volume_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + float auto_gen_ret = kodi_audioengine_stream_get_volume_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_volume_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_set_volume_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_set_volume(KODI_AE_HDL hdl, float volume) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_set_volume_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_set_volume_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_set_volume_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + float volume = std::get<1>(t); + kodi_audioengine_stream_set_volume_v1(this, hdl, volume); + return true; + } + case funcParent_kodi_audioengine_stream_get_amplification_v1: + { + // Original API call: ATTR_DLL_EXPORT float kodi_audioengine_stream_get_amplification(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_amplification_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_amplification_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_amplification_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + float auto_gen_ret = kodi_audioengine_stream_get_amplification_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_amplification_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_set_amplification_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_set_amplification(KODI_AE_HDL hdl, float amplify) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_set_amplification_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_set_amplification_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_set_amplification_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + float amplify = std::get<1>(t); + kodi_audioengine_stream_set_amplification_v1(this, hdl, amplify); + return true; + } + case funcParent_kodi_audioengine_stream_get_frame_size_v1: + { + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_frame_size(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_frame_size_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_frame_size_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_frame_size_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + unsigned int auto_gen_ret = kodi_audioengine_stream_get_frame_size_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_frame_size_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_get_channel_count_v1: + { + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_channel_count(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_channel_count_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_channel_count_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_channel_count_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + unsigned int auto_gen_ret = kodi_audioengine_stream_get_channel_count_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_channel_count_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_get_sample_rate_v1: + { + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_sample_rate(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_sample_rate_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_sample_rate_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_sample_rate_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + unsigned int auto_gen_ret = kodi_audioengine_stream_get_sample_rate_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_sample_rate_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_get_data_format_v1: + { + // Original API call: ATTR_DLL_EXPORT enum AudioEngineDataFormat kodi_audioengine_stream_get_data_format( KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_data_format_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_data_format_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_data_format_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + enum AudioEngineDataFormat auto_gen_ret = + kodi_audioengine_stream_get_data_format_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_data_format_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_get_resample_ratio_v1: + { + // Original API call: ATTR_DLL_EXPORT double kodi_audioengine_stream_get_resample_ratio(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_resample_ratio_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_resample_ratio_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_get_resample_ratio_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + double auto_gen_ret = kodi_audioengine_stream_get_resample_ratio_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_audioengine_stream_get_resample_ratio_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_audioengine_stream_set_resample_ratio_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_set_resample_ratio(KODI_AE_HDL hdl, double ratio) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_set_resample_ratio_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_set_resample_ratio_v1; /* Autogenerated */ + msgParent__IN_kodi_audioengine_stream_set_resample_ratio_v1 t = in.get().as(); + KODI_AE_HDL hdl = reinterpret_cast(std::get<0>(t)); + double ratio = std::get<1>(t); + kodi_audioengine_stream_set_resample_ratio_v1(this, hdl, ratio); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_audio_engine_h::{}: addon called with unknown function id '{}' on group " + "'audio_engine_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +bool CHdl_kodi_audio_engine_h::kodi_audioengine_get_current_sink_format_v1( + void* thisClassHdl, struct AUDIO_ENGINE_FMT* fmt) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + IAE* engine = CServiceBroker::GetActiveAE(); + if (!engine) + return false; + + AEAudioFormat sinkFormat; + if (!engine->GetCurrentSinkFormat(sinkFormat)) + { + CLog::Log(LOGERROR, "CHdl_kodi_audio_engine_h::{} - failed to get current sink format from AE!", + __func__); + return false; + } + + fmt->data_format = TranslateAEFormatToAddon(sinkFormat.m_dataFormat); + fmt->sample_rate = sinkFormat.m_sampleRate; + fmt->frames = sinkFormat.m_frames; + fmt->frame_size = sinkFormat.m_frameSize; + fmt->channel_count = sinkFormat.m_channelLayout.Count(); + for (unsigned int ch = 0; ch < fmt->channel_count && ch < AUDIOENGINE_CH_MAX; ++ch) + { + fmt->channels[ch] = TranslateAEChannelToAddon(sinkFormat.m_channelLayout[ch]); + } + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_audio_engine_h::kodi_audioengine_is_planar_format_v1( + void* thisClassHdl, enum AudioEngineDataFormat format) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + if (format >= AUDIOENGINE_FMT_U8P || format <= AUDIOENGINE_FMT_FLOATP) + return true; + return false; + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_AE_HDL CHdl_kodi_audio_engine_h::kodi_audioengine_stream_make_v1( + void* thisClassHdl, const struct AUDIO_ENGINE_FMT* fmt, unsigned int options) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + IAE* engine = CServiceBroker::GetActiveAE(); + if (!engine) + return nullptr; + + CAEChannelInfo layout; + for (unsigned int ch = 0; ch < AUDIOENGINE_CH_MAX; ++ch) + { + if (fmt->channels[ch] == AUDIOENGINE_CH_NULL) + break; + layout += TranslateAEChannelToKodi(fmt->channels[ch]); + } + + AEAudioFormat format; + format.m_channelLayout = layout; + format.m_dataFormat = TranslateAEFormatToKodi(fmt->data_format); + format.m_sampleRate = fmt->sample_rate; + + /* Translate addon options to kodi's options */ + int kodiOption = 0; + if (options & AUDIO_STREAM_FORCE_RESAMPLE) + kodiOption |= AESTREAM_FORCE_RESAMPLE; + if (options & AUDIO_STREAM_PAUSED) + kodiOption |= AESTREAM_PAUSED; + if (options & AUDIO_STREAM_AUTOSTART) + kodiOption |= AESTREAM_AUTOSTART; + + CAddonAudioStream* stream = new CAddonAudioStream(); + stream->m_stream = engine->MakeStream(format, kodiOption).release(); + if (!stream->m_stream) + { + delete stream; + return nullptr; + } + + thisClass->m_process->RegisterClass(stream); + return KODI_AE_HDL(stream); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_audio_engine_h::kodi_audioengine_stream_free_v1(void* thisClassHdl, KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream) + return; + + thisClass->m_process->UnregisterClass(stream); + IAE* engine = CServiceBroker::GetActiveAE(); + if (engine) + engine->FreeStream(stream->m_stream, true); + delete stream; + + /*---AUTO_GEN_PARSE---*/ +} + +unsigned int CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_space_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return 0; + + return stream->m_stream->GetSpace(); + + /*---AUTO_GEN_PARSE---*/ +} + +unsigned int CHdl_kodi_audio_engine_h::kodi_audioengine_stream_add_data_v1(void* thisClassHdl, + KODI_AE_HDL hdl, + uint8_t* const* data, + size_t planes, + size_t data_size, + unsigned int offset, + unsigned int frames, + unsigned int frame_size, + double pts, + bool hasDownmix, + double centerMixLevel) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream || !CServiceBroker::GetActiveAE()) + return 0; + + IAEStream::ExtData extData; + extData.pts = pts; + extData.hasDownmix = hasDownmix; + extData.centerMixLevel = centerMixLevel; + + return stream->m_stream->AddData(data, offset, frames, &extData); + + /*---AUTO_GEN_PARSE---*/ +} + +double CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_delay_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return 0.0; + + return stream->m_stream->GetDelay(); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_audio_engine_h::kodi_audioengine_stream_is_buffering_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return false; + + return stream->m_stream->IsBuffering(); + + /*---AUTO_GEN_PARSE---*/ +} + +double CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_cache_time_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return 0.0; + + return stream->m_stream->GetCacheTime(); + + /*---AUTO_GEN_PARSE---*/ +} + +double CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_cache_total_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return 0.0; + + return stream->m_stream->GetCacheTotal(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_audio_engine_h::kodi_audioengine_stream_pause_v1(void* thisClassHdl, KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return; + + stream->m_stream->Pause(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_audio_engine_h::kodi_audioengine_stream_resume_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return; + + stream->m_stream->Resume(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_audio_engine_h::kodi_audioengine_stream_drain_v1(void* thisClassHdl, + KODI_AE_HDL hdl, + bool wait) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return; + + stream->m_stream->Drain(wait); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_audio_engine_h::kodi_audioengine_stream_is_draining_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return false; + + return stream->m_stream->IsDraining(); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_audio_engine_h::kodi_audioengine_stream_is_drained_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return false; + + return stream->m_stream->IsDrained(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_audio_engine_h::kodi_audioengine_stream_flush_v1(void* thisClassHdl, KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return; + + stream->m_stream->Flush(); + + /*---AUTO_GEN_PARSE---*/ +} + +float CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_volume_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0f; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return 0.0f; + + return stream->m_stream->GetVolume(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_audio_engine_h::kodi_audioengine_stream_set_volume_v1(void* thisClassHdl, + KODI_AE_HDL hdl, + float volume) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return; + + stream->m_stream->SetVolume(volume); + + /*---AUTO_GEN_PARSE---*/ +} + +float CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_amplification_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0f; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return 0.0f; + + return stream->m_stream->GetAmplification(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_audio_engine_h::kodi_audioengine_stream_set_amplification_v1(void* thisClassHdl, + KODI_AE_HDL hdl, + float amplify) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return; + + stream->m_stream->SetAmplification(amplify); + + /*---AUTO_GEN_PARSE---*/ +} + +unsigned int CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_frame_size_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return 0; + + return stream->m_stream->GetFrameSize(); + + /*---AUTO_GEN_PARSE---*/ +} + +unsigned int CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_channel_count_v1( + void* thisClassHdl, KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return 0; + + return stream->m_stream->GetChannelCount(); + + /*---AUTO_GEN_PARSE---*/ +} + +unsigned int CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_sample_rate_v1( + void* thisClassHdl, KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return 0; + + return stream->m_stream->GetSampleRate(); + + /*---AUTO_GEN_PARSE---*/ +} + +enum AudioEngineDataFormat CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_data_format_v1( + void* thisClassHdl, KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return AUDIOENGINE_FMT_INVALID; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return AudioEngineDataFormat::AUDIOENGINE_FMT_INVALID; + + return TranslateAEFormatToAddon(stream->m_stream->GetDataFormat()); + + /*---AUTO_GEN_PARSE---*/ +} + +double CHdl_kodi_audio_engine_h::kodi_audioengine_stream_get_resample_ratio_v1(void* thisClassHdl, + KODI_AE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return 0.0; + + return stream->m_stream->GetResampleRatio(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_audio_engine_h::kodi_audioengine_stream_set_resample_ratio_v1(void* thisClassHdl, + KODI_AE_HDL hdl, + double ratio) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CAddonAudioStream* stream = static_cast(hdl); + if (!stream || !stream->m_stream) + return; + + stream->m_stream->SetResampleRatio(ratio); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/audio_engine.h b/xbmc/addons/interface/api/audio_engine.h new file mode 100644 index 0000000000000..5e2021c064cfb --- /dev/null +++ b/xbmc/addons/interface/api/audio_engine.h @@ -0,0 +1,165 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/audio_engine.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +#include "cores/AudioEngine/Utils/AEChannelData.h" +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_audio_engine_h; +struct directFuncToKodi_audio_engine_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +AEChannel TranslateAEChannelToKodi(AudioEngineChannel channel); +AudioEngineChannel TranslateAEChannelToAddon(AEChannel channel); +AEDataFormat TranslateAEFormatToKodi(AudioEngineDataFormat format); +AudioEngineDataFormat TranslateAEFormatToAddon(AEDataFormat format); +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_audio_engine_h : public IMsgHdl +{ +public: + CHdl_kodi_audio_engine_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_audio_engine_h* ifcToKodi, + directFuncToAddon_audio_engine_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static bool kodi_audioengine_get_current_sink_format_v1( + void* thisClassHdl, struct AUDIO_ENGINE_FMT* fmt); // Added with API 1 + + static bool kodi_audioengine_is_planar_format_v1( + void* thisClassHdl, enum AudioEngineDataFormat format); // Added with API 1 + + static KODI_AE_HDL kodi_audioengine_stream_make_v1(void* thisClassHdl, + const struct AUDIO_ENGINE_FMT* fmt, + unsigned int options); // Added with API 1 + + static void kodi_audioengine_stream_free_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static unsigned int kodi_audioengine_stream_get_space_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static unsigned int kodi_audioengine_stream_add_data_v1( + void* thisClassHdl, + KODI_AE_HDL hdl, + uint8_t* const* data, + size_t planes, + size_t data_size, + unsigned int offset, + unsigned int frames, + unsigned int frame_size, + double pts, + bool hasDownmix, + double centerMixLevel); // Added with API 1 + + static double kodi_audioengine_stream_get_delay_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static bool kodi_audioengine_stream_is_buffering_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static double kodi_audioengine_stream_get_cache_time_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static double kodi_audioengine_stream_get_cache_total_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static void kodi_audioengine_stream_pause_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static void kodi_audioengine_stream_resume_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static void kodi_audioengine_stream_drain_v1(void* thisClassHdl, + KODI_AE_HDL hdl, + bool wait); // Added with API 1 + + static bool kodi_audioengine_stream_is_draining_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static bool kodi_audioengine_stream_is_drained_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static void kodi_audioengine_stream_flush_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static float kodi_audioengine_stream_get_volume_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static void kodi_audioengine_stream_set_volume_v1(void* thisClassHdl, + KODI_AE_HDL hdl, + float volume); // Added with API 1 + + static float kodi_audioengine_stream_get_amplification_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static void kodi_audioengine_stream_set_amplification_v1(void* thisClassHdl, + KODI_AE_HDL hdl, + float amplify); // Added with API 1 + + static unsigned int kodi_audioengine_stream_get_frame_size_v1( + void* thisClassHdl, KODI_AE_HDL hdl); // Added with API 1 + + static unsigned int kodi_audioengine_stream_get_channel_count_v1( + void* thisClassHdl, KODI_AE_HDL hdl); // Added with API 1 + + static unsigned int kodi_audioengine_stream_get_sample_rate_v1( + void* thisClassHdl, KODI_AE_HDL hdl); // Added with API 1 + + static enum AudioEngineDataFormat kodi_audioengine_stream_get_data_format_v1( + void* thisClassHdl, KODI_AE_HDL hdl); // Added with API 1 + + static double kodi_audioengine_stream_get_resample_ratio_v1(void* thisClassHdl, + KODI_AE_HDL hdl); // Added with API 1 + + static void kodi_audioengine_stream_set_resample_ratio_v1(void* thisClassHdl, + KODI_AE_HDL hdl, + double ratio); // Added with API 1 + + directFuncToAddon_audio_engine_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/filesystem.cpp b/xbmc/addons/interface/api/filesystem.cpp new file mode 100644 index 0000000000000..74fdebdb2ec54 --- /dev/null +++ b/xbmc/addons/interface/api/filesystem.cpp @@ -0,0 +1,1998 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "filesystem.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/filesystem.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "FileItem.h" +#include "Util.h" +#include "addons/interface/RunningProcess.h" +#include "filesystem/CurlFile.h" +#include "filesystem/Directory.h" +#include "filesystem/File.h" +#include "filesystem/SpecialProtocol.h" +#include "platform/Filesystem.h" +#include "utils/Crc32.h" +#include "utils/HttpHeader.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" + +#if defined(TARGET_WINDOWS) +#ifndef S_IFLNK +#define S_IFLNK 0120000 +#endif +#ifndef S_ISBLK +#define S_ISBLK(m) (0) +#endif +#ifndef S_ISSOCK +#define S_ISSOCK(m) (0) +#endif +#ifndef S_ISLNK +#define S_ISLNK(m) ((m & S_IFLNK) != 0) +#endif +#ifndef S_ISCHR +#define S_ISCHR(m) ((m & _S_IFCHR) != 0) +#endif +#ifndef S_ISDIR +#define S_ISDIR(m) ((m & _S_IFDIR) != 0) +#endif +#ifndef S_ISFIFO +#define S_ISFIFO(m) ((m & _S_IFIFO) != 0) +#endif +#ifndef S_ISREG +#define S_ISREG(m) ((m & _S_IFREG) != 0) +#endif +#endif + +using namespace XFILE; + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +namespace +{ + +unsigned int TranslateFileReadBitsToKodi(unsigned int addonFlags) +{ + unsigned int kodiFlags = 0; + + if (addonFlags & ADDON_READ_TRUNCATED) + kodiFlags |= READ_TRUNCATED; + if (addonFlags & ADDON_READ_CHUNKED) + kodiFlags |= READ_CHUNKED; + if (addonFlags & ADDON_READ_CACHED) + kodiFlags |= READ_CACHED; + if (addonFlags & ADDON_READ_NO_CACHE) + kodiFlags |= READ_NO_CACHE; + if (addonFlags & ADDON_READ_BITRATE) + kodiFlags |= READ_BITRATE; + if (addonFlags & ADDON_READ_MULTI_STREAM) + kodiFlags |= READ_MULTI_STREAM; + if (addonFlags & ADDON_READ_AUDIO_VIDEO) + kodiFlags |= READ_AUDIO_VIDEO; + if (addonFlags & ADDON_READ_AFTER_WRITE) + kodiFlags |= READ_AFTER_WRITE; + if (addonFlags & READ_REOPEN) + kodiFlags |= READ_REOPEN; + + return kodiFlags; +} + +XFILE::FileProperty TranslateFilePropertyToKodi(FilePropertyTypes type) +{ + XFILE::FileProperty internalType; + switch (type) + { + case ADDON_FILE_PROPERTY_RESPONSE_PROTOCOL: + internalType = XFILE::FILE_PROPERTY_RESPONSE_PROTOCOL; + break; + case ADDON_FILE_PROPERTY_RESPONSE_HEADER: + internalType = XFILE::FILE_PROPERTY_RESPONSE_HEADER; + break; + case ADDON_FILE_PROPERTY_CONTENT_TYPE: + internalType = XFILE::FILE_PROPERTY_CONTENT_TYPE; + break; + case ADDON_FILE_PROPERTY_CONTENT_CHARSET: + internalType = XFILE::FILE_PROPERTY_CONTENT_CHARSET; + break; + case ADDON_FILE_PROPERTY_MIME_TYPE: + internalType = XFILE::FILE_PROPERTY_MIME_TYPE; + break; + case ADDON_FILE_PROPERTY_EFFECTIVE_URL: + internalType = XFILE::FILE_PROPERTY_EFFECTIVE_URL; + break; + default: + CLog::Log(LOGERROR, "{} - invalid type", __func__); + internalType = XFILE::FILE_PROPERTY_RESPONSE_PROTOCOL; + break; + }; + + return internalType; +} + +static void CFileItemListToVFSDirEntries(VFS_DIR_ENTRY* entries, const CFileItemList& items) +{ + for (unsigned int i = 0; i < static_cast(items.Size()); ++i) + { + entries[i].label = strdup(items[i]->GetLabel().c_str()); + entries[i].path = strdup(items[i]->GetPath().c_str()); + entries[i].size = items[i]->m_dwSize; + entries[i].folder = items[i]->m_bIsFolder; + items[i]->m_dateTime.GetAsTime(entries[i].date_time); + } +} + +/* + * CHttpHeader to use on addons, used with IInterfaceClassHdl to know opened parts + * in case of addon crash or wrong exits. + */ +class CAddonHttpHeader : public IInterfaceClassHdl, public CHttpHeader +{ +public: + CAddonHttpHeader() : IInterfaceClassHdl(InterfaceKodiClass::CHttpHeader) {} +}; + +/* + * CFile to use on addons, used with IInterfaceClassHdl to know opened parts + * in case of addon crash or wrong exits. + */ +class CAddonFile : public IInterfaceClassHdl, public CFile +{ +public: + CAddonFile() : IInterfaceClassHdl(InterfaceKodiClass::CFile) {} +}; + +} /* namespace */ + +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_filesystem_h::InitDirect(directFuncToKodi_filesystem_h* ifcToKodi, + directFuncToAddon_filesystem_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_vfs_can_open_directory_v1 = kodi_vfs_can_open_directory_v1; + ifcToKodi->kodi_vfs_create_directory_v1 = kodi_vfs_create_directory_v1; + ifcToKodi->kodi_vfs_remove_directory_v1 = kodi_vfs_remove_directory_v1; + ifcToKodi->kodi_vfs_remove_directory_recursive_v1 = kodi_vfs_remove_directory_recursive_v1; + ifcToKodi->kodi_vfs_directory_exists_v1 = kodi_vfs_directory_exists_v1; + ifcToKodi->kodi_vfs_get_directory_v1 = kodi_vfs_get_directory_v1; + // Unused "kodi_vfs_free_directory", done only in addon lib + ifcToKodi->kodi_vfs_file_exists_v1 = kodi_vfs_file_exists_v1; + ifcToKodi->kodi_vfs_stat_file_v1 = kodi_vfs_stat_file_v1; + ifcToKodi->kodi_vfs_delete_file_v1 = kodi_vfs_delete_file_v1; + ifcToKodi->kodi_vfs_rename_file_v1 = kodi_vfs_rename_file_v1; + ifcToKodi->kodi_vfs_copy_file_v1 = kodi_vfs_copy_file_v1; + ifcToKodi->kodi_vfs_get_file_md5_v1 = kodi_vfs_get_file_md5_v1; + ifcToKodi->kodi_vfs_get_cache_thumb_name_v1 = kodi_vfs_get_cache_thumb_name_v1; + ifcToKodi->kodi_vfs_make_legal_filename_v1 = kodi_vfs_make_legal_filename_v1; + ifcToKodi->kodi_vfs_make_legal_path_v1 = kodi_vfs_make_legal_path_v1; + ifcToKodi->kodi_vfs_translate_special_protocol_v1 = kodi_vfs_translate_special_protocol_v1; + ifcToKodi->kodi_vfs_is_internet_stream_v1 = kodi_vfs_is_internet_stream_v1; + ifcToKodi->kodi_vfs_is_on_lan_v1 = kodi_vfs_is_on_lan_v1; + ifcToKodi->kodi_vfs_is_remote_v1 = kodi_vfs_is_remote_v1; + ifcToKodi->kodi_vfs_is_local_v1 = kodi_vfs_is_local_v1; + ifcToKodi->kodi_vfs_is_url_v1 = kodi_vfs_is_url_v1; + ifcToKodi->kodi_vfs_get_mime_type_v1 = kodi_vfs_get_mime_type_v1; + ifcToKodi->kodi_vfs_get_content_type_v1 = kodi_vfs_get_content_type_v1; + ifcToKodi->kodi_vfs_get_cookies_v1 = kodi_vfs_get_cookies_v1; + ifcToKodi->kodi_vfs_get_disk_space_v1 = kodi_vfs_get_disk_space_v1; + ifcToKodi->kodi_vfs_http_header_open_v1 = kodi_vfs_http_header_open_v1; + ifcToKodi->kodi_vfs_http_header_close_v1 = kodi_vfs_http_header_close_v1; + ifcToKodi->kodi_vfs_http_header_get_value_v1 = kodi_vfs_http_header_get_value_v1; + ifcToKodi->kodi_vfs_http_header_get_values_v1 = kodi_vfs_http_header_get_values_v1; + ifcToKodi->kodi_vfs_http_header_get_header_v1 = kodi_vfs_http_header_get_header_v1; + ifcToKodi->kodi_vfs_http_header_get_mime_type_v1 = kodi_vfs_http_header_get_mime_type_v1; + ifcToKodi->kodi_vfs_http_header_get_charset_v1 = kodi_vfs_http_header_get_charset_v1; + ifcToKodi->kodi_vfs_http_header_get_proto_line_v1 = kodi_vfs_http_header_get_proto_line_v1; + ifcToKodi->kodi_vfs_file_open_v1 = kodi_vfs_file_open_v1; + ifcToKodi->kodi_vfs_file_open_for_write_v1 = kodi_vfs_file_open_for_write_v1; + ifcToKodi->kodi_vfs_file_curl_create_v1 = kodi_vfs_file_curl_create_v1; + ifcToKodi->kodi_vfs_file_curl_add_option_v1 = kodi_vfs_file_curl_add_option_v1; + ifcToKodi->kodi_vfs_file_curl_open_v1 = kodi_vfs_file_curl_open_v1; + ifcToKodi->kodi_vfs_file_close_v1 = kodi_vfs_file_close_v1; + ifcToKodi->kodi_vfs_file_read_v1 = kodi_vfs_file_read_v1; + ifcToKodi->kodi_vfs_file_read_line_v1 = kodi_vfs_file_read_line_v1; + ifcToKodi->kodi_vfs_file_write_v1 = kodi_vfs_file_write_v1; + ifcToKodi->kodi_vfs_file_flush_v1 = kodi_vfs_file_flush_v1; + ifcToKodi->kodi_vfs_file_seek_v1 = kodi_vfs_file_seek_v1; + ifcToKodi->kodi_vfs_file_truncate_v1 = kodi_vfs_file_truncate_v1; + ifcToKodi->kodi_vfs_file_get_position_v1 = kodi_vfs_file_get_position_v1; + ifcToKodi->kodi_vfs_file_get_length_v1 = kodi_vfs_file_get_length_v1; + ifcToKodi->kodi_vfs_file_at_end_v1 = kodi_vfs_file_at_end_v1; + ifcToKodi->kodi_vfs_file_get_download_speed_v1 = kodi_vfs_file_get_download_speed_v1; + ifcToKodi->kodi_vfs_file_get_chunk_size_v1 = kodi_vfs_file_get_chunk_size_v1; + ifcToKodi->kodi_vfs_file_io_ctl_get_seek_possible_v1 = kodi_vfs_file_io_ctl_get_seek_possible_v1; + ifcToKodi->kodi_vfs_file_io_ctl_get_cache_status_v1 = kodi_vfs_file_io_ctl_get_cache_status_v1; + ifcToKodi->kodi_vfs_file_io_ctl_set_cache_rate_v1 = kodi_vfs_file_io_ctl_set_cache_rate_v1; + ifcToKodi->kodi_vfs_file_io_ctl_set_retry_v1 = kodi_vfs_file_io_ctl_set_retry_v1; + ifcToKodi->kodi_vfs_file_get_property_value_v1 = kodi_vfs_file_get_property_value_v1; + ifcToKodi->kodi_vfs_file_get_property_values_v1 = kodi_vfs_file_get_property_values_v1; +} + +bool CHdl_kodi_filesystem_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_filesystem_h) + return false; + + switch (func) + { + case funcParent_kodi_vfs_can_open_directory_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_can_open_directory(const char* url) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_can_open_directory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_can_open_directory_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_can_open_directory_v1 t = in.get().as(); + const std::string& url = std::get<0>(t); + bool auto_gen_ret = kodi_vfs_can_open_directory_v1(this, url.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_can_open_directory_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_create_directory_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_create_directory(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_create_directory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_create_directory_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_create_directory_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + bool auto_gen_ret = kodi_vfs_create_directory_v1(this, path.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_create_directory_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_remove_directory_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_remove_directory(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_remove_directory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_remove_directory_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_remove_directory_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + bool auto_gen_ret = kodi_vfs_remove_directory_v1(this, path.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_remove_directory_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_remove_directory_recursive_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_remove_directory_recursive(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_remove_directory_recursive_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_remove_directory_recursive_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_remove_directory_recursive_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + bool auto_gen_ret = kodi_vfs_remove_directory_recursive_v1(this, path.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_remove_directory_recursive_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_directory_exists_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_directory_exists(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_directory_exists_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_directory_exists_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_directory_exists_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + bool auto_gen_ret = kodi_vfs_directory_exists_v1(this, path.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_directory_exists_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_get_directory_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_get_directory(const char* path, const char* mask, struct VFS_DIR_ENTRY** items, size_t* num_items) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_directory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgParent_OUT_kodi_vfs_get_directory_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_get_directory_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + const std::string& mask = std::get<1>(t); + struct VFS_DIR_ENTRY* items = nullptr; + size_t num_items = std::get<2>(t); + bool auto_gen_ret = + kodi_vfs_get_directory_v1(this, path.c_str(), mask.c_str(), &items, &num_items); + std::vector ifc_items; + if (items) + { + ifc_items.reserve(num_items); + for (size_t i = 0; i < num_items; ++i) + { + ifc_items.emplace_back(&items[i]); + ifc_items[i].CleanCStructure(&items[i]); + } + free(items); + } + msgpack::pack(out, + msgParent_OUT_kodi_vfs_get_directory_v1(auto_gen_ret, ifc_items, num_items)); + return true; + } + case funcParent_kodi_vfs_file_exists_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_exists(const char* filename, bool useCache) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_exists_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_exists_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_exists_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + bool useCache = std::get<1>(t); + bool auto_gen_ret = kodi_vfs_file_exists_v1(this, filename.c_str(), useCache); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_exists_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_stat_file_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_stat_file(const char* filename, struct VFS_STAT_STRUCTURE* buffer) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_stat_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_stat_file_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_stat_file_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + struct VFS_STAT_STRUCTURE buffer = {}; + bool auto_gen_ret = kodi_vfs_stat_file_v1(this, filename.c_str(), &buffer); + msgpack::pack(out, msgParent_OUT_kodi_vfs_stat_file_v1(auto_gen_ret, &buffer)); + return true; + } + case funcParent_kodi_vfs_delete_file_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_delete_file(const char* filename) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_delete_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_delete_file_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_delete_file_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + bool auto_gen_ret = kodi_vfs_delete_file_v1(this, filename.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_delete_file_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_rename_file_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_rename_file(const char* filename, const char* newFileName) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_rename_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_rename_file_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_rename_file_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + const std::string& newFileName = std::get<1>(t); + bool auto_gen_ret = kodi_vfs_rename_file_v1(this, filename.c_str(), newFileName.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_rename_file_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_copy_file_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_copy_file(const char* filename, const char* dest) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_copy_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_copy_file_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_copy_file_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + const std::string& dest = std::get<1>(t); + bool auto_gen_ret = kodi_vfs_copy_file_v1(this, filename.c_str(), dest.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_copy_file_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_get_file_md5_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_get_file_md5(const char* filename) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_file_md5_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_file_md5_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_get_file_md5_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + char* auto_gen_ret = kodi_vfs_get_file_md5_v1(this, filename.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_get_file_md5_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_get_cache_thumb_name_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_get_cache_thumb_name(const char* filename) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_cache_thumb_name_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_cache_thumb_name_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_get_cache_thumb_name_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + char* auto_gen_ret = kodi_vfs_get_cache_thumb_name_v1(this, filename.c_str()); + msgpack::pack( + out, msgParent_OUT_kodi_vfs_get_cache_thumb_name_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_make_legal_filename_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_make_legal_filename(const char* filename) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_make_legal_filename_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_make_legal_filename_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_make_legal_filename_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + char* auto_gen_ret = kodi_vfs_make_legal_filename_v1(this, filename.c_str()); + msgpack::pack( + out, msgParent_OUT_kodi_vfs_make_legal_filename_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_make_legal_path_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_make_legal_path(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_make_legal_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_make_legal_path_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_make_legal_path_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + char* auto_gen_ret = kodi_vfs_make_legal_path_v1(this, path.c_str()); + msgpack::pack(out, + msgParent_OUT_kodi_vfs_make_legal_path_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_translate_special_protocol_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_translate_special_protocol(const char* strSource) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_translate_special_protocol_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_translate_special_protocol_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_translate_special_protocol_v1 t = in.get().as(); + const std::string& strSource = std::get<0>(t); + char* auto_gen_ret = kodi_vfs_translate_special_protocol_v1(this, strSource.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_translate_special_protocol_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_is_internet_stream_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_is_internet_stream(const char* path, bool strictCheck) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_is_internet_stream_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_is_internet_stream_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_is_internet_stream_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + bool strictCheck = std::get<1>(t); + bool auto_gen_ret = kodi_vfs_is_internet_stream_v1(this, path.c_str(), strictCheck); + msgpack::pack(out, msgParent_OUT_kodi_vfs_is_internet_stream_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_is_on_lan_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_is_on_lan(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_is_on_lan_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_is_on_lan_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_is_on_lan_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + bool auto_gen_ret = kodi_vfs_is_on_lan_v1(this, path.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_is_on_lan_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_is_remote_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_is_remote(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_is_remote_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_is_remote_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_is_remote_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + bool auto_gen_ret = kodi_vfs_is_remote_v1(this, path.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_is_remote_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_is_local_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_is_local(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_is_local_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_is_local_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_is_local_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + bool auto_gen_ret = kodi_vfs_is_local_v1(this, path.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_is_local_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_is_url_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_is_url(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_is_url_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_is_url_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_is_url_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + bool auto_gen_ret = kodi_vfs_is_url_v1(this, path.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_is_url_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_get_mime_type_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_get_mime_type(const char* url, char** content, const char* useragent) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_mime_type_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_mime_type_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_get_mime_type_v1 t = in.get().as(); + const std::string& url = std::get<0>(t); + char* content = nullptr; + const std::string& useragent = std::get<1>(t); + bool auto_gen_ret = kodi_vfs_get_mime_type_v1(this, url.c_str(), &content, useragent.c_str()); + msgpack::pack(out, + msgParent_OUT_kodi_vfs_get_mime_type_v1(auto_gen_ret, content ? content : "")); + if (content) + free(content); + return true; + } + case funcParent_kodi_vfs_get_content_type_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_get_content_type(const char* url, char** content, const char* useragent) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_content_type_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_content_type_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_get_content_type_v1 t = in.get().as(); + const std::string& url = std::get<0>(t); + char* content = nullptr; + const std::string& useragent = std::get<1>(t); + bool auto_gen_ret = + kodi_vfs_get_content_type_v1(this, url.c_str(), &content, useragent.c_str()); + msgpack::pack( + out, msgParent_OUT_kodi_vfs_get_content_type_v1(auto_gen_ret, content ? content : "")); + if (content) + free(content); + return true; + } + case funcParent_kodi_vfs_get_cookies_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_get_cookies(const char* url, char** cookies) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_cookies_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_cookies_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_get_cookies_v1 t = in.get().as(); + const std::string& url = std::get<0>(t); + char* cookies = nullptr; + bool auto_gen_ret = kodi_vfs_get_cookies_v1(this, url.c_str(), &cookies); + msgpack::pack(out, + msgParent_OUT_kodi_vfs_get_cookies_v1(auto_gen_ret, cookies ? cookies : "")); + if (cookies) + free(cookies); + return true; + } + case funcParent_kodi_vfs_get_disk_space_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_get_disk_space(const char* path, uint64_t* capacity, uint64_t* free, uint64_t* available) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_disk_space_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_disk_space_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_get_disk_space_v1 t = in.get().as(); + const std::string& path = std::get<0>(t); + uint64_t capacity = std::get<1>(t); + uint64_t free = std::get<2>(t); + uint64_t available = std::get<3>(t); + bool auto_gen_ret = + kodi_vfs_get_disk_space_v1(this, path.c_str(), &capacity, &free, &available); + msgpack::pack( + out, msgParent_OUT_kodi_vfs_get_disk_space_v1(auto_gen_ret, capacity, free, available)); + return true; + } + case funcParent_kodi_vfs_http_header_open_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_HTTP_HEADER_HDL kodi_vfs_http_header_open(const char* url) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_open_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_http_header_open_v1 t = in.get().as(); + const std::string& url = std::get<0>(t); + KODI_HTTP_HEADER_HDL auto_gen_ret = kodi_vfs_http_header_open_v1(this, url.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_http_header_open_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_vfs_http_header_close_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_vfs_http_header_close(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_close_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_close_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_http_header_close_v1 t = in.get().as(); + KODI_HTTP_HEADER_HDL hdl = reinterpret_cast(std::get<0>(t)); + kodi_vfs_http_header_close_v1(this, hdl); + return true; + } + case funcParent_kodi_vfs_http_header_get_value_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_value(KODI_HTTP_HEADER_HDL hdl, const char* param) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_get_value_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_http_header_get_value_v1 t = in.get().as(); + KODI_HTTP_HEADER_HDL hdl = reinterpret_cast(std::get<0>(t)); + const std::string& param = std::get<1>(t); + char* auto_gen_ret = kodi_vfs_http_header_get_value_v1(this, hdl, param.c_str()); + msgpack::pack( + out, msgParent_OUT_kodi_vfs_http_header_get_value_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_http_header_get_values_v1: + { + // Original API call: ATTR_DLL_EXPORT char** kodi_vfs_http_header_get_values(KODI_HTTP_HEADER_HDL hdl, const char* param, size_t* length) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_values_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgParent_OUT_kodi_vfs_http_header_get_values_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_http_header_get_values_v1 t = in.get().as(); + KODI_HTTP_HEADER_HDL hdl = reinterpret_cast(std::get<0>(t)); + const std::string& param = std::get<1>(t); + size_t length = std::get<2>(t); + char** auto_gen_ret = kodi_vfs_http_header_get_values_v1(this, hdl, param.c_str(), &length); + std::vector auto_gen_ret_cpp; + if (auto_gen_ret) + { + auto_gen_ret_cpp.reserve(length); + for (size_t i = 0; i < length; ++i) + { + if (auto_gen_ret[i]) + { + auto_gen_ret_cpp.emplace_back(auto_gen_ret[i]); + free(auto_gen_ret[i]); + } + } + free(auto_gen_ret); + } + msgpack::pack(out, + msgParent_OUT_kodi_vfs_http_header_get_values_v1(auto_gen_ret_cpp, length)); + return true; + } + case funcParent_kodi_vfs_http_header_get_header_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_header(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_header_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_get_header_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_http_header_get_header_v1 t = in.get().as(); + KODI_HTTP_HEADER_HDL hdl = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_vfs_http_header_get_header_v1(this, hdl); + msgpack::pack( + out, msgParent_OUT_kodi_vfs_http_header_get_header_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_http_header_get_mime_type_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_mime_type(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_mime_type_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_get_mime_type_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_http_header_get_mime_type_v1 t = in.get().as(); + KODI_HTTP_HEADER_HDL hdl = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_vfs_http_header_get_mime_type_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_vfs_http_header_get_mime_type_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_http_header_get_charset_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_charset(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_charset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_get_charset_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_http_header_get_charset_v1 t = in.get().as(); + KODI_HTTP_HEADER_HDL hdl = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_vfs_http_header_get_charset_v1(this, hdl); + msgpack::pack( + out, msgParent_OUT_kodi_vfs_http_header_get_charset_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_http_header_get_proto_line_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_proto_line(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_proto_line_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_get_proto_line_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_http_header_get_proto_line_v1 t = in.get().as(); + KODI_HTTP_HEADER_HDL hdl = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_vfs_http_header_get_proto_line_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_vfs_http_header_get_proto_line_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_file_open_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_open(const char* filename, unsigned int flags) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_open_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_open_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + unsigned int flags = std::get<1>(t); + KODI_FILE_HDL auto_gen_ret = kodi_vfs_file_open_v1(this, filename.c_str(), flags); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_open_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_vfs_file_open_for_write_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_open_for_write(const char* filename, bool overwrite) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_open_for_write_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_open_for_write_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_open_for_write_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + bool overwrite = std::get<1>(t); + KODI_FILE_HDL auto_gen_ret = + kodi_vfs_file_open_for_write_v1(this, filename.c_str(), overwrite); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_open_for_write_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_vfs_file_curl_create_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_curl_create(const char* url) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_curl_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_curl_create_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_curl_create_v1 t = in.get().as(); + const std::string& url = std::get<0>(t); + KODI_FILE_HDL auto_gen_ret = kodi_vfs_file_curl_create_v1(this, url.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_curl_create_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_vfs_file_curl_add_option_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_curl_add_option(KODI_FILE_HDL hdl, enum CURLOptiontype type, const char* name, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_curl_add_option_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_curl_add_option_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_curl_add_option_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + enum CURLOptiontype type = std::get<1>(t); + const std::string& name = std::get<2>(t); + const std::string& value = std::get<3>(t); + bool auto_gen_ret = + kodi_vfs_file_curl_add_option_v1(this, hdl, type, name.c_str(), value.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_curl_add_option_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_curl_open_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_curl_open(KODI_FILE_HDL hdl, unsigned int flags) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_curl_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_curl_open_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_curl_open_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + unsigned int flags = std::get<1>(t); + bool auto_gen_ret = kodi_vfs_file_curl_open_v1(this, hdl, flags); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_curl_open_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_close_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_vfs_file_close(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_close_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_close_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_close_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + kodi_vfs_file_close_v1(this, hdl); + return true; + } + case funcParent_kodi_vfs_file_read_v1: + { + // Original API call: ATTR_DLL_EXPORT ssize_t kodi_vfs_file_read(KODI_FILE_HDL hdl, uint8_t* ptr, size_t size) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_read_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple> msgParent_OUT_kodi_vfs_file_read_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_read_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + size_t size = std::get<1>(t); + std::vector ptr(size); + ssize_t auto_gen_ret = kodi_vfs_file_read_v1(this, hdl, ptr.data(), size); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_read_v1(auto_gen_ret, ptr)); + return true; + } + case funcParent_kodi_vfs_file_read_line_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_read_line(KODI_FILE_HDL hdl, char* szLine, size_t lineLength) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_read_line_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_read_line_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_read_line_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + std::string szLine; + size_t lineLength = std::get<1>(t); + szLine.reserve(lineLength); + bool auto_gen_ret = kodi_vfs_file_read_line_v1(this, hdl, &szLine[0], lineLength); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_read_line_v1(auto_gen_ret, szLine)); + return true; + } + case funcParent_kodi_vfs_file_write_v1: + { + // Original API call: ATTR_DLL_EXPORT ssize_t kodi_vfs_file_write(KODI_FILE_HDL hdl, const uint8_t* ptr, size_t size) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple, size_t> msgParent__IN_kodi_vfs_file_write_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_write_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_write_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + const std::vector& ptr = std::get<1>(t); + size_t size = std::get<2>(t); + ssize_t auto_gen_ret = kodi_vfs_file_write_v1(this, hdl, ptr.data(), size); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_write_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_flush_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_vfs_file_flush(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_flush_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_flush_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_flush_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + kodi_vfs_file_flush_v1(this, hdl); + return true; + } + case funcParent_kodi_vfs_file_seek_v1: + { + // Original API call: ATTR_DLL_EXPORT int64_t kodi_vfs_file_seek(KODI_FILE_HDL hdl, int64_t position, int whence) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_seek_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_seek_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_seek_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + int64_t position = std::get<1>(t); + int whence = std::get<2>(t); + int64_t auto_gen_ret = kodi_vfs_file_seek_v1(this, hdl, position, whence); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_seek_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_truncate_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_vfs_file_truncate(KODI_FILE_HDL hdl, int64_t size) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_truncate_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_truncate_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_truncate_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + int64_t size = std::get<1>(t); + int auto_gen_ret = kodi_vfs_file_truncate_v1(this, hdl, size); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_truncate_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_get_position_v1: + { + // Original API call: ATTR_DLL_EXPORT int64_t kodi_vfs_file_get_position(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_get_position_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_get_position_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + int64_t auto_gen_ret = kodi_vfs_file_get_position_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_get_position_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_get_length_v1: + { + // Original API call: ATTR_DLL_EXPORT int64_t kodi_vfs_file_get_length(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_length_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_get_length_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_get_length_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + int64_t auto_gen_ret = kodi_vfs_file_get_length_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_get_length_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_at_end_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_at_end(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_at_end_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_at_end_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_at_end_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_vfs_file_at_end_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_at_end_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_get_download_speed_v1: + { + // Original API call: ATTR_DLL_EXPORT double kodi_vfs_file_get_download_speed(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_download_speed_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_get_download_speed_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_get_download_speed_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + double auto_gen_ret = kodi_vfs_file_get_download_speed_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_get_download_speed_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_get_chunk_size_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_vfs_file_get_chunk_size(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_chunk_size_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_get_chunk_size_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_get_chunk_size_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_vfs_file_get_chunk_size_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_get_chunk_size_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_io_ctl_get_seek_possible_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_get_seek_possible(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_io_ctl_get_seek_possible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_io_ctl_get_seek_possible_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_io_ctl_get_seek_possible_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_vfs_file_io_ctl_get_seek_possible_v1(this, hdl); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_io_ctl_get_seek_possible_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_io_ctl_get_cache_status_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_get_cache_status(KODI_FILE_HDL hdl, struct VFS_CACHE_STATUS* status) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_io_ctl_get_cache_status_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_io_ctl_get_cache_status_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_io_ctl_get_cache_status_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + struct VFS_CACHE_STATUS status = {}; + bool auto_gen_ret = kodi_vfs_file_io_ctl_get_cache_status_v1(this, hdl, &status); + msgpack::pack(out, + msgParent_OUT_kodi_vfs_file_io_ctl_get_cache_status_v1(auto_gen_ret, &status)); + return true; + } + case funcParent_kodi_vfs_file_io_ctl_set_cache_rate_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_set_cache_rate(KODI_FILE_HDL hdl, uint32_t rate) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_io_ctl_set_cache_rate_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_io_ctl_set_cache_rate_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_io_ctl_set_cache_rate_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + uint32_t rate = std::get<1>(t); + bool auto_gen_ret = kodi_vfs_file_io_ctl_set_cache_rate_v1(this, hdl, rate); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_io_ctl_set_cache_rate_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_io_ctl_set_retry_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_set_retry(KODI_FILE_HDL hdl, bool retry) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_io_ctl_set_retry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_io_ctl_set_retry_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_io_ctl_set_retry_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + bool retry = std::get<1>(t); + bool auto_gen_ret = kodi_vfs_file_io_ctl_set_retry_v1(this, hdl, retry); + msgpack::pack(out, msgParent_OUT_kodi_vfs_file_io_ctl_set_retry_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_vfs_file_get_property_value_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_file_get_property_value(KODI_FILE_HDL hdl, enum FilePropertyTypes type, const char* name) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_property_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_get_property_value_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_get_property_value_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + enum FilePropertyTypes type = std::get<1>(t); + const std::string& name = std::get<2>(t); + char* auto_gen_ret = kodi_vfs_file_get_property_value_v1(this, hdl, type, name.c_str()); + msgpack::pack( + out, msgParent_OUT_kodi_vfs_file_get_property_value_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_vfs_file_get_property_values_v1: + { + // Original API call: ATTR_DLL_EXPORT char** kodi_vfs_file_get_property_values(KODI_FILE_HDL hdl, enum FilePropertyTypes type, const char* name, size_t* length) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_property_values_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgParent_OUT_kodi_vfs_file_get_property_values_v1; /* Autogenerated */ + msgParent__IN_kodi_vfs_file_get_property_values_v1 t = in.get().as(); + KODI_FILE_HDL hdl = reinterpret_cast(std::get<0>(t)); + enum FilePropertyTypes type = std::get<1>(t); + const std::string& name = std::get<2>(t); + size_t length = std::get<3>(t); + char** auto_gen_ret = + kodi_vfs_file_get_property_values_v1(this, hdl, type, name.c_str(), &length); + std::vector auto_gen_ret_cpp; + if (auto_gen_ret) + { + auto_gen_ret_cpp.reserve(length); + for (size_t i = 0; i < length; ++i) + { + if (auto_gen_ret[i]) + { + auto_gen_ret_cpp.emplace_back(auto_gen_ret[i]); + free(auto_gen_ret[i]); + } + } + free(auto_gen_ret); + } + msgpack::pack(out, + msgParent_OUT_kodi_vfs_file_get_property_values_v1(auto_gen_ret_cpp, length)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_filesystem_h::{}: addon called with unknown function id '{}' on group " + "'filesystem_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +bool CHdl_kodi_filesystem_h::kodi_vfs_can_open_directory_v1(void* thisClassHdl, const char* url) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemList items; + return CDirectory::GetDirectory(url, items, "", DIR_FLAG_DEFAULTS); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_create_directory_v1(void* thisClassHdl, const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CDirectory::Create(path); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_remove_directory_v1(void* thisClassHdl, const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CDirectory::Remove(path); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_remove_directory_recursive_v1(void* thisClassHdl, + const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CDirectory::RemoveRecursive(path); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_directory_exists_v1(void* thisClassHdl, const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CDirectory::Exists(path); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_get_directory_v1(void* thisClassHdl, + const char* path, + const char* mask, + struct VFS_DIR_ENTRY** items, + size_t* num_items) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemList fileItems; + if (!CDirectory::GetDirectory(path, fileItems, mask, DIR_FLAG_NO_FILE_DIRS)) + return false; + + if (fileItems.Size() > 0) + { + *num_items = static_cast(fileItems.Size()); + *items = static_cast(calloc(fileItems.Size(), sizeof(VFS_DIR_ENTRY))); + CFileItemListToVFSDirEntries(*items, fileItems); + } + else + { + *num_items = 0; + *items = nullptr; + } + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_file_exists_v1(void* thisClassHdl, + const char* filename, + bool useCache) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CFile::Exists(filename, useCache); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_stat_file_v1(void* thisClassHdl, + const char* filename, + struct VFS_STAT_STRUCTURE* buffer) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + struct __stat64 statBuffer; + if (CFile::Stat(filename, &statBuffer) != 0) + return false; + + buffer->deviceId = statBuffer.st_dev; + buffer->fileSerialNumber = statBuffer.st_ino; + buffer->size = statBuffer.st_size; + buffer->accessTime = statBuffer.st_atime; + buffer->modificationTime = statBuffer.st_mtime; + buffer->statusTime = statBuffer.st_ctime; + buffer->isDirectory = S_ISDIR(statBuffer.st_mode); + buffer->isSymLink = S_ISLNK(statBuffer.st_mode); + buffer->isBlock = S_ISBLK(statBuffer.st_mode); + buffer->isCharacter = S_ISCHR(statBuffer.st_mode); + buffer->isFifo = S_ISFIFO(statBuffer.st_mode); + buffer->isRegular = S_ISREG(statBuffer.st_mode); + buffer->isSocket = S_ISSOCK(statBuffer.st_mode); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_delete_file_v1(void* thisClassHdl, const char* filename) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CFile::Delete(filename); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_rename_file_v1(void* thisClassHdl, + const char* filename, + const char* newFileName) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CFile::Rename(filename, newFileName); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_copy_file_v1(void* thisClassHdl, + const char* filename, + const char* dest) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CFile::Copy(filename, dest); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_get_file_md5_v1(void* thisClassHdl, const char* filename) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string = CUtil::GetFileDigest(filename, KODI::UTILITY::CDigest::Type::MD5); + char* buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_get_cache_thumb_name_v1(void* thisClassHdl, + const char* filename) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + const auto crc = Crc32::ComputeFromLowerCase(filename); + const auto hex = StringUtils::Format("%08x.tbn", crc); + char* buffer = strdup(hex.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_make_legal_filename_v1(void* thisClassHdl, + const char* filename) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string = CUtil::MakeLegalFileName(filename); + char* buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_make_legal_path_v1(void* thisClassHdl, const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string = CUtil::MakeLegalPath(path); + char* buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_translate_special_protocol_v1(void* thisClassHdl, + const char* strSource) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(CSpecialProtocol::TranslatePath(strSource).c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_is_internet_stream_v1(void* thisClassHdl, + const char* path, + bool strictCheck) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return URIUtils::IsInternetStream(path, strictCheck); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_is_on_lan_v1(void* thisClassHdl, const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return URIUtils::IsOnLAN(path); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_is_remote_v1(void* thisClassHdl, const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return URIUtils::IsRemote(path); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_is_local_v1(void* thisClassHdl, const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CURL(path).IsLocal(); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_is_url_v1(void* thisClassHdl, const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return URIUtils::IsURL(path); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_get_mime_type_v1(void* thisClassHdl, + const char* url, + char** content, + const char* useragent) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string kodiContent; + bool ret = XFILE::CCurlFile::GetMimeType(CURL(url), kodiContent, useragent); + if (ret && !kodiContent.empty()) + { + *content = strdup(kodiContent.c_str()); + } + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_get_content_type_v1(void* thisClassHdl, + const char* url, + char** content, + const char* useragent) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string kodiContent; + bool ret = XFILE::CCurlFile::GetContentType(CURL(url), kodiContent, useragent); + if (ret && !kodiContent.empty()) + { + *content = strdup(kodiContent.c_str()); + } + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_get_cookies_v1(void* thisClassHdl, + const char* url, + char** cookies) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string kodiCookies; + bool ret = XFILE::CCurlFile::GetCookies(CURL(url), kodiCookies); + if (ret && !kodiCookies.empty()) + { + *cookies = strdup(kodiCookies.c_str()); + } + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_get_disk_space_v1( + void* thisClassHdl, const char* path, uint64_t* capacity, uint64_t* free, uint64_t* available) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + using namespace KODI::PLATFORM::FILESYSTEM; + + std::error_code ec; + auto freeSpace = space(CSpecialProtocol::TranslatePath(path), ec); + if (ec.value() != 0) + return false; + + *capacity = freeSpace.capacity; + *free = freeSpace.free; + *available = freeSpace.available; + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_HTTP_HEADER_HDL CHdl_kodi_filesystem_h::kodi_vfs_http_header_open_v1(void* thisClassHdl, + const char* url) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CAddonHttpHeader* httpHeader = new CAddonHttpHeader; + if (!XFILE::CCurlFile::GetHttpHeader(CURL(url), *httpHeader)) + { + delete httpHeader; + return nullptr; + } + + return static_cast(httpHeader); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_filesystem_h::kodi_vfs_http_header_close_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + delete static_cast(hdl); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_http_header_get_value_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl, + const char* param) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string = static_cast(hdl)->GetValue(param); + + char* buffer = nullptr; + if (!string.empty()) + buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char** CHdl_kodi_filesystem_h::kodi_vfs_http_header_get_values_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl, + const char* param, + size_t* length) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::vector values = static_cast(hdl)->GetValues(param); + *length = values.size(); + char** ret = static_cast(malloc(sizeof(char*) * values.size())); + for (size_t i = 0; i < *length; ++i) + { + ret[i] = strdup(values[i].c_str()); + } + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_http_header_get_header_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + // Code below must be set manually by hand to make work to Kodi + + std::string string = static_cast(hdl)->GetHeader(); + + char* buffer = nullptr; + if (!string.empty()) + buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_http_header_get_mime_type_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string = static_cast(hdl)->GetMimeType(); + + char* buffer = nullptr; + if (!string.empty()) + buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_http_header_get_charset_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string = static_cast(hdl)->GetCharset(); + + char* buffer = nullptr; + if (!string.empty()) + buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_http_header_get_proto_line_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string = static_cast(hdl)->GetProtoLine(); + + char* buffer = nullptr; + if (!string.empty()) + buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_FILE_HDL CHdl_kodi_filesystem_h::kodi_vfs_file_open_v1(void* thisClassHdl, + const char* filename, + unsigned int flags) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CAddonFile* file = new CAddonFile; + if (file->Open(filename, TranslateFileReadBitsToKodi(flags))) + return static_cast(file); + + delete file; + return nullptr; + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_FILE_HDL CHdl_kodi_filesystem_h::kodi_vfs_file_open_for_write_v1(void* thisClassHdl, + const char* filename, + bool overwrite) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CAddonFile* file = new CAddonFile; + if (file->OpenForWrite(filename, overwrite)) + return static_cast(file); + + delete file; + return nullptr; + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_FILE_HDL CHdl_kodi_filesystem_h::kodi_vfs_file_curl_create_v1(void* thisClassHdl, + const char* url) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CAddonFile* file = new CAddonFile; + if (file->CURLCreate(url)) + return static_cast(file); + + delete file; + return nullptr; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_file_curl_add_option_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + enum CURLOptiontype type, + const char* name, + const char* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + XFILE::CURLOPTIONTYPE internalType; + switch (type) + { + case ADDON_CURL_OPTION_OPTION: + internalType = XFILE::CURL_OPTION_OPTION; + break; + case ADDON_CURL_OPTION_PROTOCOL: + internalType = XFILE::CURL_OPTION_PROTOCOL; + break; + case ADDON_CURL_OPTION_CREDENTIALS: + internalType = XFILE::CURL_OPTION_CREDENTIALS; + break; + case ADDON_CURL_OPTION_HEADER: + internalType = XFILE::CURL_OPTION_HEADER; + break; + default: + throw std::logic_error("Interface_Filesystem::curl_add_option - invalid curl option type"); + return false; + }; + + return static_cast(hdl)->CURLAddOption(internalType, name, value); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_file_curl_open_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + unsigned int flags) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->CURLOpen(TranslateFileReadBitsToKodi(flags)); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_filesystem_h::kodi_vfs_file_close_v1(void* thisClassHdl, KODI_FILE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(hdl)->Close(); + delete static_cast(hdl); + + /*---AUTO_GEN_PARSE---*/ +} + +ssize_t CHdl_kodi_filesystem_h::kodi_vfs_file_read_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + uint8_t* ptr, + size_t size) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->Read(ptr, size); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_file_read_line_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + char* szLine, + size_t lineLength) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->ReadString(szLine, lineLength); + + /*---AUTO_GEN_PARSE---*/ +} + +ssize_t CHdl_kodi_filesystem_h::kodi_vfs_file_write_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + const uint8_t* ptr, + size_t size) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->Write(ptr, size); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_filesystem_h::kodi_vfs_file_flush_v1(void* thisClassHdl, KODI_FILE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(hdl)->Flush(); + + /*---AUTO_GEN_PARSE---*/ +} + +int64_t CHdl_kodi_filesystem_h::kodi_vfs_file_seek_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + int64_t position, + int whence) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->Seek(position, whence); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_filesystem_h::kodi_vfs_file_truncate_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + int64_t size) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->Truncate(size); + + /*---AUTO_GEN_PARSE---*/ +} + +int64_t CHdl_kodi_filesystem_h::kodi_vfs_file_get_position_v1(void* thisClassHdl, KODI_FILE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->GetPosition(); + + /*---AUTO_GEN_PARSE---*/ +} + +int64_t CHdl_kodi_filesystem_h::kodi_vfs_file_get_length_v1(void* thisClassHdl, KODI_FILE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->GetLength(); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_file_at_end_v1(void* thisClassHdl, KODI_FILE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + int64_t length = kodi_vfs_file_get_length_v1(thisClassHdl, hdl); + int64_t position = kodi_vfs_file_get_position_v1(thisClassHdl, hdl); + return position >= length; + + /*---AUTO_GEN_PARSE---*/ +} + +double CHdl_kodi_filesystem_h::kodi_vfs_file_get_download_speed_v1(void* thisClassHdl, + KODI_FILE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->GetDownloadSpeed(); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_filesystem_h::kodi_vfs_file_get_chunk_size_v1(void* thisClassHdl, KODI_FILE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->GetChunkSize(); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_file_io_ctl_get_seek_possible_v1(void* thisClassHdl, + KODI_FILE_HDL hdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->IoControl(EIoControl::IOCTRL_SEEK_POSSIBLE, nullptr) != 0 + ? true + : false; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_file_io_ctl_get_cache_status_v1( + void* thisClassHdl, KODI_FILE_HDL hdl, struct VFS_CACHE_STATUS* status) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + SCacheStatus data; + memset(&data, 0, sizeof(data)); + int ret = static_cast(hdl)->IoControl(EIoControl::IOCTRL_CACHE_STATUS, &data); + if (ret >= 0) + { + status->forward = data.forward; + status->maxrate = data.maxrate; + status->currate = data.currate; + status->lowrate = data.lowrate; + return true; + } + return false; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_file_io_ctl_set_cache_rate_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + uint32_t rate) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->IoControl(EIoControl::IOCTRL_CACHE_SETRATE, &rate) >= 0 + ? true + : false; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_filesystem_h::kodi_vfs_file_io_ctl_set_retry_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + bool retry) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(hdl)->IoControl(EIoControl::IOCTRL_SET_RETRY, &retry) >= 0 + ? true + : false; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_filesystem_h::kodi_vfs_file_get_property_value_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + enum FilePropertyTypes type, + const char* name) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + XFILE::FileProperty internalType = TranslateFilePropertyToKodi(type); + return strdup(static_cast(hdl)->GetProperty(internalType, name).c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +char** CHdl_kodi_filesystem_h::kodi_vfs_file_get_property_values_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + enum FilePropertyTypes type, + const char* name, + size_t* length) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + XFILE::FileProperty internalType = TranslateFilePropertyToKodi(type); + std::vector values = + static_cast(hdl)->GetPropertyValues(internalType, name); + *length = values.size(); + char** ret = static_cast(malloc(sizeof(char*) * values.size())); + for (size_t i = 0; i < *length; ++i) + { + ret[i] = strdup(values[i].c_str()); + } + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/filesystem.h b/xbmc/addons/interface/api/filesystem.h new file mode 100644 index 0000000000000..e08ed08a20463 --- /dev/null +++ b/xbmc/addons/interface/api/filesystem.h @@ -0,0 +1,268 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/filesystem.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_filesystem_h; +struct directFuncToKodi_filesystem_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_filesystem_h : public IMsgHdl +{ +public: + CHdl_kodi_filesystem_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_filesystem_h* ifcToKodi, + directFuncToAddon_filesystem_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static bool kodi_vfs_can_open_directory_v1(void* thisClassHdl, + const char* url); // Added with API 1 + + static bool kodi_vfs_create_directory_v1(void* thisClassHdl, + const char* path); // Added with API 1 + + static bool kodi_vfs_remove_directory_v1(void* thisClassHdl, + const char* path); // Added with API 1 + + static bool kodi_vfs_remove_directory_recursive_v1(void* thisClassHdl, + const char* path); // Added with API 1 + + static bool kodi_vfs_directory_exists_v1(void* thisClassHdl, + const char* path); // Added with API 1 + + static bool kodi_vfs_get_directory_v1(void* thisClassHdl, + const char* path, + const char* mask, + struct VFS_DIR_ENTRY** items, + size_t* num_items); // Added with API 1 + + static bool kodi_vfs_file_exists_v1(void* thisClassHdl, + const char* filename, + bool useCache); // Added with API 1 + + static bool kodi_vfs_stat_file_v1(void* thisClassHdl, + const char* filename, + struct VFS_STAT_STRUCTURE* buffer); // Added with API 1 + + static bool kodi_vfs_delete_file_v1(void* thisClassHdl, const char* filename); // Added with API 1 + + static bool kodi_vfs_rename_file_v1(void* thisClassHdl, + const char* filename, + const char* newFileName); // Added with API 1 + + static bool kodi_vfs_copy_file_v1(void* thisClassHdl, + const char* filename, + const char* dest); // Added with API 1 + + static char* kodi_vfs_get_file_md5_v1(void* thisClassHdl, + const char* filename); // Added with API 1 + + static char* kodi_vfs_get_cache_thumb_name_v1(void* thisClassHdl, + const char* filename); // Added with API 1 + + static char* kodi_vfs_make_legal_filename_v1(void* thisClassHdl, + const char* filename); // Added with API 1 + + static char* kodi_vfs_make_legal_path_v1(void* thisClassHdl, + const char* path); // Added with API 1 + + static char* kodi_vfs_translate_special_protocol_v1(void* thisClassHdl, + const char* strSource); // Added with API 1 + + static bool kodi_vfs_is_internet_stream_v1(void* thisClassHdl, + const char* path, + bool strictCheck); // Added with API 1 + + static bool kodi_vfs_is_on_lan_v1(void* thisClassHdl, const char* path); // Added with API 1 + + static bool kodi_vfs_is_remote_v1(void* thisClassHdl, const char* path); // Added with API 1 + + static bool kodi_vfs_is_local_v1(void* thisClassHdl, const char* path); // Added with API 1 + + static bool kodi_vfs_is_url_v1(void* thisClassHdl, const char* path); // Added with API 1 + + static bool kodi_vfs_get_mime_type_v1(void* thisClassHdl, + const char* url, + char** content, + const char* useragent); // Added with API 1 + + static bool kodi_vfs_get_content_type_v1(void* thisClassHdl, + const char* url, + char** content, + const char* useragent); // Added with API 1 + + static bool kodi_vfs_get_cookies_v1(void* thisClassHdl, + const char* url, + char** cookies); // Added with API 1 + + static bool kodi_vfs_get_disk_space_v1(void* thisClassHdl, + const char* path, + uint64_t* capacity, + uint64_t* free, + uint64_t* available); // Added with API 1 + + static KODI_HTTP_HEADER_HDL kodi_vfs_http_header_open_v1(void* thisClassHdl, + const char* url); // Added with API 1 + + static void kodi_vfs_http_header_close_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl); // Added with API 1 + + static char* kodi_vfs_http_header_get_value_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl, + const char* param); // Added with API 1 + + static char** kodi_vfs_http_header_get_values_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl, + const char* param, + size_t* length); // Added with API 1 + + static char* kodi_vfs_http_header_get_header_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl); // Added with API 1 + + static char* kodi_vfs_http_header_get_mime_type_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl); // Added with API 1 + + static char* kodi_vfs_http_header_get_charset_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl); // Added with API 1 + + static char* kodi_vfs_http_header_get_proto_line_v1(void* thisClassHdl, + KODI_HTTP_HEADER_HDL hdl); // Added with API 1 + + static KODI_FILE_HDL kodi_vfs_file_open_v1(void* thisClassHdl, + const char* filename, + unsigned int flags); // Added with API 1 + + static KODI_FILE_HDL kodi_vfs_file_open_for_write_v1(void* thisClassHdl, + const char* filename, + bool overwrite); // Added with API 1 + + static KODI_FILE_HDL kodi_vfs_file_curl_create_v1(void* thisClassHdl, + const char* url); // Added with API 1 + + static bool kodi_vfs_file_curl_add_option_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + enum CURLOptiontype type, + const char* name, + const char* value); // Added with API 1 + + static bool kodi_vfs_file_curl_open_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + unsigned int flags); // Added with API 1 + + static void kodi_vfs_file_close_v1(void* thisClassHdl, KODI_FILE_HDL hdl); // Added with API 1 + + static ssize_t kodi_vfs_file_read_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + uint8_t* ptr, + size_t size); // Added with API 1 + + static bool kodi_vfs_file_read_line_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + char* szLine, + size_t lineLength); // Added with API 1 + + static ssize_t kodi_vfs_file_write_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + const uint8_t* ptr, + size_t size); // Added with API 1 + + static void kodi_vfs_file_flush_v1(void* thisClassHdl, KODI_FILE_HDL hdl); // Added with API 1 + + static int64_t kodi_vfs_file_seek_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + int64_t position, + int whence); // Added with API 1 + + static int kodi_vfs_file_truncate_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + int64_t size); // Added with API 1 + + static int64_t kodi_vfs_file_get_position_v1(void* thisClassHdl, + KODI_FILE_HDL hdl); // Added with API 1 + + static int64_t kodi_vfs_file_get_length_v1(void* thisClassHdl, + KODI_FILE_HDL hdl); // Added with API 1 + + static bool kodi_vfs_file_at_end_v1(void* thisClassHdl, KODI_FILE_HDL hdl); // Added with API 1 + + static double kodi_vfs_file_get_download_speed_v1(void* thisClassHdl, + KODI_FILE_HDL hdl); // Added with API 1 + + static int kodi_vfs_file_get_chunk_size_v1(void* thisClassHdl, + KODI_FILE_HDL hdl); // Added with API 1 + + static bool kodi_vfs_file_io_ctl_get_seek_possible_v1(void* thisClassHdl, + KODI_FILE_HDL hdl); // Added with API 1 + + static bool kodi_vfs_file_io_ctl_get_cache_status_v1( + void* thisClassHdl, KODI_FILE_HDL hdl, struct VFS_CACHE_STATUS* status); // Added with API 1 + + static bool kodi_vfs_file_io_ctl_set_cache_rate_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + uint32_t rate); // Added with API 1 + + static bool kodi_vfs_file_io_ctl_set_retry_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + bool retry); // Added with API 1 + + static char* kodi_vfs_file_get_property_value_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + enum FilePropertyTypes type, + const char* name); // Added with API 1 + + static char** kodi_vfs_file_get_property_values_v1(void* thisClassHdl, + KODI_FILE_HDL hdl, + enum FilePropertyTypes type, + const char* name, + size_t* length); // Added with API 1 + + directFuncToAddon_filesystem_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/general.cpp b/xbmc/addons/interface/api/general.cpp new file mode 100644 index 0000000000000..f04b6eb1091bc --- /dev/null +++ b/xbmc/addons/interface/api/general.cpp @@ -0,0 +1,820 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "general.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/general.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +#include "Application.h" +#include "CompileInfo.h" +#include "LangInfo.h" +#include "ServiceBroker.h" +#include "addons/AddonManager.h" +#include "addons/gui/GUIDialogAddonSettings.h" +#include "cores/AudioEngine/Interfaces/AE.h" +#include "dialogs/GUIDialogKaiToast.h" +#include "filesystem/Directory.h" +#include "filesystem/File.h" +#include "filesystem/SpecialProtocol.h" +#include "guilib/GUIAudioManager.h" +#include "guilib/GUIComponent.h" +#include "guilib/LocalizeStrings.h" +#include "input/KeyboardLayout.h" +#include "input/KeyboardLayoutManager.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" +#include "utils/CharsetConverter.h" +#include "utils/Digest.h" +#include "utils/LangCodeExpander.h" +#include "utils/MemUtils.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" + +using namespace ADDON; +using namespace KODI::UTILITY; + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_general_h::InitDirect(directFuncToKodi_general_h* ifcToKodi, + directFuncToAddon_general_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_get_localized_string_v1 = kodi_get_localized_string_v1; + ifcToKodi->kodi_get_free_mem_v1 = kodi_get_free_mem_v1; + ifcToKodi->kodi_unknown_to_utf8_v1 = kodi_unknown_to_utf8_v1; + ifcToKodi->kodi_get_language_v1 = kodi_get_language_v1; + ifcToKodi->kodi_queue_notification_v1 = kodi_queue_notification_v1; + ifcToKodi->kodi_get_digest_v1 = kodi_get_digest_v1; + ifcToKodi->kodi_get_region_v1 = kodi_get_region_v1; + ifcToKodi->kodi_get_global_idle_time_v1 = kodi_get_global_idle_time_v1; + ifcToKodi->kodi_is_addon_avilable_v1 = kodi_is_addon_avilable_v1; + ifcToKodi->kodi_version_v1 = kodi_version_v1; + ifcToKodi->kodi_get_current_skin_id_v1 = kodi_get_current_skin_id_v1; + ifcToKodi->kodi_get_keyboard_layout_v1 = kodi_get_keyboard_layout_v1; + ifcToKodi->kodi_change_keyboard_layout_v1 = kodi_change_keyboard_layout_v1; + ifcToKodi->kodi_play_sfx_v1 = kodi_play_sfx_v1; + ifcToKodi->kodi_stop_sfx_v1 = kodi_stop_sfx_v1; +} + +bool CHdl_kodi_general_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_general_h) + return false; + + switch (func) + { + case funcParent_kodi_get_localized_string_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_get_localized_string(long label_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_localized_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_localized_string_v1; /* Autogenerated */ + msgParent__IN_kodi_get_localized_string_v1 t = in.get().as(); + long label_id = std::get<0>(t); + char* auto_gen_ret = kodi_get_localized_string_v1(this, label_id); + msgpack::pack(out, + msgParent_OUT_kodi_get_localized_string_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_get_free_mem_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_get_free_mem(long* free, long* total, bool as_bytes) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_free_mem_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_free_mem_v1; /* Autogenerated */ + msgParent__IN_kodi_get_free_mem_v1 t = in.get().as(); + long free = std::get<0>(t); + long total = std::get<1>(t); + bool as_bytes = std::get<2>(t); + kodi_get_free_mem_v1(this, &free, &total, as_bytes); + msgpack::pack(out, msgParent_OUT_kodi_get_free_mem_v1(free, total)); + return true; + } + case funcParent_kodi_unknown_to_utf8_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_unknown_to_utf8(const char* source, bool* ret, bool failOnBadChar) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_unknown_to_utf8_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_unknown_to_utf8_v1; /* Autogenerated */ + msgParent__IN_kodi_unknown_to_utf8_v1 t = in.get().as(); + const std::string& source = std::get<0>(t); + bool ret = std::get<1>(t); + bool failOnBadChar = std::get<2>(t); + char* auto_gen_ret = kodi_unknown_to_utf8_v1(this, source.c_str(), &ret, failOnBadChar); + msgpack::pack(out, + msgParent_OUT_kodi_unknown_to_utf8_v1(auto_gen_ret ? auto_gen_ret : "", ret)); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_get_language_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_get_language(enum LangFormats format, bool region) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_language_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_language_v1; /* Autogenerated */ + msgParent__IN_kodi_get_language_v1 t = in.get().as(); + enum LangFormats format = std::get<0>(t); + bool region = std::get<1>(t); + char* auto_gen_ret = kodi_get_language_v1(this, format, region); + msgpack::pack(out, msgParent_OUT_kodi_get_language_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_queue_notification_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_queue_notification(enum QueueMsg type, const char* header, const char* message, const char* imageFile, unsigned int displayTime, bool withSound, unsigned int messageTime) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_queue_notification_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_queue_notification_v1; /* Autogenerated */ + msgParent__IN_kodi_queue_notification_v1 t = in.get().as(); + enum QueueMsg type = std::get<0>(t); + const std::string& header = std::get<1>(t); + const std::string& message = std::get<2>(t); + const std::string& imageFile = std::get<3>(t); + unsigned int displayTime = std::get<4>(t); + bool withSound = std::get<5>(t); + unsigned int messageTime = std::get<6>(t); + kodi_queue_notification_v1(this, type, header.c_str(), message.c_str(), imageFile.c_str(), + displayTime, withSound, messageTime); + return true; + } + case funcParent_kodi_get_digest_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_get_digest(enum DigestType type, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_digest_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_digest_v1; /* Autogenerated */ + msgParent__IN_kodi_get_digest_v1 t = in.get().as(); + enum DigestType type = std::get<0>(t); + const std::string& text = std::get<1>(t); + char* auto_gen_ret = kodi_get_digest_v1(this, type, text.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_get_digest_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_get_region_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_get_region(const char* id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_region_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_region_v1; /* Autogenerated */ + msgParent__IN_kodi_get_region_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + char* auto_gen_ret = kodi_get_region_v1(this, id.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_get_region_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_get_global_idle_time_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_get_global_idle_time() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_global_idle_time_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_global_idle_time_v1; /* Autogenerated */ + int auto_gen_ret = kodi_get_global_idle_time_v1(this); + msgpack::pack(out, msgParent_OUT_kodi_get_global_idle_time_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_is_addon_avilable_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_is_addon_avilable(const char* id, char** version, bool* enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_is_addon_avilable_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_is_addon_avilable_v1; /* Autogenerated */ + msgParent__IN_kodi_is_addon_avilable_v1 t = in.get().as(); + const std::string& id = std::get<0>(t); + char* version = nullptr; + bool enabled = std::get<1>(t); + bool auto_gen_ret = kodi_is_addon_avilable_v1(this, id.c_str(), &version, &enabled); + msgpack::pack(out, msgParent_OUT_kodi_is_addon_avilable_v1(auto_gen_ret, + version ? version : "", enabled)); + if (version) + free(version); + return true; + } + case funcParent_kodi_version_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_version( char** compile_name, int* major, int* minor, char** revision, char** tag, char** tagversion) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_version_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_version_v1; /* Autogenerated */ + msgParent__IN_kodi_version_v1 t = in.get().as(); + char* compile_name = nullptr; + int major = std::get<0>(t); + int minor = std::get<1>(t); + char* revision = nullptr; + char* tag = nullptr; + char* tagversion = nullptr; + kodi_version_v1(this, &compile_name, &major, &minor, &revision, &tag, &tagversion); + msgpack::pack(out, + msgParent_OUT_kodi_version_v1(compile_name ? compile_name : "", major, minor, + revision ? revision : "", tag ? tag : "", + tagversion ? tagversion : "")); + if (compile_name) + free(compile_name); + if (revision) + free(revision); + if (tag) + free(tag); + if (tagversion) + free(tagversion); + return true; + } + case funcParent_kodi_get_current_skin_id_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_get_current_skin_id() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_current_skin_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_current_skin_id_v1; /* Autogenerated */ + char* auto_gen_ret = kodi_get_current_skin_id_v1(this); + msgpack::pack(out, + msgParent_OUT_kodi_get_current_skin_id_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_get_keyboard_layout_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_get_keyboard_layout(int modifier_key, char** layout_name, struct AddonKeyboardKeyTable* layout) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_keyboard_layout_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_keyboard_layout_v1; /* Autogenerated */ + msgParent__IN_kodi_get_keyboard_layout_v1 t = in.get().as(); + int modifier_key = std::get<0>(t); + char* layout_name = nullptr; + struct AddonKeyboardKeyTable layout = {}; + bool auto_gen_ret = kodi_get_keyboard_layout_v1(this, modifier_key, &layout_name, &layout); + msgpack::pack(out, msgParent_OUT_kodi_get_keyboard_layout_v1( + auto_gen_ret, layout_name ? layout_name : "", &layout)); + if (layout_name) + free(layout_name); + return true; + } + case funcParent_kodi_change_keyboard_layout_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_change_keyboard_layout(char** layout_name) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_change_keyboard_layout_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_change_keyboard_layout_v1; /* Autogenerated */ + msgParent__IN_kodi_change_keyboard_layout_v1 t = in.get().as(); + char* layout_name = nullptr; + bool auto_gen_ret = kodi_change_keyboard_layout_v1(this, &layout_name); + msgpack::pack(out, msgParent_OUT_kodi_change_keyboard_layout_v1( + auto_gen_ret, layout_name ? layout_name : "")); + if (layout_name) + free(layout_name); + return true; + } + case funcParent_kodi_play_sfx_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_play_sfx(const char* filename, bool use_cached) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_play_sfx_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_play_sfx_v1; /* Autogenerated */ + msgParent__IN_kodi_play_sfx_v1 t = in.get().as(); + const std::string& filename = std::get<0>(t); + bool use_cached = std::get<1>(t); + kodi_play_sfx_v1(this, filename.c_str(), use_cached); + return true; + } + case funcParent_kodi_stop_sfx_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_stop_sfx() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_stop_sfx_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_stop_sfx_v1; /* Autogenerated */ + kodi_stop_sfx_v1(this); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_general_h::{}: addon called with unknown function id '{}' on group " + "'general_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +char* CHdl_kodi_general_h::kodi_get_localized_string_v1(void* thisClassHdl, long label_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + if (g_application.m_bStop) + return nullptr; + + std::string label = + g_localizeStrings.GetAddonString(thisClass->m_process->GetAddonID(), label_id); + if (label.empty()) + label = g_localizeStrings.Get(label_id); + char* buffer = strdup(label.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_general_h::kodi_get_free_mem_v1(void* thisClassHdl, + long* free, + long* total, + bool as_bytes) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + KODI::MEMORY::MemoryStatus stat; + KODI::MEMORY::GetMemoryStatus(&stat); + *free = static_cast(stat.availPhys); + *total = static_cast(stat.totalPhys); + if (!as_bytes) + { + *free = *free / (1024 * 1024); + *total = *total / (1024 * 1024); + } + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_general_h::kodi_unknown_to_utf8_v1(void* thisClassHdl, + const char* source, + bool* ret, + bool failOnBadChar) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string; + *ret = g_charsetConverter.unknownToUTF8(source, string, failOnBadChar); + char* buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_general_h::kodi_get_language_v1(void* thisClassHdl, + enum LangFormats format, + bool region) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string = g_langInfo.GetEnglishLanguageName(); + switch (format) + { + case LANG_FMT_ISO_639_1: + { + std::string langCode; + g_LangCodeExpander.ConvertToISO6391(string, langCode); + string = langCode; + if (region) + { + std::string region2Code; + g_LangCodeExpander.ConvertToISO6391(g_langInfo.GetRegionLocale(), region2Code); + if (!region2Code.empty()) + string += "-" + region2Code; + } + break; + } + case LANG_FMT_ISO_639_2: + { + std::string langCode; + g_LangCodeExpander.ConvertToISO6392B(string, langCode); + string = langCode; + if (region) + { + std::string region3Code; + g_LangCodeExpander.ConvertToISO6392B(g_langInfo.GetRegionLocale(), region3Code); + if (!region3Code.empty()) + string += "-" + region3Code; + } + break; + } + case LANG_FMT_ENGLISH_NAME: + default: + { + if (region) + string += "-" + g_langInfo.GetCurrentRegion(); + break; + } + } + + char* buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_general_h::kodi_queue_notification_v1(void* thisClassHdl, + enum QueueMsg type, + const char* header, + const char* message, + const char* imageFile, + unsigned int displayTime, + bool withSound, + unsigned int messageTime) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + std::shared_ptr addon = thisClass->m_process->GetAddon(); + + std::string usedHeader; + if (header && strlen(header) > 0) + usedHeader = header; + else + usedHeader = addon->Name(); + + QueueMsg qtype = static_cast(type); + + if (qtype != QUEUE_OWN_STYLE) + { + CGUIDialogKaiToast::eMessageType usedType; + switch (qtype) + { + case QueueMsg::QUEUE_WARNING: + usedType = CGUIDialogKaiToast::Warning; + withSound = true; + CLog::Log(LOGDEBUG, "Interface_General::{} - {} - Warning Message: '{}'", __func__, + addon->Name(), message); + break; + case QueueMsg::QUEUE_ERROR: + usedType = CGUIDialogKaiToast::Error; + withSound = true; + CLog::Log(LOGDEBUG, "Interface_General::{} - {} - Error Message : '{}'", __func__, + addon->Name(), message); + break; + case QueueMsg::QUEUE_INFO: + default: + usedType = CGUIDialogKaiToast::Info; + withSound = false; + CLog::Log(LOGDEBUG, "Interface_General::{} - {} - Info Message : '{}'", __func__, + addon->Name(), message); + break; + } + + if (imageFile && strlen(imageFile) > 0) + { + CLog::Log(LOGERROR, + "Interface_General::{} - To use given image file '{}' must be type value set to " + "'QUEUE_OWN_STYLE'", + __func__, imageFile); + } + + CGUIDialogKaiToast::QueueNotification(usedType, usedHeader, message, 3000, withSound); + } + else + { + CGUIDialogKaiToast::QueueNotification(imageFile, usedHeader, message, displayTime, withSound, + messageTime); + } + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_general_h::kodi_get_digest_v1(void* thisClassHdl, + enum DigestType type, + const char* text) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + switch (type) + { + case DIGEST_MD5: + return strdup(CDigest::Calculate(CDigest::Type::MD5, text).c_str()); + case DIGEST_SHA1: + return strdup(CDigest::Calculate(CDigest::Type::SHA1, text).c_str()); + case DIGEST_SHA256: + return strdup(CDigest::Calculate(CDigest::Type::SHA256, text).c_str()); + case DIGEST_SHA512: + return strdup(CDigest::Calculate(CDigest::Type::SHA512, text).c_str()); + default: + return nullptr; + } + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_general_h::kodi_get_region_v1(void* thisClassHdl, const char* id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::shared_ptr addon = thisClass->m_process->GetAddon(); + + std::string result; + if (StringUtils::CompareNoCase(id, "datelong") == 0) + { + result = g_langInfo.GetDateFormat(true); + StringUtils::Replace(result, "DDDD", "%A"); + StringUtils::Replace(result, "MMMM", "%B"); + StringUtils::Replace(result, "D", "%d"); + StringUtils::Replace(result, "YYYY", "%Y"); + } + else if (StringUtils::CompareNoCase(id, "dateshort") == 0) + { + result = g_langInfo.GetDateFormat(false); + StringUtils::Replace(result, "MM", "%m"); + StringUtils::Replace(result, "DD", "%d"); +#ifdef TARGET_WINDOWS + StringUtils::Replace(result, "M", "%#m"); + StringUtils::Replace(result, "D", "%#d"); +#else + StringUtils::Replace(result, "M", "%-m"); + StringUtils::Replace(result, "D", "%-d"); +#endif + StringUtils::Replace(result, "YYYY", "%Y"); + } + else if (StringUtils::CompareNoCase(id, "tempunit") == 0) + result = g_langInfo.GetTemperatureUnitString(); + else if (StringUtils::CompareNoCase(id, "speedunit") == 0) + result = g_langInfo.GetSpeedUnitString(); + else if (StringUtils::CompareNoCase(id, "time") == 0) + { + result = g_langInfo.GetTimeFormat(); + StringUtils::Replace(result, "H", "%H"); + StringUtils::Replace(result, "h", "%I"); + StringUtils::Replace(result, "mm", "%M"); + StringUtils::Replace(result, "ss", "%S"); + StringUtils::Replace(result, "xx", "%p"); + } + else if (StringUtils::CompareNoCase(id, "meridiem") == 0) + result = StringUtils::Format("%s/%s", g_langInfo.GetMeridiemSymbol(MeridiemSymbolAM).c_str(), + g_langInfo.GetMeridiemSymbol(MeridiemSymbolPM).c_str()); + else + { + CLog::Log(LOGERROR, "Interface_General::{} - add-on '{}' requests invalid id '{}'", __func__, + addon->Name(), id); + return nullptr; + } + + char* buffer = strdup(result.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_general_h::kodi_get_global_idle_time_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return g_application.GlobalIdleTime(); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_general_h::kodi_is_addon_avilable_v1(void* thisClassHdl, + const char* id, + char** version, + bool* enabled) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + AddonPtr addonInfo; + if (!CServiceBroker::GetAddonMgr().GetAddon(id, addonInfo, ADDON_UNKNOWN, OnlyEnabled::CHOICE_NO)) + return false; + + *version = strdup(addonInfo->Version().asString().c_str()); + *enabled = !CServiceBroker::GetAddonMgr().IsAddonDisabled(id); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_general_h::kodi_version_v1(void* thisClassHdl, + char** compile_name, + int* major, + int* minor, + char** revision, + char** tag, + char** tagversion) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + *compile_name = strdup(CCompileInfo::GetAppName()); + *major = CCompileInfo::GetMajor(); + *minor = CCompileInfo::GetMinor(); + *revision = strdup(CCompileInfo::GetSCMID()); + std::string tagStr = CCompileInfo::GetSuffix(); + if (StringUtils::StartsWithNoCase(tagStr, "alpha")) + { + *tag = strdup("alpha"); + *tagversion = strdup(StringUtils::Mid(tagStr, 5).c_str()); + } + else if (StringUtils::StartsWithNoCase(tagStr, "beta")) + { + *tag = strdup("beta"); + *tagversion = strdup(StringUtils::Mid(tagStr, 4).c_str()); + } + else if (StringUtils::StartsWithNoCase(tagStr, "rc")) + { + *tag = strdup("releasecandidate"); + *tagversion = strdup(StringUtils::Mid(tagStr, 2).c_str()); + } + else if (tagStr.empty()) + *tag = strdup("stable"); + else + *tag = strdup("prealpha"); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_general_h::kodi_get_current_skin_id_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(CServiceBroker::GetSettingsComponent() + ->GetSettings() + ->GetString(CSettings::SETTING_LOOKANDFEEL_SKIN) + .c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_general_h::kodi_get_keyboard_layout_v1(void* thisClassHdl, + int modifier_key, + char** layout_name, + struct AddonKeyboardKeyTable* layout) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + const std::string activeLayout = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString( + CSettings::SETTING_LOCALE_ACTIVEKEYBOARDLAYOUT); + + CKeyboardLayout cpp_layout; + if (!CServiceBroker::GetKeyboardLayoutManager()->GetLayout(activeLayout, cpp_layout)) + return false; + + *layout_name = strdup(cpp_layout.GetName().c_str()); + + unsigned int modifiers = CKeyboardLayout::ModifierKeyNone; + if (modifier_key & STD_KB_MODIFIER_KEY_SHIFT) + modifiers |= CKeyboardLayout::ModifierKeyShift; + if (modifier_key & STD_KB_MODIFIER_KEY_SYMBOL) + modifiers |= CKeyboardLayout::ModifierKeySymbol; + + for (unsigned int row = 0; row < STD_KB_BUTTONS_MAX_ROWS; row++) + { + for (unsigned int column = 0; column < STD_KB_BUTTONS_PER_ROW; column++) + { + std::string label = cpp_layout.GetCharAt(row, column, modifiers); + layout->keys[row][column] = strdup(label.c_str()); + } + } + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_general_h::kodi_change_keyboard_layout_v1(void* thisClassHdl, char** layout_name) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::vector layouts; + unsigned int currentLayout = 0; + + const KeyboardLayouts& keyboardLayouts = CServiceBroker::GetKeyboardLayoutManager()->GetLayouts(); + const std::shared_ptr settings = CServiceBroker::GetSettingsComponent()->GetSettings(); + const std::vector layoutNames = + settings->GetList(CSettings::SETTING_LOCALE_KEYBOARDLAYOUTS); + const std::string activeLayout = + settings->GetString(CSettings::SETTING_LOCALE_ACTIVEKEYBOARDLAYOUT); + + for (const auto& layoutName : layoutNames) + { + const auto keyboardLayout = keyboardLayouts.find(layoutName.asString()); + if (keyboardLayout != keyboardLayouts.end()) + { + layouts.emplace_back(keyboardLayout->second); + if (layoutName.asString() == activeLayout) + currentLayout = layouts.size() - 1; + } + } + + currentLayout++; + if (currentLayout >= layouts.size()) + currentLayout = 0; + CKeyboardLayout layout = layouts.empty() ? CKeyboardLayout() : layouts[currentLayout]; + CServiceBroker::GetSettingsComponent()->GetSettings()->SetString( + CSettings::SETTING_LOCALE_ACTIVEKEYBOARDLAYOUT, layout.GetName()); + + *layout_name = strdup(layout.GetName().c_str()); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_general_h::kodi_play_sfx_v1(void* thisClassHdl, + const char* filename, + bool use_cached) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIComponent* gui = CServiceBroker::GetGUI(); + if (XFILE::CFile::Exists(filename) && gui) + { + gui->GetAudioManager().PlayPythonSound(filename, use_cached); + } + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_general_h::kodi_stop_sfx_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIComponent* gui = CServiceBroker::GetGUI(); + if (gui) + gui->GetAudioManager().Stop(); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/general.h b/xbmc/addons/interface/api/general.h new file mode 100644 index 0000000000000..a3d64146a7c15 --- /dev/null +++ b/xbmc/addons/interface/api/general.h @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/general.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_general_h; +struct directFuncToKodi_general_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_general_h : public IMsgHdl +{ +public: + CHdl_kodi_general_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_general_h* ifcToKodi, directFuncToAddon_general_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static char* kodi_get_localized_string_v1(void* thisClassHdl, long label_id); // Added with API 1 + + static void kodi_get_free_mem_v1(void* thisClassHdl, + long* free, + long* total, + bool as_bytes); // Added with API 1 + + static char* kodi_unknown_to_utf8_v1(void* thisClassHdl, + const char* source, + bool* ret, + bool failOnBadChar); // Added with API 1 + + static char* kodi_get_language_v1(void* thisClassHdl, + enum LangFormats format, + bool region); // Added with API 1 + + static void kodi_queue_notification_v1(void* thisClassHdl, + enum QueueMsg type, + const char* header, + const char* message, + const char* imageFile, + unsigned int displayTime, + bool withSound, + unsigned int messageTime); // Added with API 1 + + static char* kodi_get_digest_v1(void* thisClassHdl, + enum DigestType type, + const char* text); // Added with API 1 + + static char* kodi_get_region_v1(void* thisClassHdl, const char* id); // Added with API 1 + + static int kodi_get_global_idle_time_v1(void* thisClassHdl); // Added with API 1 + + static bool kodi_is_addon_avilable_v1(void* thisClassHdl, + const char* id, + char** version, + bool* enabled); // Added with API 1 + + static void kodi_version_v1(void* thisClassHdl, + char** compile_name, + int* major, + int* minor, + char** revision, + char** tag, + char** tagversion); // Added with API 1 + + static char* kodi_get_current_skin_id_v1(void* thisClassHdl); // Added with API 1 + + static bool kodi_get_keyboard_layout_v1(void* thisClassHdl, + int modifier_key, + char** layout_name, + struct AddonKeyboardKeyTable* layout); // Added with API 1 + + static bool kodi_change_keyboard_layout_v1(void* thisClassHdl, + char** layout_name); // Added with API 1 + + static void kodi_play_sfx_v1(void* thisClassHdl, + const char* filename, + bool use_cached); // Added with API 1 + + static void kodi_stop_sfx_v1(void* thisClassHdl); // Added with API 1 + + directFuncToAddon_general_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/CMakeLists.txt b/xbmc/addons/interface/api/gui/CMakeLists.txt new file mode 100644 index 0000000000000..538bef501aa22 --- /dev/null +++ b/xbmc/addons/interface/api/gui/CMakeLists.txt @@ -0,0 +1,18 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + general.cpp + list_item.cpp + window.cpp +) + +set(HEADERS + general.h + list_item.h + window.h +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface_api_gui) +endif() diff --git a/xbmc/addons/interface/api/gui/controls/CMakeLists.txt b/xbmc/addons/interface/api/gui/controls/CMakeLists.txt new file mode 100644 index 0000000000000..8f37c9634ea06 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/CMakeLists.txt @@ -0,0 +1,36 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + button.cpp + edit.cpp + fade_label.cpp + image.cpp + label.cpp + progress.cpp + radio_button.cpp + rendering.cpp + settings_slider.cpp + slider.cpp + spin.cpp + text_box.cpp +) + +set(HEADERS + button.h + edit.h + fade_label.h + image.h + label.h + progress.h + radio_button.h + rendering.h + settings_slider.h + slider.h + spin.h + text_box.h +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface_api_gui_controls) +endif() diff --git a/xbmc/addons/interface/api/gui/controls/button.cpp b/xbmc/addons/interface/api/gui/controls/button.cpp new file mode 100644 index 0000000000000..4576acf7fa7c9 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/button.cpp @@ -0,0 +1,240 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "button.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/button.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIButtonControl.h" +#include "utils/StringUtils.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_button_h::InitDirect( + directFuncToKodi_gui_controls_button_h* ifcToKodi, + directFuncToAddon_gui_controls_button_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_button_set_visible_v1 = kodi_gui_controls_button_set_visible_v1; + ifcToKodi->kodi_gui_controls_button_set_enabled_v1 = kodi_gui_controls_button_set_enabled_v1; + ifcToKodi->kodi_gui_controls_button_set_label_v1 = kodi_gui_controls_button_set_label_v1; + ifcToKodi->kodi_gui_controls_button_get_label_v1 = kodi_gui_controls_button_get_label_v1; + ifcToKodi->kodi_gui_controls_button_set_label2_v1 = kodi_gui_controls_button_set_label2_v1; + ifcToKodi->kodi_gui_controls_button_get_label2_v1 = kodi_gui_controls_button_get_label2_v1; +} + +bool CHdl_kodi_gui_controls_button_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_button_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_button_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_button_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_button_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_button_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_button_set_enabled_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_button_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_set_enabled_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_button_set_enabled_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool enabled = std::get<1>(t); + kodi_gui_controls_button_set_enabled_v1(this, handle, enabled); + return true; + } + case funcParent_kodi_gui_controls_button_set_label_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_button_set_label(KODI_GUI_CONTROL_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_set_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_set_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_button_set_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& label = std::get<1>(t); + kodi_gui_controls_button_set_label_v1(this, handle, label.c_str()); + return true; + } + case funcParent_kodi_gui_controls_button_get_label_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_button_get_label(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_get_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_button_get_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_controls_button_get_label_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_button_get_label_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_controls_button_set_label2_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_button_set_label2(KODI_GUI_CONTROL_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_set_label2_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_set_label2_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_button_set_label2_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& label = std::get<1>(t); + kodi_gui_controls_button_set_label2_v1(this, handle, label.c_str()); + return true; + } + case funcParent_kodi_gui_controls_button_get_label2_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_button_get_label2(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_get_label2_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_get_label2_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_button_get_label2_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_controls_button_get_label2_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_button_get_label2_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_button_h::{}: addon called with unknown function id '{}' " + "on group 'gui_controls_button_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_button_h::kodi_gui_controls_button_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_button_h::kodi_gui_controls_button_set_enabled_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool enabled) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetEnabled(enabled); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_button_h::kodi_gui_controls_button_set_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* label) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetLabel(label); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_controls_button_h::kodi_gui_controls_button_get_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(static_cast(handle)->GetLabel().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_button_h::kodi_gui_controls_button_set_label2_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* label) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetLabel2(label); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_controls_button_h::kodi_gui_controls_button_get_label2_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(static_cast(handle)->GetLabel2().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/button.h b/xbmc/addons/interface/api/gui/controls/button.h new file mode 100644 index 0000000000000..9fec4825aa857 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/button.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/button.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_button_h; +struct directFuncToKodi_gui_controls_button_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_button_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_button_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_button_h* ifcToKodi, + directFuncToAddon_gui_controls_button_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_button_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_button_set_enabled_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool enabled); // Added with API 1 + + static void kodi_gui_controls_button_set_label_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* label); // Added with API 1 + + static char* kodi_gui_controls_button_get_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_button_set_label2_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* label); // Added with API 1 + + static char* kodi_gui_controls_button_get_label2_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + directFuncToAddon_gui_controls_button_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/edit.cpp b/xbmc/addons/interface/api/gui/controls/edit.cpp new file mode 100644 index 0000000000000..c8b512fd7b724 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/edit.cpp @@ -0,0 +1,358 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "edit.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/edit.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIEditControl.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_edit_h::InitDirect(directFuncToKodi_gui_controls_edit_h* ifcToKodi, + directFuncToAddon_gui_controls_edit_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_edit_set_visible_v1 = kodi_gui_controls_edit_set_visible_v1; + ifcToKodi->kodi_gui_controls_edit_set_enabled_v1 = kodi_gui_controls_edit_set_enabled_v1; + ifcToKodi->kodi_gui_controls_edit_set_label_v1 = kodi_gui_controls_edit_set_label_v1; + ifcToKodi->kodi_gui_controls_edit_get_label_v1 = kodi_gui_controls_edit_get_label_v1; + ifcToKodi->kodi_gui_controls_edit_set_text_v1 = kodi_gui_controls_edit_set_text_v1; + ifcToKodi->kodi_gui_controls_edit_get_text_v1 = kodi_gui_controls_edit_get_text_v1; + ifcToKodi->kodi_gui_controls_edit_set_cursor_position_v1 = + kodi_gui_controls_edit_set_cursor_position_v1; + ifcToKodi->kodi_gui_controls_edit_get_cursor_position_v1 = + kodi_gui_controls_edit_get_cursor_position_v1; + ifcToKodi->kodi_gui_controls_edit_set_input_type_v1 = kodi_gui_controls_edit_set_input_type_v1; +} + +bool CHdl_kodi_gui_controls_edit_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_edit_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_edit_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_edit_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_edit_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_edit_set_enabled_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_enabled_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_edit_set_enabled_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool enabled = std::get<1>(t); + kodi_gui_controls_edit_set_enabled_v1(this, handle, enabled); + return true; + } + case funcParent_kodi_gui_controls_edit_set_label_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_label(KODI_GUI_CONTROL_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_edit_set_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& label = std::get<1>(t); + kodi_gui_controls_edit_set_label_v1(this, handle, label.c_str()); + return true; + } + case funcParent_kodi_gui_controls_edit_get_label_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_edit_get_label(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_get_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_edit_get_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_controls_edit_get_label_v1(this, handle); + msgpack::pack( + out, msgParent_OUT_kodi_gui_controls_edit_get_label_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_controls_edit_set_text_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_text(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_edit_set_text_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& text = std::get<1>(t); + kodi_gui_controls_edit_set_text_v1(this, handle, text.c_str()); + return true; + } + case funcParent_kodi_gui_controls_edit_get_text_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_edit_get_text(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_get_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_get_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_edit_get_text_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_controls_edit_get_text_v1(this, handle); + msgpack::pack( + out, msgParent_OUT_kodi_gui_controls_edit_get_text_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_controls_edit_set_cursor_position_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_cursor_position(KODI_GUI_CONTROL_HANDLE handle, unsigned int position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_cursor_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_cursor_position_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_edit_set_cursor_position_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + unsigned int position = std::get<1>(t); + kodi_gui_controls_edit_set_cursor_position_v1(this, handle, position); + return true; + } + case funcParent_kodi_gui_controls_edit_get_cursor_position_v1: + { + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_gui_controls_edit_get_cursor_position( KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_get_cursor_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_get_cursor_position_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_edit_get_cursor_position_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + unsigned int auto_gen_ret = kodi_gui_controls_edit_get_cursor_position_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_edit_get_cursor_position_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_controls_edit_set_input_type_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_input_type(KODI_GUI_CONTROL_HANDLE handle, int type, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_input_type_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_input_type_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_edit_set_input_type_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int type = std::get<1>(t); + const std::string& heading = std::get<2>(t); + kodi_gui_controls_edit_set_input_type_v1(this, handle, type, heading.c_str()); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_edit_h::{}: addon called with unknown function id '{}' on " + "group 'gui_controls_edit_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_edit_h::kodi_gui_controls_edit_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_edit_h::kodi_gui_controls_edit_set_enabled_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool enabled) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetEnabled(enabled); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_edit_h::kodi_gui_controls_edit_set_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* label) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetLabel(label); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_controls_edit_h::kodi_gui_controls_edit_get_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(static_cast(handle)->GetLabel().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_edit_h::kodi_gui_controls_edit_set_text_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* text) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetLabel2(text); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_controls_edit_h::kodi_gui_controls_edit_get_text_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(static_cast(handle)->GetLabel2().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_edit_h::kodi_gui_controls_edit_set_cursor_position_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, unsigned int position) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetCursorPosition(position); + + /*---AUTO_GEN_PARSE---*/ +} + +unsigned int CHdl_kodi_gui_controls_edit_h::kodi_gui_controls_edit_get_cursor_position_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetCursorPosition(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_edit_h::kodi_gui_controls_edit_set_input_type_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int type, const char* heading) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIEditControl::INPUT_TYPE kodiType; + switch (static_cast(type)) + { + case ADDON_INPUT_TYPE_TEXT: + kodiType = CGUIEditControl::INPUT_TYPE_TEXT; + break; + case ADDON_INPUT_TYPE_NUMBER: + kodiType = CGUIEditControl::INPUT_TYPE_NUMBER; + break; + case ADDON_INPUT_TYPE_SECONDS: + kodiType = CGUIEditControl::INPUT_TYPE_SECONDS; + break; + case ADDON_INPUT_TYPE_TIME: + kodiType = CGUIEditControl::INPUT_TYPE_TIME; + break; + case ADDON_INPUT_TYPE_DATE: + kodiType = CGUIEditControl::INPUT_TYPE_DATE; + break; + case ADDON_INPUT_TYPE_IPADDRESS: + kodiType = CGUIEditControl::INPUT_TYPE_IPADDRESS; + break; + case ADDON_INPUT_TYPE_PASSWORD: + kodiType = CGUIEditControl::INPUT_TYPE_PASSWORD; + break; + case ADDON_INPUT_TYPE_PASSWORD_MD5: + kodiType = CGUIEditControl::INPUT_TYPE_PASSWORD_MD5; + break; + case ADDON_INPUT_TYPE_SEARCH: + kodiType = CGUIEditControl::INPUT_TYPE_SEARCH; + break; + case ADDON_INPUT_TYPE_FILTER: + kodiType = CGUIEditControl::INPUT_TYPE_FILTER; + break; + case ADDON_INPUT_TYPE_READONLY: + default: + kodiType = CGUIEditControl::INPUT_TYPE_PASSWORD_NUMBER_VERIFY_NEW; + } + + static_cast(handle)->SetInputType(kodiType, heading); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/edit.h b/xbmc/addons/interface/api/gui/controls/edit.h new file mode 100644 index 0000000000000..62cfa6e41dbbb --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/edit.h @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/edit.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_edit_h; +struct directFuncToKodi_gui_controls_edit_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_edit_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_edit_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_edit_h* ifcToKodi, + directFuncToAddon_gui_controls_edit_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_edit_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_edit_set_enabled_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool enabled); // Added with API 1 + + static void kodi_gui_controls_edit_set_label_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* label); // Added with API 1 + + static char* kodi_gui_controls_edit_get_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_edit_set_text_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* text); // Added with API 1 + + static char* kodi_gui_controls_edit_get_text_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_edit_set_cursor_position_v1( + void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + unsigned int position); // Added with API 1 + + static unsigned int kodi_gui_controls_edit_get_cursor_position_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_edit_set_input_type_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int type, + const char* heading); // Added with API 1 + + directFuncToAddon_gui_controls_edit_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/fade_label.cpp b/xbmc/addons/interface/api/gui/controls/fade_label.cpp new file mode 100644 index 0000000000000..ff3caab5476a2 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/fade_label.cpp @@ -0,0 +1,221 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "fade_label.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/fade_label.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIFadeLabelControl.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_fade_label_h::InitDirect( + directFuncToKodi_gui_controls_fade_label_h* ifcToKodi, + directFuncToAddon_gui_controls_fade_label_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_fade_label_set_visible_v1 = + kodi_gui_controls_fade_label_set_visible_v1; + ifcToKodi->kodi_gui_controls_fade_label_add_label_v1 = kodi_gui_controls_fade_label_add_label_v1; + ifcToKodi->kodi_gui_controls_fade_label_get_label_v1 = kodi_gui_controls_fade_label_get_label_v1; + ifcToKodi->kodi_gui_controls_fade_label_set_scrolling_v1 = + kodi_gui_controls_fade_label_set_scrolling_v1; + ifcToKodi->kodi_gui_controls_fade_label_reset_v1 = kodi_gui_controls_fade_label_reset_v1; +} + +bool CHdl_kodi_gui_controls_fade_label_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_fade_label_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_fade_label_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_fade_label_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_fade_label_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_fade_label_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_fade_label_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_fade_label_add_label_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_add_label(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_fade_label_add_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_fade_label_add_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_fade_label_add_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& text = std::get<1>(t); + kodi_gui_controls_fade_label_add_label_v1(this, handle, text.c_str()); + return true; + } + case funcParent_kodi_gui_controls_fade_label_get_label_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_fade_label_get_label(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_fade_label_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_fade_label_get_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_fade_label_get_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_controls_fade_label_get_label_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_fade_label_get_label_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_controls_fade_label_set_scrolling_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_set_scrolling(KODI_GUI_CONTROL_HANDLE handle, bool scroll) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_fade_label_set_scrolling_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_fade_label_set_scrolling_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_fade_label_set_scrolling_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool scroll = std::get<1>(t); + kodi_gui_controls_fade_label_set_scrolling_v1(this, handle, scroll); + return true; + } + case funcParent_kodi_gui_controls_fade_label_reset_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_reset(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_fade_label_reset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_fade_label_reset_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_fade_label_reset_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_controls_fade_label_reset_v1(this, handle); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_fade_label_h::{}: addon called with unknown function id " + "'{}' on group 'gui_controls_fade_label_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_fade_label_h::kodi_gui_controls_fade_label_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_fade_label_h::kodi_gui_controls_fade_label_add_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* text) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIFadeLabelControl* control = static_cast(handle); + CGUIMessage msg(GUI_MSG_LABEL_ADD, control->GetParentID(), control->GetID()); + msg.SetLabel(text); + control->OnMessage(msg); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_controls_fade_label_h::kodi_gui_controls_fade_label_get_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CGUIFadeLabelControl* control = static_cast(handle); + CGUIMessage msg(GUI_MSG_ITEM_SELECTED, control->GetParentID(), control->GetID()); + control->OnMessage(msg); + std::string text = msg.GetLabel(); + return strdup(text.c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_fade_label_h::kodi_gui_controls_fade_label_set_scrolling_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool scroll) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetScrolling(scroll); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_fade_label_h::kodi_gui_controls_fade_label_reset_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIFadeLabelControl* control = static_cast(handle); + CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID()); + control->OnMessage(msg); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/fade_label.h b/xbmc/addons/interface/api/gui/controls/fade_label.h new file mode 100644 index 0000000000000..8d75a0bfe206c --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/fade_label.h @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/fade_label.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_fade_label_h; +struct directFuncToKodi_gui_controls_fade_label_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_fade_label_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_fade_label_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_fade_label_h* ifcToKodi, + directFuncToAddon_gui_controls_fade_label_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_fade_label_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_fade_label_add_label_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* text); // Added with API 1 + + static char* kodi_gui_controls_fade_label_get_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_fade_label_set_scrolling_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool scroll); // Added with API 1 + + static void kodi_gui_controls_fade_label_reset_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + directFuncToAddon_gui_controls_fade_label_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/image.cpp b/xbmc/addons/interface/api/gui/controls/image.cpp new file mode 100644 index 0000000000000..83cb6d1b6090c --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/image.cpp @@ -0,0 +1,156 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "image.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/image.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIImage.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_image_h::InitDirect(directFuncToKodi_gui_controls_image_h* ifcToKodi, + directFuncToAddon_gui_controls_image_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_image_set_visible_v1 = kodi_gui_controls_image_set_visible_v1; + ifcToKodi->kodi_gui_controls_image_set_filename_v1 = kodi_gui_controls_image_set_filename_v1; + ifcToKodi->kodi_gui_controls_image_set_color_diffuse_v1 = + kodi_gui_controls_image_set_color_diffuse_v1; +} + +bool CHdl_kodi_gui_controls_image_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_image_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_image_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_image_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_image_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_image_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_image_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_image_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_image_set_filename_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_image_set_filename(KODI_GUI_CONTROL_HANDLE handle, const char* filename, bool use_cache) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_image_set_filename_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_image_set_filename_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_image_set_filename_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& filename = std::get<1>(t); + bool use_cache = std::get<2>(t); + kodi_gui_controls_image_set_filename_v1(this, handle, filename.c_str(), use_cache); + return true; + } + case funcParent_kodi_gui_controls_image_set_color_diffuse_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_image_set_color_diffuse(KODI_GUI_CONTROL_HANDLE handle, uint32_t color_diffuse) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_image_set_color_diffuse_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_image_set_color_diffuse_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_image_set_color_diffuse_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + uint32_t color_diffuse = std::get<1>(t); + kodi_gui_controls_image_set_color_diffuse_v1(this, handle, color_diffuse); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_image_h::{}: addon called with unknown function id '{}' on " + "group 'gui_controls_image_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_image_h::kodi_gui_controls_image_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_image_h::kodi_gui_controls_image_set_filename_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* filename, bool use_cache) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetFileName(filename, false, use_cache); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_image_h::kodi_gui_controls_image_set_color_diffuse_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, uint32_t color_diffuse) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetColorDiffuse(GUILIB::GUIINFO::CGUIInfoColor(color_diffuse)); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/image.h b/xbmc/addons/interface/api/gui/controls/image.h new file mode 100644 index 0000000000000..b7be5e6587171 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/image.h @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/image.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_image_h; +struct directFuncToKodi_gui_controls_image_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_image_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_image_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_image_h* ifcToKodi, + directFuncToAddon_gui_controls_image_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_image_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_image_set_filename_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* filename, + bool use_cache); // Added with API 1 + + static void kodi_gui_controls_image_set_color_diffuse_v1( + void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + uint32_t color_diffuse); // Added with API 1 + + directFuncToAddon_gui_controls_image_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/label.cpp b/xbmc/addons/interface/api/gui/controls/label.cpp new file mode 100644 index 0000000000000..e6f031d0b2585 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/label.cpp @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "label.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/label.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIComponent.h" +#include "guilib/GUILabelControl.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_label_h::InitDirect(directFuncToKodi_gui_controls_label_h* ifcToKodi, + directFuncToAddon_gui_controls_label_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_label_set_visible_v1 = kodi_gui_controls_label_set_visible_v1; + ifcToKodi->kodi_gui_controls_label_set_label_v1 = kodi_gui_controls_label_set_label_v1; + ifcToKodi->kodi_gui_controls_label_get_label_v1 = kodi_gui_controls_label_get_label_v1; +} + +bool CHdl_kodi_gui_controls_label_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_label_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_label_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_label_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_label_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_label_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_label_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_label_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_label_set_label_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_label_set_label(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_label_set_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_label_set_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_label_set_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& text = std::get<1>(t); + kodi_gui_controls_label_set_label_v1(this, handle, text.c_str()); + return true; + } + case funcParent_kodi_gui_controls_label_get_label_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_label_get_label(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_label_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_label_get_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_label_get_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_controls_label_get_label_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_label_get_label_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_label_h::{}: addon called with unknown function id '{}' on " + "group 'gui_controls_label_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_label_h::kodi_gui_controls_label_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_label_h::kodi_gui_controls_label_set_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* text) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUILabelControl* control = static_cast(handle); + CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID()); + msg.SetLabel(text); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_controls_label_h::kodi_gui_controls_label_get_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(static_cast(handle)->GetDescription().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/label.h b/xbmc/addons/interface/api/gui/controls/label.h new file mode 100644 index 0000000000000..aec223b609cfe --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/label.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/label.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_label_h; +struct directFuncToKodi_gui_controls_label_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_label_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_label_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_label_h* ifcToKodi, + directFuncToAddon_gui_controls_label_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_label_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_label_set_label_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* text); // Added with API 1 + + static char* kodi_gui_controls_label_get_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + directFuncToAddon_gui_controls_label_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/progress.cpp b/xbmc/addons/interface/api/gui/controls/progress.cpp new file mode 100644 index 0000000000000..4c431128280c0 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/progress.cpp @@ -0,0 +1,158 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "progress.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/progress.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIProgressControl.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_progress_h::InitDirect( + directFuncToKodi_gui_controls_progress_h* ifcToKodi, + directFuncToAddon_gui_controls_progress_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_progress_set_visible_v1 = kodi_gui_controls_progress_set_visible_v1; + ifcToKodi->kodi_gui_controls_progress_set_percentage_v1 = + kodi_gui_controls_progress_set_percentage_v1; + ifcToKodi->kodi_gui_controls_progress_get_percentage_v1 = + kodi_gui_controls_progress_get_percentage_v1; +} + +bool CHdl_kodi_gui_controls_progress_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_progress_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_progress_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_progress_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_progress_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_progress_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_progress_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_progress_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_progress_set_percentage_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_progress_set_percentage(KODI_GUI_CONTROL_HANDLE handle, float percent) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_progress_set_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_progress_set_percentage_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_progress_set_percentage_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float percent = std::get<1>(t); + kodi_gui_controls_progress_set_percentage_v1(this, handle, percent); + return true; + } + case funcParent_kodi_gui_controls_progress_get_percentage_v1: + { + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_progress_get_percentage(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_progress_get_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_progress_get_percentage_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_progress_get_percentage_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float auto_gen_ret = kodi_gui_controls_progress_get_percentage_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_progress_get_percentage_v1(auto_gen_ret)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_progress_h::{}: addon called with unknown function id '{}' " + "on group 'gui_controls_progress_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_progress_h::kodi_gui_controls_progress_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_progress_h::kodi_gui_controls_progress_set_percentage_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float percent) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetPercentage(percent); + + /*---AUTO_GEN_PARSE---*/ +} + +float CHdl_kodi_gui_controls_progress_h::kodi_gui_controls_progress_get_percentage_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0f; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetPercentage(); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/progress.h b/xbmc/addons/interface/api/gui/controls/progress.h new file mode 100644 index 0000000000000..f65961635fc4a --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/progress.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/progress.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_progress_h; +struct directFuncToKodi_gui_controls_progress_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_progress_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_progress_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_progress_h* ifcToKodi, + directFuncToAddon_gui_controls_progress_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_progress_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_progress_set_percentage_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float percent); // Added with API 1 + + static float kodi_gui_controls_progress_get_percentage_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + directFuncToAddon_gui_controls_progress_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/radio_button.cpp b/xbmc/addons/interface/api/gui/controls/radio_button.cpp new file mode 100644 index 0000000000000..90dfeacfe338d --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/radio_button.cpp @@ -0,0 +1,242 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "radio_button.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/radio_button.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIRadioButtonControl.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_radio_button_h::InitDirect( + directFuncToKodi_gui_controls_radio_button_h* ifcToKodi, + directFuncToAddon_gui_controls_radio_button_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_radio_button_set_visible_v1 = + kodi_gui_controls_radio_button_set_visible_v1; + ifcToKodi->kodi_gui_controls_radio_button_set_enabled_v1 = + kodi_gui_controls_radio_button_set_enabled_v1; + ifcToKodi->kodi_gui_controls_radio_button_set_label_v1 = + kodi_gui_controls_radio_button_set_label_v1; + ifcToKodi->kodi_gui_controls_radio_button_get_label_v1 = + kodi_gui_controls_radio_button_get_label_v1; + ifcToKodi->kodi_gui_controls_radio_button_set_selected_v1 = + kodi_gui_controls_radio_button_set_selected_v1; + ifcToKodi->kodi_gui_controls_radio_button_is_selected_v1 = + kodi_gui_controls_radio_button_is_selected_v1; +} + +bool CHdl_kodi_gui_controls_radio_button_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_radio_button_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_radio_button_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_radio_button_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_radio_button_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_radio_button_set_enabled_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_set_enabled_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_radio_button_set_enabled_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool enabled = std::get<1>(t); + kodi_gui_controls_radio_button_set_enabled_v1(this, handle, enabled); + return true; + } + case funcParent_kodi_gui_controls_radio_button_set_label_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_label(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_set_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_set_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_radio_button_set_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& text = std::get<1>(t); + kodi_gui_controls_radio_button_set_label_v1(this, handle, text.c_str()); + return true; + } + case funcParent_kodi_gui_controls_radio_button_get_label_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_radio_button_get_label(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_get_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_radio_button_get_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_controls_radio_button_get_label_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_radio_button_get_label_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_controls_radio_button_set_selected_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_selected(KODI_GUI_CONTROL_HANDLE handle, bool selected) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_set_selected_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_set_selected_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_radio_button_set_selected_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool selected = std::get<1>(t); + kodi_gui_controls_radio_button_set_selected_v1(this, handle, selected); + return true; + } + case funcParent_kodi_gui_controls_radio_button_is_selected_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_controls_radio_button_is_selected(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_is_selected_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_is_selected_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_radio_button_is_selected_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_gui_controls_radio_button_is_selected_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_radio_button_is_selected_v1(auto_gen_ret)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_radio_button_h::{}: addon called with unknown function id " + "'{}' on group 'gui_controls_radio_button_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_radio_button_h::kodi_gui_controls_radio_button_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_radio_button_h::kodi_gui_controls_radio_button_set_enabled_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool enabled) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetEnabled(enabled); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_radio_button_h::kodi_gui_controls_radio_button_set_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* text) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetLabel(text); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_controls_radio_button_h::kodi_gui_controls_radio_button_get_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(static_cast(handle)->GetLabel().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_radio_button_h::kodi_gui_controls_radio_button_set_selected_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool selected) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetSelected(selected); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_controls_radio_button_h::kodi_gui_controls_radio_button_is_selected_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->IsSelected(); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/radio_button.h b/xbmc/addons/interface/api/gui/controls/radio_button.h new file mode 100644 index 0000000000000..96faeaad98e46 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/radio_button.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/radio_button.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_radio_button_h; +struct directFuncToKodi_gui_controls_radio_button_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_radio_button_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_radio_button_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_radio_button_h* ifcToKodi, + directFuncToAddon_gui_controls_radio_button_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_radio_button_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_radio_button_set_enabled_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool enabled); // Added with API 1 + + static void kodi_gui_controls_radio_button_set_label_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* text); // Added with API 1 + + static char* kodi_gui_controls_radio_button_get_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_radio_button_set_selected_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool selected); // Added with API 1 + + static bool kodi_gui_controls_radio_button_is_selected_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + directFuncToAddon_gui_controls_radio_button_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/rendering.cpp b/xbmc/addons/interface/api/gui/controls/rendering.cpp new file mode 100644 index 0000000000000..fb0a145f3739a --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/rendering.cpp @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "rendering.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/rendering.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "addons/interface/api/gui/general.h" +#include "guilib/GUIRenderingControl.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_rendering_h::InitDirect( + directFuncToKodi_gui_controls_rendering_h* ifcToKodi, + directFuncToAddon_gui_controls_rendering_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_radio_rendering_destroy_v1 = + kodi_gui_controls_radio_rendering_destroy_v1; +} + +bool CHdl_kodi_gui_controls_rendering_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_rendering_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_radio_rendering_destroy_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_radio_rendering_destroy(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_rendering_destroy_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_rendering_destroy_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_radio_rendering_destroy_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_controls_radio_rendering_destroy_v1(this, handle); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_rendering_h::{}: addon called with unknown function id " + "'{}' on group 'gui_controls_rendering_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_rendering_h::kodi_gui_controls_radio_rendering_destroy_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CHdl_kodi_gui_general_h::lock(); + // static_cast(handle)->Delete(); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/rendering.h b/xbmc/addons/interface/api/gui/controls/rendering.h new file mode 100644 index 0000000000000..4543ffd2f4c1b --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/rendering.h @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/rendering.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_rendering_h; +struct directFuncToKodi_gui_controls_rendering_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_rendering_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_rendering_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_rendering_h* ifcToKodi, + directFuncToAddon_gui_controls_rendering_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_radio_rendering_destroy_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + directFuncToAddon_gui_controls_rendering_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/settings_slider.cpp b/xbmc/addons/interface/api/gui/controls/settings_slider.cpp new file mode 100644 index 0000000000000..acd26c66adc1c --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/settings_slider.cpp @@ -0,0 +1,491 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "settings_slider.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/settings_slider.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIComponent.h" +#include "guilib/GUISettingsSliderControl.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_settings_slider_h::InitDirect( + directFuncToKodi_gui_controls_settings_slider_h* ifcToKodi, + directFuncToAddon_gui_controls_settings_slider_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_settings_slider_set_visible_v1 = + kodi_gui_controls_settings_slider_set_visible_v1; + ifcToKodi->kodi_gui_controls_settings_slider_set_enabled_v1 = + kodi_gui_controls_settings_slider_set_enabled_v1; + ifcToKodi->kodi_gui_controls_settings_slider_set_text_v1 = + kodi_gui_controls_settings_slider_set_text_v1; + ifcToKodi->kodi_gui_controls_settings_slider_reset_v1 = + kodi_gui_controls_settings_slider_reset_v1; + ifcToKodi->kodi_gui_controls_settings_slider_set_int_range_v1 = + kodi_gui_controls_settings_slider_set_int_range_v1; + ifcToKodi->kodi_gui_controls_settings_slider_set_int_value_v1 = + kodi_gui_controls_settings_slider_set_int_value_v1; + ifcToKodi->kodi_gui_controls_settings_slider_get_int_value_v1 = + kodi_gui_controls_settings_slider_get_int_value_v1; + ifcToKodi->kodi_gui_controls_settings_slider_set_int_interval_v1 = + kodi_gui_controls_settings_slider_set_int_interval_v1; + ifcToKodi->kodi_gui_controls_settings_slider_set_percentage_v1 = + kodi_gui_controls_settings_slider_set_percentage_v1; + ifcToKodi->kodi_gui_controls_settings_slider_get_percentage_v1 = + kodi_gui_controls_settings_slider_get_percentage_v1; + ifcToKodi->kodi_gui_controls_settings_slider_set_float_range_v1 = + kodi_gui_controls_settings_slider_set_float_range_v1; + ifcToKodi->kodi_gui_controls_settings_slider_set_float_value_v1 = + kodi_gui_controls_settings_slider_set_float_value_v1; + ifcToKodi->kodi_gui_controls_settings_slider_get_float_value_v1 = + kodi_gui_controls_settings_slider_get_float_value_v1; + ifcToKodi->kodi_gui_controls_settings_slider_set_float_interval_v1 = + kodi_gui_controls_settings_slider_set_float_interval_v1; +} + +bool CHdl_kodi_gui_controls_settings_slider_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_settings_slider_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_settings_slider_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_settings_slider_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_set_enabled_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_enabled_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_set_enabled_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool enabled = std::get<1>(t); + kodi_gui_controls_settings_slider_set_enabled_v1(this, handle, enabled); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_set_text_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_text(KODI_GUI_CONTROL_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_set_text_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& label = std::get<1>(t); + kodi_gui_controls_settings_slider_set_text_v1(this, handle, label.c_str()); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_reset_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_reset(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_reset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_reset_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_reset_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_controls_settings_slider_reset_v1(this, handle); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_set_int_range_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_range( KODI_GUI_CONTROL_HANDLE handle, int start, int end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_int_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_int_range_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_set_int_range_v1 t = + in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int start = std::get<1>(t); + int end = std::get<2>(t); + kodi_gui_controls_settings_slider_set_int_range_v1(this, handle, start, end); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_set_int_value_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_value( KODI_GUI_CONTROL_HANDLE handle, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_int_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_set_int_value_v1 t = + in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int value = std::get<1>(t); + kodi_gui_controls_settings_slider_set_int_value_v1(this, handle, value); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_get_int_value_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_controls_settings_slider_get_int_value( KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_get_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_get_int_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_get_int_value_v1 t = + in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_gui_controls_settings_slider_get_int_value_v1(this, handle); + msgpack::pack(out, + msgParent_OUT_kodi_gui_controls_settings_slider_get_int_value_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_set_int_interval_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_interval( KODI_GUI_CONTROL_HANDLE handle, int interval) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_int_interval_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_int_interval_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_set_int_interval_v1 t = + in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int interval = std::get<1>(t); + kodi_gui_controls_settings_slider_set_int_interval_v1(this, handle, interval); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_set_percentage_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_percentage( KODI_GUI_CONTROL_HANDLE handle, float percent) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_percentage_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_set_percentage_v1 t = + in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float percent = std::get<1>(t); + kodi_gui_controls_settings_slider_set_percentage_v1(this, handle, percent); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_get_percentage_v1: + { + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_settings_slider_get_percentage( KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_get_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_get_percentage_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_get_percentage_v1 t = + in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float auto_gen_ret = kodi_gui_controls_settings_slider_get_percentage_v1(this, handle); + msgpack::pack( + out, msgParent_OUT_kodi_gui_controls_settings_slider_get_percentage_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_set_float_range_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_range( KODI_GUI_CONTROL_HANDLE handle, float start, float end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_float_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_float_range_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_set_float_range_v1 t = + in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float start = std::get<1>(t); + float end = std::get<2>(t); + kodi_gui_controls_settings_slider_set_float_range_v1(this, handle, start, end); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_set_float_value_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_value( KODI_GUI_CONTROL_HANDLE handle, float value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_float_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_set_float_value_v1 t = + in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float value = std::get<1>(t); + kodi_gui_controls_settings_slider_set_float_value_v1(this, handle, value); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_get_float_value_v1: + { + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_settings_slider_get_float_value( KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_get_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_get_float_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_get_float_value_v1 t = + in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float auto_gen_ret = kodi_gui_controls_settings_slider_get_float_value_v1(this, handle); + msgpack::pack( + out, msgParent_OUT_kodi_gui_controls_settings_slider_get_float_value_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_controls_settings_slider_set_float_interval_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_interval( KODI_GUI_CONTROL_HANDLE handle, float interval) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_float_interval_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_float_interval_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_settings_slider_set_float_interval_v1 t = + in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float interval = std::get<1>(t); + kodi_gui_controls_settings_slider_set_float_interval_v1(this, handle, interval); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_settings_slider_h::{}: addon called with unknown function " + "id '{}' on group 'gui_controls_settings_slider_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_set_enabled_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool enabled) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetEnabled(enabled); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_set_text_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* label) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISettingsSliderControl* control = static_cast(handle); + CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID()); + msg.SetLabel(label); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_reset_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISettingsSliderControl* control = static_cast(handle); + CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID()); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_set_int_range_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int start, int end) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISettingsSliderControl* control = static_cast(handle); + control->SetType(SLIDER_CONTROL_TYPE_INT); + control->SetRange(start, end); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_set_int_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISettingsSliderControl* control = static_cast(handle); + control->SetType(SLIDER_CONTROL_TYPE_INT); + control->SetIntValue(value); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_get_int_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetIntValue(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_settings_slider_h:: + kodi_gui_controls_settings_slider_set_int_interval_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int interval) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetIntInterval(interval); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_set_percentage_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float percent) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISettingsSliderControl* control = static_cast(handle); + control->SetType(SLIDER_CONTROL_TYPE_PERCENTAGE); + control->SetPercentage(percent); + + /*---AUTO_GEN_PARSE---*/ +} + +float CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_get_percentage_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0f; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetPercentage(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_set_float_range_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float start, float end) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISettingsSliderControl* control = static_cast(handle); + control->SetType(SLIDER_CONTROL_TYPE_FLOAT); + control->SetFloatRange(start, end); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_settings_slider_h::kodi_gui_controls_settings_slider_set_float_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISettingsSliderControl* control = static_cast(handle); + control->SetType(SLIDER_CONTROL_TYPE_FLOAT); + control->SetFloatValue(value); + + /*---AUTO_GEN_PARSE---*/ +} + +float CHdl_kodi_gui_controls_settings_slider_h:: + kodi_gui_controls_settings_slider_get_float_value_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0f; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetFloatValue(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_settings_slider_h:: + kodi_gui_controls_settings_slider_set_float_interval_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float interval) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetFloatInterval(interval); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/settings_slider.h b/xbmc/addons/interface/api/gui/controls/settings_slider.h new file mode 100644 index 0000000000000..30fda3c86b299 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/settings_slider.h @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/settings_slider.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_settings_slider_h; +struct directFuncToKodi_gui_controls_settings_slider_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_settings_slider_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_settings_slider_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_settings_slider_h* ifcToKodi, + directFuncToAddon_gui_controls_settings_slider_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_settings_slider_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_settings_slider_set_enabled_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool enabled); // Added with API 1 + + static void kodi_gui_controls_settings_slider_set_text_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* label); // Added with API 1 + + static void kodi_gui_controls_settings_slider_reset_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_settings_slider_set_int_range_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int start, + int end); // Added with API 1 + + static void kodi_gui_controls_settings_slider_set_int_value_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int value); // Added with API 1 + + static int kodi_gui_controls_settings_slider_get_int_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_settings_slider_set_int_interval_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int interval); // Added with API 1 + + static void kodi_gui_controls_settings_slider_set_percentage_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float percent); // Added with API 1 + + static float kodi_gui_controls_settings_slider_get_percentage_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_settings_slider_set_float_range_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float start, + float end); // Added with API 1 + + static void kodi_gui_controls_settings_slider_set_float_value_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float value); // Added with API 1 + + static float kodi_gui_controls_settings_slider_get_float_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_settings_slider_set_float_interval_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float interval); // Added with API 1 + + directFuncToAddon_gui_controls_settings_slider_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/slider.cpp b/xbmc/addons/interface/api/gui/controls/slider.cpp new file mode 100644 index 0000000000000..d14bb0397cd5d --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/slider.cpp @@ -0,0 +1,467 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "slider.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/slider.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIComponent.h" +#include "guilib/GUISliderControl.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_slider_h::InitDirect( + directFuncToKodi_gui_controls_slider_h* ifcToKodi, + directFuncToAddon_gui_controls_slider_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_slider_set_visible_v1 = kodi_gui_controls_slider_set_visible_v1; + ifcToKodi->kodi_gui_controls_slider_set_enabled_v1 = kodi_gui_controls_slider_set_enabled_v1; + ifcToKodi->kodi_gui_controls_slider_reset_v1 = kodi_gui_controls_slider_reset_v1; + ifcToKodi->kodi_gui_controls_slider_get_description_v1 = + kodi_gui_controls_slider_get_description_v1; + ifcToKodi->kodi_gui_controls_slider_set_int_range_v1 = kodi_gui_controls_slider_set_int_range_v1; + ifcToKodi->kodi_gui_controls_slider_set_int_value_v1 = kodi_gui_controls_slider_set_int_value_v1; + ifcToKodi->kodi_gui_controls_slider_get_int_value_v1 = kodi_gui_controls_slider_get_int_value_v1; + ifcToKodi->kodi_gui_controls_slider_set_int_interval_v1 = + kodi_gui_controls_slider_set_int_interval_v1; + ifcToKodi->kodi_gui_controls_slider_set_percentage_v1 = + kodi_gui_controls_slider_set_percentage_v1; + ifcToKodi->kodi_gui_controls_slider_get_percentage_v1 = + kodi_gui_controls_slider_get_percentage_v1; + ifcToKodi->kodi_gui_controls_slider_set_float_range_v1 = + kodi_gui_controls_slider_set_float_range_v1; + ifcToKodi->kodi_gui_controls_slider_set_float_value_v1 = + kodi_gui_controls_slider_set_float_value_v1; + ifcToKodi->kodi_gui_controls_slider_get_float_value_v1 = + kodi_gui_controls_slider_get_float_value_v1; + ifcToKodi->kodi_gui_controls_slider_set_float_interval_v1 = + kodi_gui_controls_slider_set_float_interval_v1; +} + +bool CHdl_kodi_gui_controls_slider_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_slider_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_slider_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_slider_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_slider_set_enabled_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_enabled_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_set_enabled_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool enabled = std::get<1>(t); + kodi_gui_controls_slider_set_enabled_v1(this, handle, enabled); + return true; + } + case funcParent_kodi_gui_controls_slider_reset_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_reset(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_reset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_reset_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_reset_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_controls_slider_reset_v1(this, handle); + return true; + } + case funcParent_kodi_gui_controls_slider_get_description_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_slider_get_description(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_get_description_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_get_description_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_get_description_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_controls_slider_get_description_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_slider_get_description_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_controls_slider_set_int_range_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_range(KODI_GUI_CONTROL_HANDLE handle, int start, int end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_int_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_int_range_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_set_int_range_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int start = std::get<1>(t); + int end = std::get<2>(t); + kodi_gui_controls_slider_set_int_range_v1(this, handle, start, end); + return true; + } + case funcParent_kodi_gui_controls_slider_set_int_value_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_value(KODI_GUI_CONTROL_HANDLE handle, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_int_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_set_int_value_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int value = std::get<1>(t); + kodi_gui_controls_slider_set_int_value_v1(this, handle, value); + return true; + } + case funcParent_kodi_gui_controls_slider_get_int_value_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_controls_slider_get_int_value(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_get_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_get_int_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_get_int_value_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_gui_controls_slider_get_int_value_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_slider_get_int_value_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_controls_slider_set_int_interval_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_interval(KODI_GUI_CONTROL_HANDLE handle, int interval) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_int_interval_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_int_interval_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_set_int_interval_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int interval = std::get<1>(t); + kodi_gui_controls_slider_set_int_interval_v1(this, handle, interval); + return true; + } + case funcParent_kodi_gui_controls_slider_set_percentage_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_percentage(KODI_GUI_CONTROL_HANDLE handle, float percent) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_percentage_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_set_percentage_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float percent = std::get<1>(t); + kodi_gui_controls_slider_set_percentage_v1(this, handle, percent); + return true; + } + case funcParent_kodi_gui_controls_slider_get_percentage_v1: + { + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_slider_get_percentage(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_get_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_get_percentage_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_get_percentage_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float auto_gen_ret = kodi_gui_controls_slider_get_percentage_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_slider_get_percentage_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_controls_slider_set_float_range_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_range(KODI_GUI_CONTROL_HANDLE handle, float start, float end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_float_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_float_range_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_set_float_range_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float start = std::get<1>(t); + float end = std::get<2>(t); + kodi_gui_controls_slider_set_float_range_v1(this, handle, start, end); + return true; + } + case funcParent_kodi_gui_controls_slider_set_float_value_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_value(KODI_GUI_CONTROL_HANDLE handle, float value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_float_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_set_float_value_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float value = std::get<1>(t); + kodi_gui_controls_slider_set_float_value_v1(this, handle, value); + return true; + } + case funcParent_kodi_gui_controls_slider_get_float_value_v1: + { + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_slider_get_float_value(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_get_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_get_float_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_get_float_value_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float auto_gen_ret = kodi_gui_controls_slider_get_float_value_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_slider_get_float_value_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_controls_slider_set_float_interval_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_interval(KODI_GUI_CONTROL_HANDLE handle, float interval) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_float_interval_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_float_interval_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_slider_set_float_interval_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float interval = std::get<1>(t); + kodi_gui_controls_slider_set_float_interval_v1(this, handle, interval); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_slider_h::{}: addon called with unknown function id '{}' " + "on group 'gui_controls_slider_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_set_enabled_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool enabled) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetEnabled(enabled); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_reset_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISliderControl* control = static_cast(handle); + CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID()); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_get_description_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(static_cast(handle)->GetDescription().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_set_int_range_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int start, int end) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISliderControl* control = static_cast(handle); + control->SetType(SLIDER_CONTROL_TYPE_INT); + control->SetRange(start, end); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_set_int_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISliderControl* control = static_cast(handle); + control->SetType(SLIDER_CONTROL_TYPE_INT); + control->SetIntValue(value); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_get_int_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetIntValue(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_set_int_interval_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int interval) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetIntInterval(interval); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_set_percentage_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float percent) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISliderControl* control = static_cast(handle); + control->SetType(SLIDER_CONTROL_TYPE_PERCENTAGE); + control->SetPercentage(percent); + + /*---AUTO_GEN_PARSE---*/ +} + +float CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_get_percentage_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0f; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetPercentage(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_set_float_range_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float start, float end) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISliderControl* control = static_cast(handle); + control->SetType(SLIDER_CONTROL_TYPE_FLOAT); + control->SetFloatRange(start, end); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_set_float_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISliderControl* control = static_cast(handle); + control->SetType(SLIDER_CONTROL_TYPE_FLOAT); + control->SetFloatValue(value); + + /*---AUTO_GEN_PARSE---*/ +} + +float CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_get_float_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0f; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetFloatValue(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_slider_h::kodi_gui_controls_slider_set_float_interval_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float interval) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetFloatInterval(interval); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/slider.h b/xbmc/addons/interface/api/gui/controls/slider.h new file mode 100644 index 0000000000000..763e35b310c2a --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/slider.h @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/slider.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_slider_h; +struct directFuncToKodi_gui_controls_slider_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_slider_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_slider_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_slider_h* ifcToKodi, + directFuncToAddon_gui_controls_slider_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_slider_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_slider_set_enabled_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool enabled); // Added with API 1 + + static void kodi_gui_controls_slider_reset_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static char* kodi_gui_controls_slider_get_description_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_slider_set_int_range_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int start, + int end); // Added with API 1 + + static void kodi_gui_controls_slider_set_int_value_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int value); // Added with API 1 + + static int kodi_gui_controls_slider_get_int_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_slider_set_int_interval_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int interval); // Added with API 1 + + static void kodi_gui_controls_slider_set_percentage_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float percent); // Added with API 1 + + static float kodi_gui_controls_slider_get_percentage_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_slider_set_float_range_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float start, + float end); // Added with API 1 + + static void kodi_gui_controls_slider_set_float_value_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float value); // Added with API 1 + + static float kodi_gui_controls_slider_get_float_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_slider_set_float_interval_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float interval); // Added with API 1 + + directFuncToAddon_gui_controls_slider_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/spin.cpp b/xbmc/addons/interface/api/gui/controls/spin.cpp new file mode 100644 index 0000000000000..a9b39574d9e25 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/spin.cpp @@ -0,0 +1,509 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "spin.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/spin.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIComponent.h" +#include "guilib/GUISpinControlEx.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_spin_h::InitDirect(directFuncToKodi_gui_controls_spin_h* ifcToKodi, + directFuncToAddon_gui_controls_spin_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_spin_set_visible_v1 = kodi_gui_controls_spin_set_visible_v1; + ifcToKodi->kodi_gui_controls_spin_set_enabled_v1 = kodi_gui_controls_spin_set_enabled_v1; + ifcToKodi->kodi_gui_controls_spin_set_text_v1 = kodi_gui_controls_spin_set_text_v1; + ifcToKodi->kodi_gui_controls_spin_reset_v1 = kodi_gui_controls_spin_reset_v1; + ifcToKodi->kodi_gui_controls_spin_set_type_v1 = kodi_gui_controls_spin_set_type_v1; + ifcToKodi->kodi_gui_controls_spin_add_string_label_v1 = + kodi_gui_controls_spin_add_string_label_v1; + ifcToKodi->kodi_gui_controls_spin_set_string_value_v1 = + kodi_gui_controls_spin_set_string_value_v1; + ifcToKodi->kodi_gui_controls_spin_get_string_value_v1 = + kodi_gui_controls_spin_get_string_value_v1; + ifcToKodi->kodi_gui_controls_spin_add_int_label_v1 = kodi_gui_controls_spin_add_int_label_v1; + ifcToKodi->kodi_gui_controls_spin_set_int_range_v1 = kodi_gui_controls_spin_set_int_range_v1; + ifcToKodi->kodi_gui_controls_spin_set_int_value_v1 = kodi_gui_controls_spin_set_int_value_v1; + ifcToKodi->kodi_gui_controls_spin_get_int_value_v1 = kodi_gui_controls_spin_get_int_value_v1; + ifcToKodi->kodi_gui_controls_spin_set_float_range_v1 = kodi_gui_controls_spin_set_float_range_v1; + ifcToKodi->kodi_gui_controls_spin_set_float_value_v1 = kodi_gui_controls_spin_set_float_value_v1; + ifcToKodi->kodi_gui_controls_spin_get_float_value_v1 = kodi_gui_controls_spin_get_float_value_v1; + ifcToKodi->kodi_gui_controls_spin_set_float_interval_v1 = + kodi_gui_controls_spin_set_float_interval_v1; +} + +bool CHdl_kodi_gui_controls_spin_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_spin_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_spin_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_spin_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_spin_set_enabled_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_enabled_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_set_enabled_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool enabled = std::get<1>(t); + kodi_gui_controls_spin_set_enabled_v1(this, handle, enabled); + return true; + } + case funcParent_kodi_gui_controls_spin_set_text_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_text(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_set_text_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& text = std::get<1>(t); + kodi_gui_controls_spin_set_text_v1(this, handle, text.c_str()); + return true; + } + case funcParent_kodi_gui_controls_spin_reset_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_reset(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_reset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_reset_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_reset_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_controls_spin_reset_v1(this, handle); + return true; + } + case funcParent_kodi_gui_controls_spin_set_type_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_type(KODI_GUI_CONTROL_HANDLE handle, int type) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_type_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_type_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_set_type_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int type = std::get<1>(t); + kodi_gui_controls_spin_set_type_v1(this, handle, type); + return true; + } + case funcParent_kodi_gui_controls_spin_add_string_label_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_add_string_label(KODI_GUI_CONTROL_HANDLE handle, const char* label, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_add_string_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_add_string_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_add_string_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& label = std::get<1>(t); + const std::string& value = std::get<2>(t); + kodi_gui_controls_spin_add_string_label_v1(this, handle, label.c_str(), value.c_str()); + return true; + } + case funcParent_kodi_gui_controls_spin_set_string_value_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_string_value(KODI_GUI_CONTROL_HANDLE handle, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_string_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_string_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_set_string_value_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& value = std::get<1>(t); + kodi_gui_controls_spin_set_string_value_v1(this, handle, value.c_str()); + return true; + } + case funcParent_kodi_gui_controls_spin_get_string_value_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_spin_get_string_value(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_get_string_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_get_string_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_get_string_value_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_controls_spin_get_string_value_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_spin_get_string_value_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_controls_spin_add_int_label_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_add_int_label(KODI_GUI_CONTROL_HANDLE handle, const char* label, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_add_int_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_add_int_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_add_int_label_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& label = std::get<1>(t); + int value = std::get<2>(t); + kodi_gui_controls_spin_add_int_label_v1(this, handle, label.c_str(), value); + return true; + } + case funcParent_kodi_gui_controls_spin_set_int_range_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_int_range(KODI_GUI_CONTROL_HANDLE handle, int start, int end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_int_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_int_range_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_set_int_range_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int start = std::get<1>(t); + int end = std::get<2>(t); + kodi_gui_controls_spin_set_int_range_v1(this, handle, start, end); + return true; + } + case funcParent_kodi_gui_controls_spin_set_int_value_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_int_value(KODI_GUI_CONTROL_HANDLE handle, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_int_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_set_int_value_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int value = std::get<1>(t); + kodi_gui_controls_spin_set_int_value_v1(this, handle, value); + return true; + } + case funcParent_kodi_gui_controls_spin_get_int_value_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_controls_spin_get_int_value(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_get_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_get_int_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_get_int_value_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_gui_controls_spin_get_int_value_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_spin_get_int_value_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_controls_spin_set_float_range_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_range(KODI_GUI_CONTROL_HANDLE handle, float start, float end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_float_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_float_range_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_set_float_range_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float start = std::get<1>(t); + float end = std::get<2>(t); + kodi_gui_controls_spin_set_float_range_v1(this, handle, start, end); + return true; + } + case funcParent_kodi_gui_controls_spin_set_float_value_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_value(KODI_GUI_CONTROL_HANDLE handle, float value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_float_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_set_float_value_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float value = std::get<1>(t); + kodi_gui_controls_spin_set_float_value_v1(this, handle, value); + return true; + } + case funcParent_kodi_gui_controls_spin_get_float_value_v1: + { + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_spin_get_float_value(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_get_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_get_float_value_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_get_float_value_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float auto_gen_ret = kodi_gui_controls_spin_get_float_value_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_spin_get_float_value_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_controls_spin_set_float_interval_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_interval(KODI_GUI_CONTROL_HANDLE handle, float interval) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_float_interval_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_float_interval_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_spin_set_float_interval_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float interval = std::get<1>(t); + kodi_gui_controls_spin_set_float_interval_v1(this, handle, interval); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_spin_h::{}: addon called with unknown function id '{}' on " + "group 'gui_controls_spin_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_set_enabled_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool enabled) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetEnabled(enabled); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_set_text_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* text) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISpinControlEx* control = static_cast(handle); + CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID()); + msg.SetLabel(text); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_reset_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUISpinControlEx* control = static_cast(handle); + CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID()); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_set_type_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int type) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetType(type); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_add_string_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* label, const char* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->AddLabel(std::string(label), std::string(value)); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_set_string_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetStringValue(std::string(value)); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_get_string_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(static_cast(handle)->GetStringValue().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_add_int_label_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* label, int value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->AddLabel(std::string(label), value); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_set_int_range_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int start, int end) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetRange(start, end); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_set_int_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetValue(value); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_get_int_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetValue(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_set_float_range_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float start, float end) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetFloatRange(start, end); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_set_float_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetFloatValue(value); + + /*---AUTO_GEN_PARSE---*/ +} + +float CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_get_float_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0f; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetFloatValue(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_spin_h::kodi_gui_controls_spin_set_float_interval_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, float interval) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetFloatInterval(interval); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/spin.h b/xbmc/addons/interface/api/gui/controls/spin.h new file mode 100644 index 0000000000000..ad1760fbdbbd7 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/spin.h @@ -0,0 +1,131 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/spin.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_spin_h; +struct directFuncToKodi_gui_controls_spin_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_spin_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_spin_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_spin_h* ifcToKodi, + directFuncToAddon_gui_controls_spin_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_spin_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_spin_set_enabled_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool enabled); // Added with API 1 + + static void kodi_gui_controls_spin_set_text_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* text); // Added with API 1 + + static void kodi_gui_controls_spin_reset_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_spin_set_type_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int type); // Added with API 1 + + static void kodi_gui_controls_spin_add_string_label_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* label, + const char* value); // Added with API 1 + + static void kodi_gui_controls_spin_set_string_value_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* value); // Added with API 1 + + static char* kodi_gui_controls_spin_get_string_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_spin_add_int_label_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* label, + int value); // Added with API 1 + + static void kodi_gui_controls_spin_set_int_range_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int start, + int end); // Added with API 1 + + static void kodi_gui_controls_spin_set_int_value_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int value); // Added with API 1 + + static int kodi_gui_controls_spin_get_int_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_spin_set_float_range_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float start, + float end); // Added with API 1 + + static void kodi_gui_controls_spin_set_float_value_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float value); // Added with API 1 + + static float kodi_gui_controls_spin_get_float_value_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_spin_set_float_interval_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + float interval); // Added with API 1 + + directFuncToAddon_gui_controls_spin_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/text_box.cpp b/xbmc/addons/interface/api/gui/controls/text_box.cpp new file mode 100644 index 0000000000000..1a2918dca997b --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/text_box.cpp @@ -0,0 +1,303 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "text_box.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/controls/text_box.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIComponent.h" +#include "guilib/GUITextBox.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_text_box_h::InitDirect( + directFuncToKodi_gui_controls_text_box_h* ifcToKodi, + directFuncToAddon_gui_controls_text_box_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_controls_text_box_set_visible_v1 = kodi_gui_controls_text_box_set_visible_v1; + ifcToKodi->kodi_gui_controls_text_box_reset_v1 = kodi_gui_controls_text_box_reset_v1; + ifcToKodi->kodi_gui_controls_text_box_set_text_v1 = kodi_gui_controls_text_box_set_text_v1; + ifcToKodi->kodi_gui_controls_text_box_get_text_v1 = kodi_gui_controls_text_box_get_text_v1; + ifcToKodi->kodi_gui_controls_text_box_scroll_v1 = kodi_gui_controls_text_box_scroll_v1; + ifcToKodi->kodi_gui_controls_text_box_set_auto_scrolling_v1 = + kodi_gui_controls_text_box_set_auto_scrolling_v1; +} + +bool CHdl_kodi_gui_controls_text_box_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_controls_text_box_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_controls_text_box_set_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_set_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_text_box_set_visible_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool visible = std::get<1>(t); + kodi_gui_controls_text_box_set_visible_v1(this, handle, visible); + return true; + } + case funcParent_kodi_gui_controls_text_box_reset_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_text_box_reset(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_reset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_reset_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_text_box_reset_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_controls_text_box_reset_v1(this, handle); + return true; + } + case funcParent_kodi_gui_controls_text_box_set_text_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_text(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_set_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_set_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_text_box_set_text_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& text = std::get<1>(t); + kodi_gui_controls_text_box_set_text_v1(this, handle, text.c_str()); + return true; + } + case funcParent_kodi_gui_controls_text_box_get_text_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_text_box_get_text(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_get_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_get_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_text_box_get_text_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_controls_text_box_get_text_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_controls_text_box_get_text_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_controls_text_box_scroll_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_text_box_scroll(KODI_GUI_CONTROL_HANDLE handle, unsigned int position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_scroll_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_scroll_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_text_box_scroll_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + unsigned int position = std::get<1>(t); + kodi_gui_controls_text_box_scroll_v1(this, handle, position); + return true; + } + case funcParent_kodi_gui_controls_text_box_set_auto_scrolling_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_auto_scrolling( KODI_GUI_CONTROL_HANDLE handle, int delay, int time, int repeat) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_set_auto_scrolling_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_set_auto_scrolling_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_controls_text_box_set_auto_scrolling_v1 t = in.get().as(); + KODI_GUI_CONTROL_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int delay = std::get<1>(t); + int time = std::get<2>(t); + int repeat = std::get<3>(t); + kodi_gui_controls_text_box_set_auto_scrolling_v1(this, handle, delay, time, repeat); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_controls_text_box_h::{}: addon called with unknown function id '{}' " + "on group 'gui_controls_text_box_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_controls_text_box_h::kodi_gui_controls_text_box_set_visible_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUITextBox* control = static_cast(handle); + if (!control) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_controls_text_box_h::{} - invalid handler data (handle='{}') on addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + control->SetVisible(visible); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_text_box_h::kodi_gui_controls_text_box_reset_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUITextBox* control = static_cast(handle); + if (!control) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_controls_text_box_h::{} - invalid handler data (handle='{}') on addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID()); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_text_box_h::kodi_gui_controls_text_box_set_text_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, const char* text) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUITextBox* control = static_cast(handle); + if (!control) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_controls_text_box_h::{} - invalid handler data (handle='{}') on addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID()); + msg.SetLabel(text); + CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_controls_text_box_h::kodi_gui_controls_text_box_get_text_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CGUITextBox* control = static_cast(handle); + if (!control) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_controls_text_box_h::{} - invalid handler data (handle='{}') on addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return nullptr; + } + + return strdup(control->GetDescription().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_text_box_h::kodi_gui_controls_text_box_scroll_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, unsigned int position) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUITextBox* control = static_cast(handle); + if (!control) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_controls_text_box_h::{} - invalid handler data (handle='{}') on addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + control->Scroll(position); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_controls_text_box_h::kodi_gui_controls_text_box_set_auto_scrolling_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle, int delay, int time, int repeat) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUITextBox* control = static_cast(handle); + if (!control) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_controls_text_box_h::{} - invalid handler data (handle='{}') on addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + control->SetAutoScrolling(delay, time, repeat); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/controls/text_box.h b/xbmc/addons/interface/api/gui/controls/text_box.h new file mode 100644 index 0000000000000..c9379d73d1ef6 --- /dev/null +++ b/xbmc/addons/interface/api/gui/controls/text_box.h @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/text_box.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_text_box_h; +struct directFuncToKodi_gui_controls_text_box_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_controls_text_box_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_text_box_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_controls_text_box_h* ifcToKodi, + directFuncToAddon_gui_controls_text_box_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_controls_text_box_set_visible_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + bool visible); // Added with API 1 + + static void kodi_gui_controls_text_box_reset_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_text_box_set_text_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + const char* text); // Added with API 1 + + static char* kodi_gui_controls_text_box_get_text_v1( + void* thisClassHdl, KODI_GUI_CONTROL_HANDLE handle); // Added with API 1 + + static void kodi_gui_controls_text_box_scroll_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + unsigned int position); // Added with API 1 + + static void kodi_gui_controls_text_box_set_auto_scrolling_v1(void* thisClassHdl, + KODI_GUI_CONTROL_HANDLE handle, + int delay, + int time, + int repeat); // Added with API 1 + + directFuncToAddon_gui_controls_text_box_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/CMakeLists.txt b/xbmc/addons/interface/api/gui/dialogs/CMakeLists.txt new file mode 100644 index 0000000000000..c1f9c0274b181 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/CMakeLists.txt @@ -0,0 +1,32 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + context_menu.cpp + extended_progress.cpp + filebrowser.cpp + keyboard.cpp + numeric.cpp + ok.cpp + progress.cpp + select.cpp + text_viewer.cpp + yes_no.cpp +) + +set(HEADERS + context_menu.h + extended_progress.h + filebrowser.h + keyboard.h + numeric.h + ok.h + progress.h + select.h + text_viewer.h + yes_no.h +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface_api_gui_dialogs) +endif() diff --git a/xbmc/addons/interface/api/gui/dialogs/context_menu.cpp b/xbmc/addons/interface/api/gui/dialogs/context_menu.cpp new file mode 100644 index 0000000000000..4f8a7bec51ce5 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/context_menu.cpp @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "context_menu.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/dialogs/context_menu.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "dialogs/GUIDialogContextMenu.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_context_menu_h::InitDirect( + directFuncToKodi_gui_dialogs_context_menu_h* ifcToKodi, + directFuncToAddon_gui_dialogs_context_menu_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_dialogs_context_menu_open_v1 = kodi_gui_dialogs_context_menu_open_v1; +} + +bool CHdl_kodi_gui_dialogs_context_menu_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_dialogs_context_menu_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_dialogs_context_menu_open_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_dialogs_context_menu_open(const char* heading, const char* entries[], size_t size) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple, size_t> msgParent__IN_kodi_gui_dialogs_context_menu_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_context_menu_open_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_context_menu_open_v1 t = in.get().as(); + const std::string& heading = std::get<0>(t); + const std::vector& cpp_entries = std::get<1>(t); + size_t size = std::get<2>(t); + + std::vector entries; + entries.reserve(size); + for (size_t i = 0; i < size; ++i) + { + entries.emplace_back(cpp_entries[i].c_str()); + } + assert(cpp_entries.size() == size); + + int auto_gen_ret = + kodi_gui_dialogs_context_menu_open_v1(this, heading.c_str(), entries.data(), size); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_context_menu_open_v1(auto_gen_ret)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_context_menu_h::{}: addon called with unknown function id " + "'{}' on group 'gui_dialogs_context_menu_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +int CHdl_kodi_gui_dialogs_context_menu_h::kodi_gui_dialogs_context_menu_open_v1( + void* thisClassHdl, const char* heading, const char* entries[], size_t size) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + // Code below must be set manually by hand to make work to Kodi + + CGUIDialogContextMenu* dialog = + CServiceBroker::GetGUI()->GetWindowManager().GetWindow( + WINDOW_DIALOG_CONTEXT_MENU); + + CContextButtons choices; + for (unsigned int i = 0; i < size; ++i) + choices.Add(i, entries[i]); + + return dialog->Show(choices); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/context_menu.h b/xbmc/addons/interface/api/gui/dialogs/context_menu.h new file mode 100644 index 0000000000000..4576e10b3f8dc --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/context_menu.h @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/context_menu.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_context_menu_h; +struct directFuncToKodi_gui_dialogs_context_menu_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_dialogs_context_menu_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_context_menu_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_dialogs_context_menu_h* ifcToKodi, + directFuncToAddon_gui_dialogs_context_menu_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static int kodi_gui_dialogs_context_menu_open_v1(void* thisClassHdl, + const char* heading, + const char* entries[], + size_t size); // Added with API 1 + + directFuncToAddon_gui_dialogs_context_menu_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/extended_progress.cpp b/xbmc/addons/interface/api/gui/dialogs/extended_progress.cpp new file mode 100644 index 0000000000000..3a5b7579203a0 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/extended_progress.cpp @@ -0,0 +1,407 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "extended_progress.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/dialogs/extended_progress.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "dialogs/GUIDialogExtendedProgressBar.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_extended_progress_h::InitDirect( + directFuncToKodi_gui_dialogs_extended_progress_h* ifcToKodi, + directFuncToAddon_gui_dialogs_extended_progress_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_dialogs_extended_progress_new_dialog_v1 = + kodi_gui_dialogs_extended_progress_new_dialog_v1; + ifcToKodi->kodi_gui_dialogs_extended_progress_delete_dialog_v1 = + kodi_gui_dialogs_extended_progress_delete_dialog_v1; + ifcToKodi->kodi_gui_dialogs_extended_progress_get_title_v1 = + kodi_gui_dialogs_extended_progress_get_title_v1; + ifcToKodi->kodi_gui_dialogs_extended_progress_set_title_v1 = + kodi_gui_dialogs_extended_progress_set_title_v1; + ifcToKodi->kodi_gui_dialogs_extended_progress_get_text_v1 = + kodi_gui_dialogs_extended_progress_get_text_v1; + ifcToKodi->kodi_gui_dialogs_extended_progress_set_text_v1 = + kodi_gui_dialogs_extended_progress_set_text_v1; + ifcToKodi->kodi_gui_dialogs_extended_progress_is_finished_v1 = + kodi_gui_dialogs_extended_progress_is_finished_v1; + ifcToKodi->kodi_gui_dialogs_extended_progress_mark_finished_v1 = + kodi_gui_dialogs_extended_progress_mark_finished_v1; + ifcToKodi->kodi_gui_dialogs_extended_progress_get_percentage_v1 = + kodi_gui_dialogs_extended_progress_get_percentage_v1; + ifcToKodi->kodi_gui_dialogs_extended_progress_set_percentage_v1 = + kodi_gui_dialogs_extended_progress_set_percentage_v1; + ifcToKodi->kodi_gui_dialogs_extended_progress_set_progress_v1 = + kodi_gui_dialogs_extended_progress_set_progress_v1; +} + +bool CHdl_kodi_gui_dialogs_extended_progress_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_dialogs_extended_progress_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_dialogs_extended_progress_new_dialog_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_HANDLE kodi_gui_dialogs_extended_progress_new_dialog(const char* title) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_new_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_new_dialog_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_new_dialog_v1 t = in.get().as(); + const std::string& title = std::get<0>(t); + KODI_GUI_HANDLE auto_gen_ret = + kodi_gui_dialogs_extended_progress_new_dialog_v1(this, title.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_extended_progress_new_dialog_v1( + PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_dialogs_extended_progress_delete_dialog_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_delete_dialog(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_delete_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_delete_dialog_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_delete_dialog_v1 t = + in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_dialogs_extended_progress_delete_dialog_v1(this, handle); + return true; + } + case funcParent_kodi_gui_dialogs_extended_progress_get_title_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_dialogs_extended_progress_get_title(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_get_title_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_get_title_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_get_title_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_dialogs_extended_progress_get_title_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_extended_progress_get_title_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_dialogs_extended_progress_set_title_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_title(KODI_GUI_HANDLE handle, const char* title) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_set_title_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_set_title_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_set_title_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& title = std::get<1>(t); + kodi_gui_dialogs_extended_progress_set_title_v1(this, handle, title.c_str()); + return true; + } + case funcParent_kodi_gui_dialogs_extended_progress_get_text_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_dialogs_extended_progress_get_text(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_get_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_get_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_get_text_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_dialogs_extended_progress_get_text_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_extended_progress_get_text_v1( + auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_dialogs_extended_progress_set_text_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_text(KODI_GUI_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_set_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_set_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_set_text_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& text = std::get<1>(t); + kodi_gui_dialogs_extended_progress_set_text_v1(this, handle, text.c_str()); + return true; + } + case funcParent_kodi_gui_dialogs_extended_progress_is_finished_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_extended_progress_is_finished(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_is_finished_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_is_finished_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_is_finished_v1 t = + in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_gui_dialogs_extended_progress_is_finished_v1(this, handle); + msgpack::pack(out, + msgParent_OUT_kodi_gui_dialogs_extended_progress_is_finished_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_dialogs_extended_progress_mark_finished_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_mark_finished(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_mark_finished_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_mark_finished_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_mark_finished_v1 t = + in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_dialogs_extended_progress_mark_finished_v1(this, handle); + return true; + } + case funcParent_kodi_gui_dialogs_extended_progress_get_percentage_v1: + { + // Original API call: ATTR_DLL_EXPORT float kodi_gui_dialogs_extended_progress_get_percentage(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_get_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_get_percentage_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_get_percentage_v1 t = + in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float auto_gen_ret = kodi_gui_dialogs_extended_progress_get_percentage_v1(this, handle); + msgpack::pack( + out, msgParent_OUT_kodi_gui_dialogs_extended_progress_get_percentage_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_dialogs_extended_progress_set_percentage_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_percentage(KODI_GUI_HANDLE handle, float percentage) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_set_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_set_percentage_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_set_percentage_v1 t = + in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + float percentage = std::get<1>(t); + kodi_gui_dialogs_extended_progress_set_percentage_v1(this, handle, percentage); + return true; + } + case funcParent_kodi_gui_dialogs_extended_progress_set_progress_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_progress(KODI_GUI_HANDLE handle, int currentItem, int itemCount) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_set_progress_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_set_progress_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_extended_progress_set_progress_v1 t = + in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int currentItem = std::get<1>(t); + int itemCount = std::get<2>(t); + kodi_gui_dialogs_extended_progress_set_progress_v1(this, handle, currentItem, itemCount); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_extended_progress_h::{}: addon called with unknown function " + "id '{}' on group 'gui_dialogs_extended_progress_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +KODI_GUI_HANDLE CHdl_kodi_gui_dialogs_extended_progress_h:: + kodi_gui_dialogs_extended_progress_new_dialog_v1(void* thisClassHdl, const char* title) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + // setup the progress dialog + CGUIDialogExtendedProgressBar* dialog = + CServiceBroker::GetGUI()->GetWindowManager().GetWindow( + WINDOW_DIALOG_EXT_PROGRESS); + if (!dialog) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_extended_progress_h::{} - invalid handler data , " + "dialog='{}') on addon '{}'", + __func__, static_cast(dialog), thisClass->m_process->GetAddonID()); + return nullptr; + } + + CGUIDialogProgressBarHandle* dlgProgressHandle = dialog->GetHandle(title); + return dlgProgressHandle; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_extended_progress_h::kodi_gui_dialogs_extended_progress_delete_dialog_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->MarkFinished(); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_dialogs_extended_progress_h::kodi_gui_dialogs_extended_progress_get_title_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(static_cast(handle)->Title().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_extended_progress_h::kodi_gui_dialogs_extended_progress_set_title_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, const char* title) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetTitle(title); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_dialogs_extended_progress_h::kodi_gui_dialogs_extended_progress_get_text_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return strdup(static_cast(handle)->Text().c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_extended_progress_h::kodi_gui_dialogs_extended_progress_set_text_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, const char* text) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetText(text); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_extended_progress_h::kodi_gui_dialogs_extended_progress_is_finished_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->IsFinished(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_extended_progress_h::kodi_gui_dialogs_extended_progress_mark_finished_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->MarkFinished(); + + /*---AUTO_GEN_PARSE---*/ +} + +float CHdl_kodi_gui_dialogs_extended_progress_h:: + kodi_gui_dialogs_extended_progress_get_percentage_v1(void* thisClassHdl, KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0f; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->Percentage(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_extended_progress_h:: + kodi_gui_dialogs_extended_progress_set_percentage_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + float percentage) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetPercentage(percentage); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_extended_progress_h::kodi_gui_dialogs_extended_progress_set_progress_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, int currentItem, int itemCount) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetProgress(currentItem, itemCount); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/extended_progress.h b/xbmc/addons/interface/api/gui/dialogs/extended_progress.h new file mode 100644 index 0000000000000..8fb92a3eb5cc3 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/extended_progress.h @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/extended_progress.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_extended_progress_h; +struct directFuncToKodi_gui_dialogs_extended_progress_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_dialogs_extended_progress_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_extended_progress_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_dialogs_extended_progress_h* ifcToKodi, + directFuncToAddon_gui_dialogs_extended_progress_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static KODI_GUI_HANDLE kodi_gui_dialogs_extended_progress_new_dialog_v1( + void* thisClassHdl, const char* title); // Added with API 1 + + static void kodi_gui_dialogs_extended_progress_delete_dialog_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle); // Added with API 1 + + static char* kodi_gui_dialogs_extended_progress_get_title_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle); // Added with API 1 + + static void kodi_gui_dialogs_extended_progress_set_title_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, const char* title); // Added with API 1 + + static char* kodi_gui_dialogs_extended_progress_get_text_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle); // Added with API 1 + + static void kodi_gui_dialogs_extended_progress_set_text_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + const char* text); // Added with API 1 + + static bool kodi_gui_dialogs_extended_progress_is_finished_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle); // Added with API 1 + + static void kodi_gui_dialogs_extended_progress_mark_finished_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle); // Added with API 1 + + static float kodi_gui_dialogs_extended_progress_get_percentage_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle); // Added with API 1 + + static void kodi_gui_dialogs_extended_progress_set_percentage_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, float percentage); // Added with API 1 + + static void kodi_gui_dialogs_extended_progress_set_progress_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + int currentItem, + int itemCount); // Added with API 1 + + directFuncToAddon_gui_dialogs_extended_progress_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/filebrowser.cpp b/xbmc/addons/interface/api/gui/dialogs/filebrowser.cpp new file mode 100644 index 0000000000000..ca4b45c04b935 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/filebrowser.cpp @@ -0,0 +1,545 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "filebrowser.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/dialogs/filebrowser.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "URL.h" +#include "dialogs/GUIDialogFileBrowser.h" +#include "settings/MediaSourceSettings.h" +#include "storage/MediaManager.h" +#include "utils/URIUtils.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +namespace +{ + +void GetVECShares(VECSOURCES& vecShares, const std::string& strShares, const std::string& strPath) +{ + std::size_t found; + found = strShares.find("local"); + if (found != std::string::npos) + CServiceBroker::GetMediaManager().GetLocalDrives(vecShares); + found = strShares.find("network"); + if (found != std::string::npos) + CServiceBroker::GetMediaManager().GetNetworkLocations(vecShares); + found = strShares.find("removable"); + if (found != std::string::npos) + CServiceBroker::GetMediaManager().GetRemovableDrives(vecShares); + found = strShares.find("programs"); + if (found != std::string::npos) + { + VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("programs"); + if (sources != nullptr) + vecShares.insert(vecShares.end(), sources->begin(), sources->end()); + } + found = strShares.find("files"); + if (found != std::string::npos) + { + VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("files"); + if (sources != nullptr) + vecShares.insert(vecShares.end(), sources->begin(), sources->end()); + } + found = strShares.find("music"); + if (found != std::string::npos) + { + VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("music"); + if (sources != nullptr) + vecShares.insert(vecShares.end(), sources->begin(), sources->end()); + } + found = strShares.find("video"); + if (found != std::string::npos) + { + VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("video"); + if (sources != nullptr) + vecShares.insert(vecShares.end(), sources->begin(), sources->end()); + } + found = strShares.find("pictures"); + if (found != std::string::npos) + { + VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("pictures"); + if (sources != nullptr) + vecShares.insert(vecShares.end(), sources->begin(), sources->end()); + } + + if (vecShares.empty()) + { + CMediaSource share; + std::string basePath = strPath; + std::string tempPath; + while (URIUtils::GetParentPath(basePath, tempPath)) + basePath = tempPath; + share.strPath = basePath; + // don't include the user details in the share name + CURL url(share.strPath); + share.strName = url.GetWithoutUserDetails(); + vecShares.push_back(share); + } +} + +} /* namespace */ + +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_filebrowser_h::InitDirect( + directFuncToKodi_gui_dialogs_filebrowser_h* ifcToKodi, + directFuncToAddon_gui_dialogs_filebrowser_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_dialogs_file_browser_show_and_get_directory_v1 = + kodi_gui_dialogs_file_browser_show_and_get_directory_v1; + ifcToKodi->kodi_gui_dialogs_file_browser_show_and_get_file_v1 = + kodi_gui_dialogs_file_browser_show_and_get_file_v1; + ifcToKodi->kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1 = + kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1; + ifcToKodi->kodi_gui_dialogs_file_browser_show_and_get_file_list_v1 = + kodi_gui_dialogs_file_browser_show_and_get_file_list_v1; + ifcToKodi->kodi_gui_dialogs_file_browser_show_and_get_source_v1 = + kodi_gui_dialogs_file_browser_show_and_get_source_v1; + ifcToKodi->kodi_gui_dialogs_file_browser_show_and_get_image_v1 = + kodi_gui_dialogs_file_browser_show_and_get_image_v1; + ifcToKodi->kodi_gui_dialogs_file_browser_show_and_get_image_list_v1 = + kodi_gui_dialogs_file_browser_show_and_get_image_list_v1; + // Unused "kodi_gui_dialogs_file_browser_clear_file_list", done only in addon lib +} + +bool CHdl_kodi_gui_dialogs_filebrowser_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_dialogs_filebrowser_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_dialogs_file_browser_show_and_get_directory_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_directory(const char* shares, const char* heading, const char* path_in, char** path_out, bool write_only) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_directory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_directory_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_directory_v1 t = + in.get().as(); + const std::string& shares = std::get<0>(t); + const std::string& heading = std::get<1>(t); + const std::string& path_in = std::get<2>(t); + char* path_out = nullptr; + bool write_only = std::get<3>(t); + bool auto_gen_ret = kodi_gui_dialogs_file_browser_show_and_get_directory_v1( + this, shares.c_str(), heading.c_str(), path_in.c_str(), &path_out, write_only); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_directory_v1( + auto_gen_ret, path_out ? path_out : "")); + if (path_out) + free(path_out); + return true; + } + case funcParent_kodi_gui_dialogs_file_browser_show_and_get_file_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file(const char* shares, const char* mask, const char* heading, const char* path_in, char** path_out, bool use_thumbs, bool use_file_directories) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_v1 t = + in.get().as(); + const std::string& shares = std::get<0>(t); + const std::string& mask = std::get<1>(t); + const std::string& heading = std::get<2>(t); + const std::string& path_in = std::get<3>(t); + char* path_out = nullptr; + bool use_thumbs = std::get<4>(t); + bool use_file_directories = std::get<5>(t); + bool auto_gen_ret = kodi_gui_dialogs_file_browser_show_and_get_file_v1( + this, shares.c_str(), mask.c_str(), heading.c_str(), path_in.c_str(), &path_out, + use_thumbs, use_file_directories); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_v1( + auto_gen_ret, path_out ? path_out : "")); + if (path_out) + free(path_out); + return true; + } + case funcParent_kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file_from_dir( const char* directory, const char* mask, const char* heading, const char* path_in, char** path_out, bool use_thumbs, bool use_file_directories, bool single_list) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1 t = + in.get().as(); + const std::string& directory = std::get<0>(t); + const std::string& mask = std::get<1>(t); + const std::string& heading = std::get<2>(t); + const std::string& path_in = std::get<3>(t); + char* path_out = nullptr; + bool use_thumbs = std::get<4>(t); + bool use_file_directories = std::get<5>(t); + bool single_list = std::get<6>(t); + bool auto_gen_ret = kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1( + this, directory.c_str(), mask.c_str(), heading.c_str(), path_in.c_str(), &path_out, + use_thumbs, use_file_directories, single_list); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1( + auto_gen_ret, path_out ? path_out : "")); + if (path_out) + free(path_out); + return true; + } + case funcParent_kodi_gui_dialogs_file_browser_show_and_get_file_list_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file_list( const char* shares, const char* mask, const char* heading, char*** file_list, size_t* entries, bool use_thumbs, bool use_file_directories) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_list_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_list_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_list_v1 t = + in.get().as(); + const std::string& shares = std::get<0>(t); + const std::string& mask = std::get<1>(t); + const std::string& heading = std::get<2>(t); + char** file_list = nullptr; + size_t entries = std::get<3>(t); + bool use_thumbs = std::get<4>(t); + bool use_file_directories = std::get<5>(t); + bool auto_gen_ret = kodi_gui_dialogs_file_browser_show_and_get_file_list_v1( + this, shares.c_str(), mask.c_str(), heading.c_str(), &file_list, &entries, use_thumbs, + use_file_directories); + std::vector cpp_file_list; + cpp_file_list.reserve(entries); + if (file_list) + { + for (size_t i = 0; i < entries; ++i) + { + if (file_list[i]) + { + cpp_file_list.emplace_back(file_list[i]); + free(file_list[i]); + } + else + { + cpp_file_list.emplace_back(""); + } + } + free(file_list); + } + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_list_v1( + auto_gen_ret, cpp_file_list, entries)); + return true; + } + case funcParent_kodi_gui_dialogs_file_browser_show_and_get_source_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_source( const char* path_in, char** path_out, bool allow_network_shares, const char* additional_share, const char* type) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_source_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_source_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_source_v1 t = + in.get().as(); + const std::string& path_in = std::get<0>(t); + char* path_out = nullptr; + bool allow_network_shares = std::get<1>(t); + const std::string& additional_share = std::get<2>(t); + const std::string& type = std::get<3>(t); + bool auto_gen_ret = kodi_gui_dialogs_file_browser_show_and_get_source_v1( + this, path_in.c_str(), &path_out, allow_network_shares, additional_share.c_str(), + type.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_source_v1( + auto_gen_ret, path_out ? path_out : "")); + if (path_out) + free(path_out); + return true; + } + case funcParent_kodi_gui_dialogs_file_browser_show_and_get_image_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_image(const char* shares, const char* heading, const char* path_in, char** path_out) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_image_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_image_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_image_v1 t = + in.get().as(); + const std::string& shares = std::get<0>(t); + const std::string& heading = std::get<1>(t); + const std::string& path_in = std::get<2>(t); + char* path_out = nullptr; + bool auto_gen_ret = kodi_gui_dialogs_file_browser_show_and_get_image_v1( + this, shares.c_str(), heading.c_str(), path_in.c_str(), &path_out); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_image_v1( + auto_gen_ret, path_out ? path_out : "")); + if (path_out) + free(path_out); + return true; + } + case funcParent_kodi_gui_dialogs_file_browser_show_and_get_image_list_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_image_list(const char* shares, const char* heading, char*** file_list, size_t* entries) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_image_list_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_image_list_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_image_list_v1 t = + in.get().as(); + const std::string& shares = std::get<0>(t); + const std::string& heading = std::get<1>(t); + char** file_list = nullptr; + size_t entries = std::get<2>(t); + bool auto_gen_ret = kodi_gui_dialogs_file_browser_show_and_get_image_list_v1( + this, shares.c_str(), heading.c_str(), &file_list, &entries); + std::vector cpp_file_list; + cpp_file_list.reserve(entries); + if (file_list) + { + for (size_t i = 0; i < entries; ++i) + { + if (file_list[i]) + { + cpp_file_list.emplace_back(file_list[i]); + free(file_list[i]); + } + else + { + cpp_file_list.emplace_back(""); + } + } + free(file_list); + } + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_image_list_v1( + auto_gen_ret, cpp_file_list, entries)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_filebrowser_h::{}: addon called with unknown function id " + "'{}' on group 'gui_dialogs_filebrowser_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +bool CHdl_kodi_gui_dialogs_filebrowser_h::kodi_gui_dialogs_file_browser_show_and_get_directory_v1( + void* thisClassHdl, + const char* shares, + const char* heading, + const char* path_in, + char** path_out, + bool write_only) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string strPath = path_in; + + VECSOURCES vecShares; + GetVECShares(vecShares, shares, strPath); + bool bRet = CGUIDialogFileBrowser::ShowAndGetDirectory(vecShares, heading, strPath, write_only); + if (bRet) + *path_out = strdup(strPath.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_filebrowser_h::kodi_gui_dialogs_file_browser_show_and_get_file_v1( + void* thisClassHdl, + const char* shares, + const char* mask, + const char* heading, + const char* path_in, + char** path_out, + bool use_thumbs, + bool use_file_directories) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string strPath = path_in; + + VECSOURCES vecShares; + GetVECShares(vecShares, shares, strPath); + bool bRet = CGUIDialogFileBrowser::ShowAndGetFile(vecShares, mask, heading, strPath, use_thumbs, + use_file_directories); + if (bRet) + *path_out = strdup(strPath.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_filebrowser_h:: + kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1(void* thisClassHdl, + const char* directory, + const char* mask, + const char* heading, + const char* path_in, + char** path_out, + bool use_thumbs, + bool use_file_directories, + bool single_list) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string strPath = path_in; + bool bRet = CGUIDialogFileBrowser::ShowAndGetFile(directory, mask, heading, strPath, use_thumbs, + use_file_directories, single_list); + if (bRet) + *path_out = strdup(strPath.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_filebrowser_h::kodi_gui_dialogs_file_browser_show_and_get_file_list_v1( + void* thisClassHdl, + const char* shares, + const char* mask, + const char* heading, + char*** file_list, + size_t* entries, + bool use_thumbs, + bool use_file_directories) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + VECSOURCES vecShares; + GetVECShares(vecShares, shares, ""); + + std::vector pathsInt; + bool bRet = CGUIDialogFileBrowser::ShowAndGetFileList(vecShares, mask, heading, pathsInt, + use_thumbs, use_file_directories); + if (bRet) + { + *entries = pathsInt.size(); + *file_list = static_cast(malloc(*entries * sizeof(char*))); + for (unsigned int i = 0; i < *entries; ++i) + (*file_list)[i] = strdup(pathsInt[i].c_str()); + } + else + *entries = 0; + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_filebrowser_h::kodi_gui_dialogs_file_browser_show_and_get_source_v1( + void* thisClassHdl, + const char* path_in, + char** path_out, + bool allow_network_shares, + const char* additional_share, + const char* type) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string strPath = path_in; + + VECSOURCES vecShares; + if (additional_share) + GetVECShares(vecShares, additional_share, strPath); + bool bRet = + CGUIDialogFileBrowser::ShowAndGetSource(strPath, allow_network_shares, &vecShares, type); + if (bRet) + *path_out = strdup(strPath.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_filebrowser_h::kodi_gui_dialogs_file_browser_show_and_get_image_v1( + void* thisClassHdl, + const char* shares, + const char* heading, + const char* path_in, + char** path_out) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string strPath = path_in; + + VECSOURCES vecShares; + GetVECShares(vecShares, shares, strPath); + bool bRet = CGUIDialogFileBrowser::ShowAndGetImage(vecShares, heading, strPath); + if (bRet) + *path_out = strdup(strPath.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_filebrowser_h::kodi_gui_dialogs_file_browser_show_and_get_image_list_v1( + void* thisClassHdl, const char* shares, const char* heading, char*** file_list, size_t* entries) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + VECSOURCES vecShares; + GetVECShares(vecShares, shares, ""); + + std::vector pathsInt; + bool bRet = CGUIDialogFileBrowser::ShowAndGetImageList(vecShares, heading, pathsInt); + if (bRet) + { + *entries = pathsInt.size(); + *file_list = static_cast(malloc(*entries * sizeof(char*))); + for (unsigned int i = 0; i < *entries; ++i) + (*file_list)[i] = strdup(pathsInt[i].c_str()); + } + else + *entries = 0; + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/filebrowser.h b/xbmc/addons/interface/api/gui/dialogs/filebrowser.h new file mode 100644 index 0000000000000..c839d7f3fb71f --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/filebrowser.h @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/filebrowser.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_filebrowser_h; +struct directFuncToKodi_gui_dialogs_filebrowser_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_dialogs_filebrowser_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_filebrowser_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_dialogs_filebrowser_h* ifcToKodi, + directFuncToAddon_gui_dialogs_filebrowser_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static bool kodi_gui_dialogs_file_browser_show_and_get_directory_v1( + void* thisClassHdl, + const char* shares, + const char* heading, + const char* path_in, + char** path_out, + bool write_only); // Added with API 1 + + static bool kodi_gui_dialogs_file_browser_show_and_get_file_v1( + void* thisClassHdl, + const char* shares, + const char* mask, + const char* heading, + const char* path_in, + char** path_out, + bool use_thumbs, + bool use_file_directories); // Added with API 1 + + static bool kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1( + void* thisClassHdl, + const char* directory, + const char* mask, + const char* heading, + const char* path_in, + char** path_out, + bool use_thumbs, + bool use_file_directories, + bool single_list); // Added with API 1 + + static bool kodi_gui_dialogs_file_browser_show_and_get_file_list_v1( + void* thisClassHdl, + const char* shares, + const char* mask, + const char* heading, + char*** file_list, + size_t* entries, + bool use_thumbs, + bool use_file_directories); // Added with API 1 + + static bool kodi_gui_dialogs_file_browser_show_and_get_source_v1( + void* thisClassHdl, + const char* path_in, + char** path_out, + bool allow_network_shares, + const char* additional_share, + const char* type); // Added with API 1 + + static bool kodi_gui_dialogs_file_browser_show_and_get_image_v1( + void* thisClassHdl, + const char* shares, + const char* heading, + const char* path_in, + char** path_out); // Added with API 1 + + static bool kodi_gui_dialogs_file_browser_show_and_get_image_list_v1( + void* thisClassHdl, + const char* shares, + const char* heading, + char*** file_list, + size_t* entries); // Added with API 1 + + directFuncToAddon_gui_dialogs_filebrowser_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/keyboard.cpp b/xbmc/addons/interface/api/gui/dialogs/keyboard.cpp new file mode 100644 index 0000000000000..4b9855f3b90ba --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/keyboard.cpp @@ -0,0 +1,481 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "keyboard.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/dialogs/keyboard.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "guilib/GUIKeyboardFactory.h" +#include "utils/Variant.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_keyboard_h::InitDirect( + directFuncToKodi_gui_dialogs_keyboard_h* ifcToKodi, + directFuncToAddon_gui_dialogs_keyboard_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1 = + kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1; + ifcToKodi->kodi_gui_dialogs_keyboard_show_and_get_input_v1 = + kodi_gui_dialogs_keyboard_show_and_get_input_v1; + ifcToKodi->kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1 = + kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1; + ifcToKodi->kodi_gui_dialogs_keyboard_show_and_get_new_password_v1 = + kodi_gui_dialogs_keyboard_show_and_get_new_password_v1; + ifcToKodi->kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1 = + kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1; + ifcToKodi->kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1 = + kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1; + ifcToKodi->kodi_gui_dialogs_keyboard_show_and_verify_password_v1 = + kodi_gui_dialogs_keyboard_show_and_verify_password_v1; + ifcToKodi->kodi_gui_dialogs_keyboard_show_and_get_filter_v1 = + kodi_gui_dialogs_keyboard_show_and_get_filter_v1; + ifcToKodi->kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1 = + kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1; + ifcToKodi->kodi_gui_dialogs_keyboard_is_keyboard_activated_v1 = + kodi_gui_dialogs_keyboard_is_keyboard_activated_v1; +} + +bool CHdl_kodi_gui_dialogs_keyboard_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_dialogs_keyboard_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_input_with_head( const char* text_in, char** text_out, const char* heading, bool allow_empty_result, bool hidden_input, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1 t = + in.get().as(); + const std::string& text_in = std::get<0>(t); + char* text_out = nullptr; + const std::string& heading = std::get<1>(t); + bool allow_empty_result = std::get<2>(t); + bool hidden_input = std::get<3>(t); + unsigned int auto_close_ms = std::get<4>(t); + bool auto_gen_ret = kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1( + this, text_in.c_str(), &text_out, heading.c_str(), allow_empty_result, hidden_input, + auto_close_ms); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1( + auto_gen_ret, text_out ? text_out : "")); + if (text_out) + free(text_out); + return true; + } + case funcParent_kodi_gui_dialogs_keyboard_show_and_get_input_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_input(const char* text_in, char** text_out, bool allow_empty_result, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_input_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_input_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_input_v1 t = in.get().as(); + const std::string& text_in = std::get<0>(t); + char* text_out = nullptr; + bool allow_empty_result = std::get<1>(t); + unsigned int auto_close_ms = std::get<2>(t); + bool auto_gen_ret = kodi_gui_dialogs_keyboard_show_and_get_input_v1( + this, text_in.c_str(), &text_out, allow_empty_result, auto_close_ms); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_input_v1( + auto_gen_ret, text_out ? text_out : "")); + if (text_out) + free(text_out); + return true; + } + case funcParent_kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head( const char* password_in, char** password_out, const char* heading, bool allow_empty_result, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1 t = + in.get().as(); + const std::string& password_in = std::get<0>(t); + char* password_out = nullptr; + const std::string& heading = std::get<1>(t); + bool allow_empty_result = std::get<2>(t); + unsigned int auto_close_ms = std::get<3>(t); + bool auto_gen_ret = kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1( + this, password_in.c_str(), &password_out, heading.c_str(), allow_empty_result, + auto_close_ms); + msgpack::pack(out, + msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1( + auto_gen_ret, password_out ? password_out : "")); + if (password_out) + free(password_out); + return true; + } + case funcParent_kodi_gui_dialogs_keyboard_show_and_get_new_password_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_new_password( const char* password_in, char** password_out, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_new_password_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_new_password_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_new_password_v1 t = + in.get().as(); + const std::string& password_in = std::get<0>(t); + char* password_out = nullptr; + unsigned int auto_close_ms = std::get<1>(t); + bool auto_gen_ret = kodi_gui_dialogs_keyboard_show_and_get_new_password_v1( + this, password_in.c_str(), &password_out, auto_close_ms); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_new_password_v1( + auto_gen_ret, password_out ? password_out : "")); + if (password_out) + free(password_out); + return true; + } + case funcParent_kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head( char** password_out, const char* heading, bool allow_empty_result, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1 t = + in.get().as(); + char* password_out = nullptr; + const std::string& heading = std::get<0>(t); + bool allow_empty_result = std::get<1>(t); + unsigned int auto_close_ms = std::get<2>(t); + bool auto_gen_ret = kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1( + this, &password_out, heading.c_str(), allow_empty_result, auto_close_ms); + msgpack::pack( + out, msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1( + auto_gen_ret, password_out ? password_out : "")); + if (password_out) + free(password_out); + return true; + } + case funcParent_kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_verify_new_password( char** password_out, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1 t = + in.get().as(); + char* password_out = nullptr; + unsigned int auto_close_ms = std::get<0>(t); + bool auto_gen_ret = kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1( + this, &password_out, auto_close_ms); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1( + auto_gen_ret, password_out ? password_out : "")); + if (password_out) + free(password_out); + return true; + } + case funcParent_kodi_gui_dialogs_keyboard_show_and_verify_password_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_dialogs_keyboard_show_and_verify_password(const char* password_in, char** password_out, const char* heading, int retries, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_password_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_password_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_password_v1 t = + in.get().as(); + const std::string& password_in = std::get<0>(t); + char* password_out = nullptr; + const std::string& heading = std::get<1>(t); + int retries = std::get<2>(t); + unsigned int auto_close_ms = std::get<3>(t); + int auto_gen_ret = kodi_gui_dialogs_keyboard_show_and_verify_password_v1( + this, password_in.c_str(), &password_out, heading.c_str(), retries, auto_close_ms); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_password_v1( + auto_gen_ret, password_out ? password_out : "")); + if (password_out) + free(password_out); + return true; + } + case funcParent_kodi_gui_dialogs_keyboard_show_and_get_filter_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_filter(const char* text_in, char** text_out, bool searching, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_filter_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_filter_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_filter_v1 t = in.get().as(); + const std::string& text_in = std::get<0>(t); + char* text_out = nullptr; + bool searching = std::get<1>(t); + unsigned int auto_close_ms = std::get<2>(t); + bool auto_gen_ret = kodi_gui_dialogs_keyboard_show_and_get_filter_v1( + this, text_in.c_str(), &text_out, searching, auto_close_ms); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_filter_v1( + auto_gen_ret, text_out ? text_out : "")); + if (text_out) + free(text_out); + return true; + } + case funcParent_kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_send_text_to_active_keyboard(const char* text, bool close_keyboard) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1 t = + in.get().as(); + const std::string& text = std::get<0>(t); + bool close_keyboard = std::get<1>(t); + bool auto_gen_ret = kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1( + this, text.c_str(), close_keyboard); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1( + auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_dialogs_keyboard_is_keyboard_activated_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_is_keyboard_activated() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_is_keyboard_activated_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_is_keyboard_activated_v1; /* Autogenerated */ + bool auto_gen_ret = kodi_gui_dialogs_keyboard_is_keyboard_activated_v1(this); + msgpack::pack(out, + msgParent_OUT_kodi_gui_dialogs_keyboard_is_keyboard_activated_v1(auto_gen_ret)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_keyboard_h::{}: addon called with unknown function id '{}' " + "on group 'gui_dialogs_keyboard_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +bool CHdl_kodi_gui_dialogs_keyboard_h::kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1( + void* thisClassHdl, + const char* text_in, + char** text_out, + const char* heading, + bool allow_empty_result, + bool hidden_input, + unsigned int auto_close_ms) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str = text_in; + bool bRet = CGUIKeyboardFactory::ShowAndGetInput(str, CVariant{heading}, allow_empty_result, + hidden_input, auto_close_ms); + if (bRet) + *text_out = strdup(str.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_keyboard_h::kodi_gui_dialogs_keyboard_show_and_get_input_v1( + void* thisClassHdl, + const char* text_in, + char** text_out, + bool allow_empty_result, + unsigned int auto_close_ms) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str = text_in; + bool bRet = CGUIKeyboardFactory::ShowAndGetInput(str, allow_empty_result, auto_close_ms); + if (bRet) + *text_out = strdup(str.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_keyboard_h:: + kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1(void* thisClassHdl, + const char* password_in, + char** password_out, + const char* heading, + bool allow_empty_result, + unsigned int auto_close_ms) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str = password_in; + bool bRet = + CGUIKeyboardFactory::ShowAndGetNewPassword(str, heading, allow_empty_result, auto_close_ms); + if (bRet) + *password_out = strdup(str.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_keyboard_h::kodi_gui_dialogs_keyboard_show_and_get_new_password_v1( + void* thisClassHdl, const char* password_in, char** password_out, unsigned int auto_close_ms) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str = password_in; + bool bRet = CGUIKeyboardFactory::ShowAndGetNewPassword(str, auto_close_ms); + if (bRet) + *password_out = strdup(str.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_keyboard_h:: + kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1(void* thisClassHdl, + char** password_out, + const char* heading, + bool allow_empty_result, + unsigned int auto_close_ms) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str; + bool bRet = CGUIKeyboardFactory::ShowAndVerifyNewPassword(str, heading, allow_empty_result, + auto_close_ms); + if (bRet) + *password_out = strdup(str.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_keyboard_h::kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1( + void* thisClassHdl, char** password_out, unsigned int auto_close_ms) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str; + bool bRet = CGUIKeyboardFactory::ShowAndVerifyNewPassword(str, auto_close_ms); + if (bRet) + *password_out = strdup(str.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_dialogs_keyboard_h::kodi_gui_dialogs_keyboard_show_and_verify_password_v1( + void* thisClassHdl, + const char* password_in, + char** password_out, + const char* heading, + int retries, + unsigned int auto_close_ms) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + std::string str = password_in; + int iRet = CGUIKeyboardFactory::ShowAndVerifyPassword(str, heading, retries, auto_close_ms); + if (iRet) + *password_out = strdup(str.c_str()); + return iRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_keyboard_h::kodi_gui_dialogs_keyboard_show_and_get_filter_v1( + void* thisClassHdl, + const char* text_in, + char** text_out, + bool searching, + unsigned int auto_close_ms) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str = text_in; + bool bRet = CGUIKeyboardFactory::ShowAndGetFilter(str, searching, auto_close_ms); + if (bRet) + *text_out = strdup(str.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_keyboard_h::kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1( + void* thisClassHdl, const char* text, bool close_keyboard) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CGUIKeyboardFactory::SendTextToActiveKeyboard(text, close_keyboard); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_keyboard_h::kodi_gui_dialogs_keyboard_is_keyboard_activated_v1( + void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CGUIKeyboardFactory::isKeyboardActivated(); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/keyboard.h b/xbmc/addons/interface/api/gui/dialogs/keyboard.h new file mode 100644 index 0000000000000..ee42b32a37692 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/keyboard.h @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/keyboard.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_keyboard_h; +struct directFuncToKodi_gui_dialogs_keyboard_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_dialogs_keyboard_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_keyboard_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_dialogs_keyboard_h* ifcToKodi, + directFuncToAddon_gui_dialogs_keyboard_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static bool kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1( + void* thisClassHdl, + const char* text_in, + char** text_out, + const char* heading, + bool allow_empty_result, + bool hidden_input, + unsigned int auto_close_ms); // Added with API 1 + + static bool kodi_gui_dialogs_keyboard_show_and_get_input_v1( + void* thisClassHdl, + const char* text_in, + char** text_out, + bool allow_empty_result, + unsigned int auto_close_ms); // Added with API 1 + + static bool kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1( + void* thisClassHdl, + const char* password_in, + char** password_out, + const char* heading, + bool allow_empty_result, + unsigned int auto_close_ms); // Added with API 1 + + static bool kodi_gui_dialogs_keyboard_show_and_get_new_password_v1( + void* thisClassHdl, + const char* password_in, + char** password_out, + unsigned int auto_close_ms); // Added with API 1 + + static bool kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1( + void* thisClassHdl, + char** password_out, + const char* heading, + bool allow_empty_result, + unsigned int auto_close_ms); // Added with API 1 + + static bool kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1( + void* thisClassHdl, char** password_out, unsigned int auto_close_ms); // Added with API 1 + + static int kodi_gui_dialogs_keyboard_show_and_verify_password_v1( + void* thisClassHdl, + const char* password_in, + char** password_out, + const char* heading, + int retries, + unsigned int auto_close_ms); // Added with API 1 + + static bool kodi_gui_dialogs_keyboard_show_and_get_filter_v1( + void* thisClassHdl, + const char* text_in, + char** text_out, + bool searching, + unsigned int auto_close_ms); // Added with API 1 + + static bool kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1( + void* thisClassHdl, const char* text, bool close_keyboard); // Added with API 1 + + static bool kodi_gui_dialogs_keyboard_is_keyboard_activated_v1( + void* thisClassHdl); // Added with API 1 + + directFuncToAddon_gui_dialogs_keyboard_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/numeric.cpp b/xbmc/addons/interface/api/gui/dialogs/numeric.cpp new file mode 100644 index 0000000000000..484efc9125f0b --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/numeric.cpp @@ -0,0 +1,389 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "numeric.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/dialogs/numeric.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "XBDateTime.h" +#include "dialogs/GUIDialogNumeric.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_numeric_h::InitDirect( + directFuncToKodi_gui_dialogs_numeric_h* ifcToKodi, + directFuncToAddon_gui_dialogs_numeric_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_dialogs_numeric_show_and_verify_new_password_v1 = + kodi_gui_dialogs_numeric_show_and_verify_new_password_v1; + ifcToKodi->kodi_gui_dialogs_numeric_show_and_verify_password_v1 = + kodi_gui_dialogs_numeric_show_and_verify_password_v1; + ifcToKodi->kodi_gui_dialogs_numeric_show_and_verify_input_v1 = + kodi_gui_dialogs_numeric_show_and_verify_input_v1; + ifcToKodi->kodi_gui_dialogs_numeric_show_and_get_time_v1 = + kodi_gui_dialogs_numeric_show_and_get_time_v1; + ifcToKodi->kodi_gui_dialogs_numeric_show_and_get_date_v1 = + kodi_gui_dialogs_numeric_show_and_get_date_v1; + ifcToKodi->kodi_gui_dialogs_numeric_show_and_get_ip_address_v1 = + kodi_gui_dialogs_numeric_show_and_get_ip_address_v1; + ifcToKodi->kodi_gui_dialogs_numeric_show_and_get_number_v1 = + kodi_gui_dialogs_numeric_show_and_get_number_v1; + ifcToKodi->kodi_gui_dialogs_numeric_show_and_get_seconds_v1 = + kodi_gui_dialogs_numeric_show_and_get_seconds_v1; +} + +bool CHdl_kodi_gui_dialogs_numeric_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_dialogs_numeric_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_dialogs_numeric_show_and_verify_new_password_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_verify_new_password(char** password) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_new_password_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_new_password_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_new_password_v1 t = + in.get().as(); + char* password = nullptr; + bool auto_gen_ret = kodi_gui_dialogs_numeric_show_and_verify_new_password_v1(this, &password); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_new_password_v1( + auto_gen_ret, password ? password : "")); + if (password) + free(password); + return true; + } + case funcParent_kodi_gui_dialogs_numeric_show_and_verify_password_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_dialogs_numeric_show_and_verify_password(const char* password, const char* heading, int retries) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_password_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_password_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_password_v1 t = + in.get().as(); + const std::string& password = std::get<0>(t); + const std::string& heading = std::get<1>(t); + int retries = std::get<2>(t); + int auto_gen_ret = kodi_gui_dialogs_numeric_show_and_verify_password_v1( + this, password.c_str(), heading.c_str(), retries); + msgpack::pack( + out, msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_password_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_dialogs_numeric_show_and_verify_input_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_verify_input(const char* verify_in, char** verify_out, const char* heading, bool verify_input) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_input_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_input_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_input_v1 t = + in.get().as(); + const std::string& verify_in = std::get<0>(t); + char* verify_out = nullptr; + const std::string& heading = std::get<1>(t); + bool verify_input = std::get<2>(t); + bool auto_gen_ret = kodi_gui_dialogs_numeric_show_and_verify_input_v1( + this, verify_in.c_str(), &verify_out, heading.c_str(), verify_input); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_input_v1( + auto_gen_ret, verify_out ? verify_out : "")); + if (verify_out) + free(verify_out); + return true; + } + case funcParent_kodi_gui_dialogs_numeric_show_and_get_time_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_time(struct tm* time, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_time_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_time_v1; /* Autogenerated */ + tm time; + msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_time_v1 t = in.get().as(); + std::get<0>(t).SetCStructure(&time); + const std::string& heading = std::get<1>(t); + bool auto_gen_ret = + kodi_gui_dialogs_numeric_show_and_get_time_v1(this, &time, heading.c_str()); + msgpack::pack( + out, msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_time_v1(auto_gen_ret, &time)); + return true; + } + case funcParent_kodi_gui_dialogs_numeric_show_and_get_date_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_date(struct tm* date, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_date_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_date_v1; /* Autogenerated */ + tm date; + msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_date_v1 t = in.get().as(); + std::get<0>(t).SetCStructure(&date); + const std::string& heading = std::get<1>(t); + bool auto_gen_ret = + kodi_gui_dialogs_numeric_show_and_get_date_v1(this, &date, heading.c_str()); + msgpack::pack( + out, msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_date_v1(auto_gen_ret, &date)); + return true; + } + case funcParent_kodi_gui_dialogs_numeric_show_and_get_ip_address_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_ip_address(const char* ip_address_in, char** ip_address_out, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_ip_address_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_ip_address_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_ip_address_v1 t = + in.get().as(); + const std::string& ip_address_in = std::get<0>(t); + char* ip_address_out = nullptr; + const std::string& heading = std::get<1>(t); + bool auto_gen_ret = kodi_gui_dialogs_numeric_show_and_get_ip_address_v1( + this, ip_address_in.c_str(), &ip_address_out, heading.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_ip_address_v1( + auto_gen_ret, ip_address_out ? ip_address_out : "")); + if (ip_address_out) + free(ip_address_out); + return true; + } + case funcParent_kodi_gui_dialogs_numeric_show_and_get_number_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_number(const char* number_in, char** number_out, const char* heading, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_number_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_number_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_number_v1 t = in.get().as(); + const std::string& number_in = std::get<0>(t); + char* number_out = nullptr; + const std::string& heading = std::get<1>(t); + unsigned int auto_close_ms = std::get<2>(t); + bool auto_gen_ret = kodi_gui_dialogs_numeric_show_and_get_number_v1( + this, number_in.c_str(), &number_out, heading.c_str(), auto_close_ms); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_number_v1( + auto_gen_ret, number_out ? number_out : "")); + if (number_out) + free(number_out); + return true; + } + case funcParent_kodi_gui_dialogs_numeric_show_and_get_seconds_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_seconds(const char* time_in, char** time_out, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_seconds_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_seconds_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_seconds_v1 t = in.get().as(); + const std::string& time_in = std::get<0>(t); + char* time_out = nullptr; + const std::string& heading = std::get<1>(t); + bool auto_gen_ret = kodi_gui_dialogs_numeric_show_and_get_seconds_v1( + this, time_in.c_str(), &time_out, heading.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_seconds_v1( + auto_gen_ret, time_out ? time_out : "")); + if (time_out) + free(time_out); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_numeric_h::{}: addon called with unknown function id '{}' " + "on group 'gui_dialogs_numeric_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +bool CHdl_kodi_gui_dialogs_numeric_h::kodi_gui_dialogs_numeric_show_and_verify_new_password_v1( + void* thisClassHdl, char** password) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str; + bool bRet = CGUIDialogNumeric::ShowAndVerifyNewPassword(str); + if (bRet) + *password = strdup(str.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_dialogs_numeric_h::kodi_gui_dialogs_numeric_show_and_verify_password_v1( + void* thisClassHdl, const char* password, const char* heading, int retries) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + std::string pw(password); + return CGUIDialogNumeric::ShowAndVerifyPassword(pw, heading, retries); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_numeric_h::kodi_gui_dialogs_numeric_show_and_verify_input_v1( + void* thisClassHdl, + const char* verify_in, + char** verify_out, + const char* heading, + bool verify_input) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str = verify_in; + if (CGUIDialogNumeric::ShowAndVerifyInput(str, heading, verify_input) == + InputVerificationResult::SUCCESS) + { + *verify_out = strdup(str.c_str()); + return true; + } + return false; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_numeric_h::kodi_gui_dialogs_numeric_show_and_get_time_v1( + void* thisClassHdl, struct tm* time, const char* heading) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + KODI::TIME::SystemTime systemTime; + CDateTime dateTime(*time); + dateTime.GetAsSystemTime(systemTime); + if (CGUIDialogNumeric::ShowAndGetTime(systemTime, heading)) + { + dateTime = systemTime; + dateTime.GetAsTm(*time); + return true; + } + return false; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_numeric_h::kodi_gui_dialogs_numeric_show_and_get_date_v1( + void* thisClassHdl, struct tm* date, const char* heading) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + KODI::TIME::SystemTime systemTime; + CDateTime dateTime(*date); + dateTime.GetAsSystemTime(systemTime); + if (CGUIDialogNumeric::ShowAndGetDate(systemTime, heading)) + { + dateTime = systemTime; + dateTime.GetAsTm(*date); + return true; + } + return false; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_numeric_h::kodi_gui_dialogs_numeric_show_and_get_ip_address_v1( + void* thisClassHdl, const char* ip_address_in, char** ip_address_out, const char* heading) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string strIP = ip_address_in; + bool bRet = CGUIDialogNumeric::ShowAndGetIPAddress(strIP, heading); + if (bRet) + *ip_address_out = strdup(strIP.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_numeric_h::kodi_gui_dialogs_numeric_show_and_get_number_v1( + void* thisClassHdl, + const char* number_in, + char** number_out, + const char* heading, + unsigned int auto_close_ms) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str = number_in; + bool bRet = CGUIDialogNumeric::ShowAndGetNumber(str, heading, auto_close_ms); + if (bRet) + *number_out = strdup(str.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_numeric_h::kodi_gui_dialogs_numeric_show_and_get_seconds_v1( + void* thisClassHdl, const char* time_in, char** time_out, const char* heading) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + std::string str = time_in; + bool bRet = CGUIDialogNumeric::ShowAndGetSeconds(str, heading); + if (bRet) + *time_out = strdup(str.c_str()); + return bRet; + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/numeric.h b/xbmc/addons/interface/api/gui/dialogs/numeric.h new file mode 100644 index 0000000000000..df342d05781dd --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/numeric.h @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/numeric.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_numeric_h; +struct directFuncToKodi_gui_dialogs_numeric_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_dialogs_numeric_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_numeric_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_dialogs_numeric_h* ifcToKodi, + directFuncToAddon_gui_dialogs_numeric_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static bool kodi_gui_dialogs_numeric_show_and_verify_new_password_v1( + void* thisClassHdl, char** password); // Added with API 1 + + static int kodi_gui_dialogs_numeric_show_and_verify_password_v1(void* thisClassHdl, + const char* password, + const char* heading, + int retries); // Added with API 1 + + static bool kodi_gui_dialogs_numeric_show_and_verify_input_v1( + void* thisClassHdl, + const char* verify_in, + char** verify_out, + const char* heading, + bool verify_input); // Added with API 1 + + static bool kodi_gui_dialogs_numeric_show_and_get_time_v1( + void* thisClassHdl, struct tm* time, const char* heading); // Added with API 1 + + static bool kodi_gui_dialogs_numeric_show_and_get_date_v1( + void* thisClassHdl, struct tm* date, const char* heading); // Added with API 1 + + static bool kodi_gui_dialogs_numeric_show_and_get_ip_address_v1( + void* thisClassHdl, + const char* ip_address_in, + char** ip_address_out, + const char* heading); // Added with API 1 + + static bool kodi_gui_dialogs_numeric_show_and_get_number_v1( + void* thisClassHdl, + const char* number_in, + char** number_out, + const char* heading, + unsigned int auto_close_ms); // Added with API 1 + + static bool kodi_gui_dialogs_numeric_show_and_get_seconds_v1( + void* thisClassHdl, + const char* time_in, + char** time_out, + const char* heading); // Added with API 1 + + directFuncToAddon_gui_dialogs_numeric_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/ok.cpp b/xbmc/addons/interface/api/gui/dialogs/ok.cpp new file mode 100644 index 0000000000000..ef1ee05498c8d --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/ok.cpp @@ -0,0 +1,142 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "ok.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/dialogs/ok.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "messaging/helpers/DialogOKHelper.h" +#include "utils/Variant.h" + +using namespace KODI::MESSAGING; + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_ok_h::InitDirect(directFuncToKodi_gui_dialogs_ok_h* ifcToKodi, + directFuncToAddon_gui_dialogs_ok_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_dialogs_ok_show_and_get_input_single_text_v1 = + kodi_gui_dialogs_ok_show_and_get_input_single_text_v1; + ifcToKodi->kodi_gui_dialogs_ok_show_and_get_input_line_text_v1 = + kodi_gui_dialogs_ok_show_and_get_input_line_text_v1; +} + +bool CHdl_kodi_gui_dialogs_ok_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_dialogs_ok_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_dialogs_ok_show_and_get_input_single_text_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_ok_show_and_get_input_single_text(const char* heading, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_ok_show_and_get_input_single_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_ok_show_and_get_input_single_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_ok_show_and_get_input_single_text_v1 t = + in.get().as(); + const std::string& heading = std::get<0>(t); + const std::string& text = std::get<1>(t); + kodi_gui_dialogs_ok_show_and_get_input_single_text_v1(this, heading.c_str(), text.c_str()); + return true; + } + case funcParent_kodi_gui_dialogs_ok_show_and_get_input_line_text_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_ok_show_and_get_input_line_text(const char* heading, const char* line0, const char* line1, const char* line2) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_ok_show_and_get_input_line_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_ok_show_and_get_input_line_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_ok_show_and_get_input_line_text_v1 t = + in.get().as(); + const std::string& heading = std::get<0>(t); + const std::string& line0 = std::get<1>(t); + const std::string& line1 = std::get<2>(t); + const std::string& line2 = std::get<3>(t); + kodi_gui_dialogs_ok_show_and_get_input_line_text_v1(this, heading.c_str(), line0.c_str(), + line1.c_str(), line2.c_str()); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_ok_h::{}: addon called with unknown function id '{}' on " + "group 'gui_dialogs_ok_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_dialogs_ok_h::kodi_gui_dialogs_ok_show_and_get_input_single_text_v1( + void* thisClassHdl, const char* heading, const char* text) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + HELPERS::ShowOKDialogText(CVariant{heading}, CVariant{text}); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_ok_h::kodi_gui_dialogs_ok_show_and_get_input_line_text_v1( + void* thisClassHdl, + const char* heading, + const char* line0, + const char* line1, + const char* line2) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + HELPERS::ShowOKDialogLines(CVariant{heading}, CVariant{line0}, CVariant{line1}, CVariant{line2}); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/ok.h b/xbmc/addons/interface/api/gui/dialogs/ok.h new file mode 100644 index 0000000000000..0b229642bf48a --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/ok.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/ok.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_ok_h; +struct directFuncToKodi_gui_dialogs_ok_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_dialogs_ok_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_ok_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_dialogs_ok_h* ifcToKodi, + directFuncToAddon_gui_dialogs_ok_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_dialogs_ok_show_and_get_input_single_text_v1( + void* thisClassHdl, const char* heading, const char* text); // Added with API 1 + + static void kodi_gui_dialogs_ok_show_and_get_input_line_text_v1( + void* thisClassHdl, + const char* heading, + const char* line0, + const char* line1, + const char* line2); // Added with API 1 + + directFuncToAddon_gui_dialogs_ok_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/progress.cpp b/xbmc/addons/interface/api/gui/dialogs/progress.cpp new file mode 100644 index 0000000000000..5f48f9409ebcd --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/progress.cpp @@ -0,0 +1,439 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "progress.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/dialogs/progress.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "dialogs/GUIDialogProgress.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "utils/Variant.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_progress_h::InitDirect( + directFuncToKodi_gui_dialogs_progress_h* ifcToKodi, + directFuncToAddon_gui_dialogs_progress_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_dialogs_progress_new_dialog_v1 = kodi_gui_dialogs_progress_new_dialog_v1; + ifcToKodi->kodi_gui_dialogs_progress_delete_dialog_v1 = + kodi_gui_dialogs_progress_delete_dialog_v1; + ifcToKodi->kodi_gui_dialogs_progress_open_v1 = kodi_gui_dialogs_progress_open_v1; + ifcToKodi->kodi_gui_dialogs_progress_set_heading_v1 = kodi_gui_dialogs_progress_set_heading_v1; + ifcToKodi->kodi_gui_dialogs_progress_set_line_v1 = kodi_gui_dialogs_progress_set_line_v1; + ifcToKodi->kodi_gui_dialogs_progress_set_can_cancel_v1 = + kodi_gui_dialogs_progress_set_can_cancel_v1; + ifcToKodi->kodi_gui_dialogs_progress_is_canceled_v1 = kodi_gui_dialogs_progress_is_canceled_v1; + ifcToKodi->kodi_gui_dialogs_progress_set_percentage_v1 = + kodi_gui_dialogs_progress_set_percentage_v1; + ifcToKodi->kodi_gui_dialogs_progress_get_percentage_v1 = + kodi_gui_dialogs_progress_get_percentage_v1; + ifcToKodi->kodi_gui_dialogs_progress_show_progress_bar_v1 = + kodi_gui_dialogs_progress_show_progress_bar_v1; + ifcToKodi->kodi_gui_dialogs_progress_set_progress_max_v1 = + kodi_gui_dialogs_progress_set_progress_max_v1; + ifcToKodi->kodi_gui_dialogs_progress_set_progress_advance_v1 = + kodi_gui_dialogs_progress_set_progress_advance_v1; + ifcToKodi->kodi_gui_dialogs_progress_abort_v1 = kodi_gui_dialogs_progress_abort_v1; +} + +bool CHdl_kodi_gui_dialogs_progress_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_dialogs_progress_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_dialogs_progress_new_dialog_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_HANDLE kodi_gui_dialogs_progress_new_dialog() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_new_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_new_dialog_v1; /* Autogenerated */ + KODI_GUI_HANDLE auto_gen_ret = kodi_gui_dialogs_progress_new_dialog_v1(this); + msgpack::pack(out, + msgParent_OUT_kodi_gui_dialogs_progress_new_dialog_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_dialogs_progress_delete_dialog_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_delete_dialog(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_delete_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_delete_dialog_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_delete_dialog_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_dialogs_progress_delete_dialog_v1(this, handle); + return true; + } + case funcParent_kodi_gui_dialogs_progress_open_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_open(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_open_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_open_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_dialogs_progress_open_v1(this, handle); + return true; + } + case funcParent_kodi_gui_dialogs_progress_set_heading_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_heading(KODI_GUI_HANDLE handle, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_heading_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_heading_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_set_heading_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& heading = std::get<1>(t); + kodi_gui_dialogs_progress_set_heading_v1(this, handle, heading.c_str()); + return true; + } + case funcParent_kodi_gui_dialogs_progress_set_line_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_line(KODI_GUI_HANDLE handle, unsigned int line_no, const char* line) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_line_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_line_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_set_line_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + unsigned int line_no = std::get<1>(t); + const std::string& line = std::get<2>(t); + kodi_gui_dialogs_progress_set_line_v1(this, handle, line_no, line.c_str()); + return true; + } + case funcParent_kodi_gui_dialogs_progress_set_can_cancel_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_can_cancel(KODI_GUI_HANDLE handle, bool can_cancel) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_can_cancel_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_can_cancel_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_set_can_cancel_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool can_cancel = std::get<1>(t); + kodi_gui_dialogs_progress_set_can_cancel_v1(this, handle, can_cancel); + return true; + } + case funcParent_kodi_gui_dialogs_progress_is_canceled_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_progress_is_canceled(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_is_canceled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_is_canceled_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_is_canceled_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_gui_dialogs_progress_is_canceled_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_progress_is_canceled_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_dialogs_progress_set_percentage_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_percentage(KODI_GUI_HANDLE handle, int percentage) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_percentage_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_set_percentage_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int percentage = std::get<1>(t); + kodi_gui_dialogs_progress_set_percentage_v1(this, handle, percentage); + return true; + } + case funcParent_kodi_gui_dialogs_progress_get_percentage_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_dialogs_progress_get_percentage(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_get_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_get_percentage_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_get_percentage_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_gui_dialogs_progress_get_percentage_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_progress_get_percentage_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_dialogs_progress_show_progress_bar_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_show_progress_bar(KODI_GUI_HANDLE handle, bool on_off) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_show_progress_bar_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_show_progress_bar_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_show_progress_bar_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool on_off = std::get<1>(t); + kodi_gui_dialogs_progress_show_progress_bar_v1(this, handle, on_off); + return true; + } + case funcParent_kodi_gui_dialogs_progress_set_progress_max_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_progress_max(KODI_GUI_HANDLE handle, int max) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_progress_max_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_progress_max_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_set_progress_max_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int max = std::get<1>(t); + kodi_gui_dialogs_progress_set_progress_max_v1(this, handle, max); + return true; + } + case funcParent_kodi_gui_dialogs_progress_set_progress_advance_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_progress_advance(KODI_GUI_HANDLE handle, int n_steps) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_progress_advance_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_progress_advance_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_set_progress_advance_v1 t = + in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int n_steps = std::get<1>(t); + kodi_gui_dialogs_progress_set_progress_advance_v1(this, handle, n_steps); + return true; + } + case funcParent_kodi_gui_dialogs_progress_abort_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_progress_abort(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_abort_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_abort_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_progress_abort_v1 t = in.get().as(); + KODI_GUI_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_gui_dialogs_progress_abort_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_progress_abort_v1(auto_gen_ret)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_progress_h::{}: addon called with unknown function id '{}' " + "on group 'gui_dialogs_progress_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +KODI_GUI_HANDLE CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_new_dialog_v1( + void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + // Code below must be set manually by hand to make work to Kodi + + CGUIDialogProgress* dialog = + CServiceBroker::GetGUI()->GetWindowManager().GetWindow( + WINDOW_DIALOG_PROGRESS); + if (!dialog) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_dialogs_progress_h::{} - invalid handler data (dialog='{}') on addon '{}'", + __func__, static_cast(dialog), thisClass->m_process->GetAddonID()); + return nullptr; + } + + return dialog; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_delete_dialog_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->Close(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_open_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->Open(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_set_heading_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, const char* heading) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetHeading(heading); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_set_line_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + unsigned int line_no, + const char* line) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetLine(line_no, line); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_set_can_cancel_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, bool can_cancel) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetCanCancel(can_cancel); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_is_canceled_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->IsCanceled(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_set_percentage_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, int percentage) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetPercentage(percentage); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_get_percentage_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->GetPercentage(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_show_progress_bar_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, bool on_off) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->ShowProgressBar(on_off); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_set_progress_max_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, int max) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetProgressMax(max); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_set_progress_advance_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle, int n_steps) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + static_cast(handle)->SetProgressAdvance(n_steps); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_progress_h::kodi_gui_dialogs_progress_abort_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return static_cast(handle)->Abort(); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/progress.h b/xbmc/addons/interface/api/gui/dialogs/progress.h new file mode 100644 index 0000000000000..906f02ee84fb0 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/progress.h @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/progress.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_progress_h; +struct directFuncToKodi_gui_dialogs_progress_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_dialogs_progress_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_progress_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_dialogs_progress_h* ifcToKodi, + directFuncToAddon_gui_dialogs_progress_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static KODI_GUI_HANDLE kodi_gui_dialogs_progress_new_dialog_v1( + void* thisClassHdl); // Added with API 1 + + static void kodi_gui_dialogs_progress_delete_dialog_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle); // Added with API 1 + + static void kodi_gui_dialogs_progress_open_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle); // Added with API 1 + + static void kodi_gui_dialogs_progress_set_heading_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + const char* heading); // Added with API 1 + + static void kodi_gui_dialogs_progress_set_line_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + unsigned int line_no, + const char* line); // Added with API 1 + + static void kodi_gui_dialogs_progress_set_can_cancel_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + bool can_cancel); // Added with API 1 + + static bool kodi_gui_dialogs_progress_is_canceled_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle); // Added with API 1 + + static void kodi_gui_dialogs_progress_set_percentage_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + int percentage); // Added with API 1 + + static int kodi_gui_dialogs_progress_get_percentage_v1( + void* thisClassHdl, KODI_GUI_HANDLE handle); // Added with API 1 + + static void kodi_gui_dialogs_progress_show_progress_bar_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + bool on_off); // Added with API 1 + + static void kodi_gui_dialogs_progress_set_progress_max_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + int max); // Added with API 1 + + static void kodi_gui_dialogs_progress_set_progress_advance_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle, + int n_steps); // Added with API 1 + + static bool kodi_gui_dialogs_progress_abort_v1(void* thisClassHdl, + KODI_GUI_HANDLE handle); // Added with API 1 + + directFuncToAddon_gui_dialogs_progress_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/select.cpp b/xbmc/addons/interface/api/gui/dialogs/select.cpp new file mode 100644 index 0000000000000..e73f9eb5586d7 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/select.cpp @@ -0,0 +1,232 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "select.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/dialogs/select.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "dialogs/GUIDialogSelect.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "utils/Variant.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_select_h::InitDirect(directFuncToKodi_gui_dialogs_select_h* ifcToKodi, + directFuncToAddon_gui_dialogs_select_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_dialogs_select_open_v1 = kodi_gui_dialogs_select_open_v1; + ifcToKodi->kodi_gui_dialogs_select_open_multi_select_v1 = + kodi_gui_dialogs_select_open_multi_select_v1; +} + +bool CHdl_kodi_gui_dialogs_select_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_dialogs_select_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_dialogs_select_open_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_dialogs_select_open(const char* heading, const char* entries[], size_t size, int selected, unsigned int autoclose) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple, size_t, int, unsigned int> msgParent__IN_kodi_gui_dialogs_select_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_select_open_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_select_open_v1 t = in.get().as(); + const std::string& heading = std::get<0>(t); + const std::vector& cpp_entries = std::get<1>(t); + size_t size = std::get<2>(t); + int selected = std::get<3>(t); + unsigned int autoclose = std::get<4>(t); + + std::vector entries; + entries.reserve(size); + for (size_t i = 0; i < size; ++i) + { + entries.emplace_back(cpp_entries[i].c_str()); + } + assert(cpp_entries.size() == size); + + int auto_gen_ret = kodi_gui_dialogs_select_open_v1(this, heading.c_str(), entries.data(), + size, selected, autoclose); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_select_open_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_dialogs_select_open_multi_select_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_select_open_multi_select(const char* heading, const char* entryIDs[], const char* entryNames[], uint8_t entriesSelected[], size_t size, unsigned int autoclose) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple, std::vector, std::vector, size_t, unsigned int> msgParent__IN_kodi_gui_dialogs_select_open_multi_select_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple> msgParent_OUT_kodi_gui_dialogs_select_open_multi_select_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_select_open_multi_select_v1 t = in.get().as(); + const std::string& heading = std::get<0>(t); + const std::vector& cpp_entryIDs = std::get<1>(t); + const std::vector& cpp_entryNames = std::get<2>(t); + std::vector& entriesSelected = std::get<3>(t); + size_t size = std::get<4>(t); + unsigned int autoclose = std::get<5>(t); + + std::vector entryIDs; + entryIDs.reserve(size); + for (size_t i = 0; i < size; ++i) + { + entryIDs.emplace_back(cpp_entryIDs[i].c_str()); + } + assert(cpp_entryIDs.size() == size); + + std::vector entryNames; + entryNames.reserve(size); + for (size_t i = 0; i < size; ++i) + { + entryNames.emplace_back(cpp_entryNames[i].c_str()); + } + assert(cpp_entryNames.size() == size); + + bool auto_gen_ret = kodi_gui_dialogs_select_open_multi_select_v1( + this, heading.c_str(), entryIDs.data(), entryNames.data(), entriesSelected.data(), size, + autoclose); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_select_open_multi_select_v1( + auto_gen_ret, entriesSelected)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_select_h::{}: addon called with unknown function id '{}' on " + "group 'gui_dialogs_select_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +int CHdl_kodi_gui_dialogs_select_h::kodi_gui_dialogs_select_open_v1(void* thisClassHdl, + const char* heading, + const char* entries[], + size_t size, + int selected, + unsigned int autoclose) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + CGUIDialogSelect* dialog = + CServiceBroker::GetGUI()->GetWindowManager().GetWindow( + WINDOW_DIALOG_SELECT); + + dialog->Reset(); + dialog->SetHeading(CVariant{heading}); + + for (unsigned int i = 0; i < size; ++i) + dialog->Add(entries[i]); + + if (selected > 0) + dialog->SetSelected(selected); + if (autoclose > 0) + dialog->SetAutoClose(autoclose); + + dialog->Open(); + return dialog->GetSelectedItem(); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_select_h::kodi_gui_dialogs_select_open_multi_select_v1( + void* thisClassHdl, + const char* heading, + const char* entryIDs[], + const char* entryNames[], + uint8_t entriesSelected[], + size_t size, + unsigned int autoclose) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CGUIDialogSelect* dialog = + CServiceBroker::GetGUI()->GetWindowManager().GetWindow( + WINDOW_DIALOG_SELECT); + dialog->Reset(); + dialog->SetMultiSelection(true); + dialog->SetHeading(CVariant{heading}); + + std::vector selectedIndexes; + + for (unsigned int i = 0; i < size; ++i) + { + dialog->Add(entryNames[i]); + if (entriesSelected[i]) + selectedIndexes.push_back(i); + } + + dialog->SetSelected(selectedIndexes); + if (autoclose > 0) + dialog->SetAutoClose(autoclose); + + dialog->Open(); + if (dialog->IsConfirmed()) + { + for (unsigned int i = 0; i < size; ++i) + entriesSelected[i] = 0; + + selectedIndexes = dialog->GetSelectedItems(); + + for (unsigned int i = 0; i < selectedIndexes.size(); ++i) + { + if (selectedIndexes[i]) + entriesSelected[selectedIndexes[i]] = 1; + } + } + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/select.h b/xbmc/addons/interface/api/gui/dialogs/select.h new file mode 100644 index 0000000000000..90372424cbefb --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/select.h @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/select.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_select_h; +struct directFuncToKodi_gui_dialogs_select_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_dialogs_select_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_select_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_dialogs_select_h* ifcToKodi, + directFuncToAddon_gui_dialogs_select_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static int kodi_gui_dialogs_select_open_v1(void* thisClassHdl, + const char* heading, + const char* entries[], + size_t size, + int selected, + unsigned int autoclose); // Added with API 1 + + static bool kodi_gui_dialogs_select_open_multi_select_v1( + void* thisClassHdl, + const char* heading, + const char* entryIDs[], + const char* entryNames[], + uint8_t entriesSelected[], + size_t size, + unsigned int autoclose); // Added with API 1 + + directFuncToAddon_gui_dialogs_select_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/text_viewer.cpp b/xbmc/addons/interface/api/gui/dialogs/text_viewer.cpp new file mode 100644 index 0000000000000..ec4d59b12c2b0 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/text_viewer.cpp @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "text_viewer.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/dialogs/text_viewer.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +#include "dialogs/GUIDialogTextViewer.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_text_viewer_h::InitDirect( + directFuncToKodi_gui_dialogs_text_viewer_h* ifcToKodi, + directFuncToAddon_gui_dialogs_text_viewer_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_dialogs_text_viewer_show_v1 = kodi_gui_dialogs_text_viewer_show_v1; +} + +bool CHdl_kodi_gui_dialogs_text_viewer_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_dialogs_text_viewer_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_dialogs_text_viewer_show_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_text_viewer_show(const char* heading, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_text_viewer_show_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_text_viewer_show_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_text_viewer_show_v1 t = in.get().as(); + const std::string& heading = std::get<0>(t); + const std::string& text = std::get<1>(t); + kodi_gui_dialogs_text_viewer_show_v1(this, heading.c_str(), text.c_str()); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_text_viewer_h::{}: addon called with unknown function id " + "'{}' on group 'gui_dialogs_text_viewer_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_dialogs_text_viewer_h::kodi_gui_dialogs_text_viewer_show_v1(void* thisClassHdl, + const char* heading, + const char* text) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIDialogTextViewer* dialog = + CServiceBroker::GetGUI()->GetWindowManager().GetWindow( + WINDOW_DIALOG_TEXT_VIEWER); + if (!heading || !text || !dialog) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_dialogs_text_viewer_h::{} - invalid handler data (heading='{}', text='{}', " + "dialog='{}') on addon '{}'", + __func__, static_cast(heading), static_cast(text), + static_cast(dialog), thisClass->m_process->GetAddonID()); + return; + } + + dialog->SetHeading(heading); + dialog->SetText(text); + dialog->Open(); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/text_viewer.h b/xbmc/addons/interface/api/gui/dialogs/text_viewer.h new file mode 100644 index 0000000000000..2b5b130e12d51 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/text_viewer.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/text_viewer.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_text_viewer_h; +struct directFuncToKodi_gui_dialogs_text_viewer_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_dialogs_text_viewer_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_text_viewer_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_dialogs_text_viewer_h* ifcToKodi, + directFuncToAddon_gui_dialogs_text_viewer_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_dialogs_text_viewer_show_v1(void* thisClassHdl, + const char* heading, + const char* text); // Added with API 1 + + directFuncToAddon_gui_dialogs_text_viewer_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/yes_no.cpp b/xbmc/addons/interface/api/gui/dialogs/yes_no.cpp new file mode 100644 index 0000000000000..6f39dbf43593b --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/yes_no.cpp @@ -0,0 +1,251 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "yes_no.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/dialogs/yes_no.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "dialogs/GUIDialogYesNo.h" +#include "messaging/helpers/DialogHelper.h" + +using namespace KODI::MESSAGING; +using KODI::MESSAGING::HELPERS::DialogResponse; + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_yes_no_h::InitDirect(directFuncToKodi_gui_dialogs_yes_no_h* ifcToKodi, + directFuncToAddon_gui_dialogs_yes_no_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1 = + kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1; + ifcToKodi->kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1 = + kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1; + ifcToKodi->kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1 = + kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1; +} + +bool CHdl_kodi_gui_dialogs_yes_no_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_dialogs_yes_no_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_single_text(const char* heading, const char* text, bool* canceled, const char* noLabel, const char* yesLabel) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1 t = + in.get().as(); + const std::string& heading = std::get<0>(t); + const std::string& text = std::get<1>(t); + bool canceled = std::get<2>(t); + const std::string& noLabel = std::get<3>(t); + const std::string& yesLabel = std::get<4>(t); + bool auto_gen_ret = kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1( + this, heading.c_str(), text.c_str(), &canceled, noLabel.c_str(), yesLabel.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1( + auto_gen_ret, canceled)); + return true; + } + case funcParent_kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_line_text(const char* heading, const char* line0, const char* line1, const char* line2, const char* noLabel, const char* yesLabel) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1 t = + in.get().as(); + const std::string& heading = std::get<0>(t); + const std::string& line0 = std::get<1>(t); + const std::string& line1 = std::get<2>(t); + const std::string& line2 = std::get<3>(t); + const std::string& noLabel = std::get<4>(t); + const std::string& yesLabel = std::get<5>(t); + bool auto_gen_ret = kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1( + this, heading.c_str(), line0.c_str(), line1.c_str(), line2.c_str(), noLabel.c_str(), + yesLabel.c_str()); + msgpack::pack( + out, msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_line_button_text( const char* heading, const char* line0, const char* line1, const char* line2, bool* canceled, const char* noLabel, const char* yesLabel) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1 t = + in.get().as(); + const std::string& heading = std::get<0>(t); + const std::string& line0 = std::get<1>(t); + const std::string& line1 = std::get<2>(t); + const std::string& line2 = std::get<3>(t); + bool canceled = std::get<4>(t); + const std::string& noLabel = std::get<5>(t); + const std::string& yesLabel = std::get<6>(t); + bool auto_gen_ret = kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1( + this, heading.c_str(), line0.c_str(), line1.c_str(), line2.c_str(), &canceled, + noLabel.c_str(), yesLabel.c_str()); + msgpack::pack(out, + msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1( + auto_gen_ret, canceled)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_yes_no_h::{}: addon called with unknown function id '{}' on " + "group 'gui_dialogs_yes_no_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +bool CHdl_kodi_gui_dialogs_yes_no_h::kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1( + void* thisClassHdl, + const char* heading, + const char* text, + bool* canceled, + const char* noLabel, + const char* yesLabel) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + if (!heading || !text || !canceled || !noLabel || !yesLabel) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_dialogs_yes_no_h::{} - invalid handler data (heading='{}', text='{}', " + "canceled='{}', noLabel='{}', yesLabel='{}') on addon '{}'", + __func__, static_cast(heading), static_cast(text), + static_cast(canceled), static_cast(noLabel), + static_cast(yesLabel), thisClass->m_process->GetAddonID()); + return false; + } + + DialogResponse result = HELPERS::ShowYesNoDialogText(heading, text, noLabel, yesLabel); + *canceled = (result == DialogResponse::CHOICE_CANCELLED); + return (result == DialogResponse::CHOICE_YES); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_yes_no_h::kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1( + void* thisClassHdl, + const char* heading, + const char* line0, + const char* line1, + const char* line2, + const char* noLabel, + const char* yesLabel) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + if (!heading || !line0 || !line1 || !line2 || !noLabel || !yesLabel) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_dialogs_yes_no_h::{} - invalid handler data (heading='{}', line0='{}', " + "line1='{}', line2='{}', " + "noLabel='{}', yesLabel='{}') on addon '{}'", + __func__, static_cast(heading), static_cast(line0), + static_cast(line1), static_cast(line2), + static_cast(noLabel), static_cast(yesLabel), + thisClass->m_process->GetAddonID()); + return false; + } + + return HELPERS::ShowYesNoDialogLines(heading, line0, line1, line2, noLabel, yesLabel) == + DialogResponse::CHOICE_YES; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_dialogs_yes_no_h::kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1( + void* thisClassHdl, + const char* heading, + const char* line0, + const char* line1, + const char* line2, + bool* canceled, + const char* noLabel, + const char* yesLabel) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + if (!heading || !line0 || !line1 || !line2 || !canceled || !noLabel || !yesLabel) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_dialogs_yes_no_h::{} - invalid handler data (heading='{}', line0='{}', " + "line1='{}', line2='{}', " + "canceled='{}', noLabel='{}', yesLabel='{}') on addon '{}'", + __func__, static_cast(heading), static_cast(line0), + static_cast(line1), static_cast(line2), + static_cast(canceled), static_cast(noLabel), + static_cast(yesLabel), thisClass->m_process->GetAddonID()); + return false; + } + + DialogResponse result = + HELPERS::ShowYesNoDialogLines(heading, line0, line1, line2, noLabel, yesLabel); + *canceled = (result == DialogResponse::CHOICE_CANCELLED); + return (result == DialogResponse::CHOICE_YES); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/dialogs/yes_no.h b/xbmc/addons/interface/api/gui/dialogs/yes_no.h new file mode 100644 index 0000000000000..b4d5b3e5614e4 --- /dev/null +++ b/xbmc/addons/interface/api/gui/dialogs/yes_no.h @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/yes_no.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_yes_no_h; +struct directFuncToKodi_gui_dialogs_yes_no_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_dialogs_yes_no_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_yes_no_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_dialogs_yes_no_h* ifcToKodi, + directFuncToAddon_gui_dialogs_yes_no_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static bool kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1( + void* thisClassHdl, + const char* heading, + const char* text, + bool* canceled, + const char* noLabel, + const char* yesLabel); // Added with API 1 + + static bool kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1( + void* thisClassHdl, + const char* heading, + const char* line0, + const char* line1, + const char* line2, + const char* noLabel, + const char* yesLabel); // Added with API 1 + + static bool kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1( + void* thisClassHdl, + const char* heading, + const char* line0, + const char* line1, + const char* line2, + bool* canceled, + const char* noLabel, + const char* yesLabel); // Added with API 1 + + directFuncToAddon_gui_dialogs_yes_no_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/general.cpp b/xbmc/addons/interface/api/gui/general.cpp new file mode 100644 index 0000000000000..77d4e231e193c --- /dev/null +++ b/xbmc/addons/interface/api/gui/general.cpp @@ -0,0 +1,283 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "general.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/general.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "ServiceBroker.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +int CHdl_kodi_gui_general_h::m_iAddonGUILockRef = 0; + +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_general_h::InitDirect(directFuncToKodi_gui_general_h* ifcToKodi, + directFuncToAddon_gui_general_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_lock_v1 = kodi_gui_lock_v1; + ifcToKodi->kodi_gui_unlock_v1 = kodi_gui_unlock_v1; + ifcToKodi->kodi_gui_get_screen_height_v1 = kodi_gui_get_screen_height_v1; + ifcToKodi->kodi_gui_get_screen_width_v1 = kodi_gui_get_screen_width_v1; + ifcToKodi->kodi_gui_get_video_resolution_v1 = kodi_gui_get_video_resolution_v1; + ifcToKodi->kodi_gui_get_current_window_dialog_id_v1 = kodi_gui_get_current_window_dialog_id_v1; + ifcToKodi->kodi_gui_get_current_window_id_v1 = kodi_gui_get_current_window_id_v1; + ifcToKodi->kodi_gui_get_hw_context_v1 = kodi_gui_get_hw_context_v1; +} + +bool CHdl_kodi_gui_general_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_general_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_lock_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_lock() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_lock_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_lock_v1; /* Autogenerated */ + kodi_gui_lock_v1(this); + return true; + } + case funcParent_kodi_gui_unlock_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_unlock() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_unlock_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_unlock_v1; /* Autogenerated */ + kodi_gui_unlock_v1(this); + return true; + } + case funcParent_kodi_gui_get_screen_height_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_get_screen_height() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_screen_height_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_screen_height_v1; /* Autogenerated */ + int auto_gen_ret = kodi_gui_get_screen_height_v1(this); + msgpack::pack(out, msgParent_OUT_kodi_gui_get_screen_height_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_get_screen_width_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_get_screen_width() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_screen_width_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_screen_width_v1; /* Autogenerated */ + int auto_gen_ret = kodi_gui_get_screen_width_v1(this); + msgpack::pack(out, msgParent_OUT_kodi_gui_get_screen_width_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_get_video_resolution_v1: + { + // Original API call: ATTR_DLL_EXPORT float kodi_gui_get_video_resolution() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_video_resolution_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_video_resolution_v1; /* Autogenerated */ + float auto_gen_ret = kodi_gui_get_video_resolution_v1(this); + msgpack::pack(out, msgParent_OUT_kodi_gui_get_video_resolution_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_get_current_window_dialog_id_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_get_current_window_dialog_id() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_current_window_dialog_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_current_window_dialog_id_v1; /* Autogenerated */ + int auto_gen_ret = kodi_gui_get_current_window_dialog_id_v1(this); + msgpack::pack(out, msgParent_OUT_kodi_gui_get_current_window_dialog_id_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_get_current_window_id_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_get_current_window_id() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_current_window_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_current_window_id_v1; /* Autogenerated */ + int auto_gen_ret = kodi_gui_get_current_window_id_v1(this); + msgpack::pack(out, msgParent_OUT_kodi_gui_get_current_window_id_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_get_hw_context_v1: + { + // Original API call: ATTR_DLL_EXPORT ADDON_HARDWARE_CONTEXT kodi_gui_get_hw_context() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_hw_context_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_hw_context_v1; /* Autogenerated */ + ADDON_HARDWARE_CONTEXT auto_gen_ret = kodi_gui_get_hw_context_v1(this); + msgpack::pack(out, msgParent_OUT_kodi_gui_get_hw_context_v1(PtrValue(auto_gen_ret))); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_general_h::{}: addon called with unknown function id '{}' on group " + "'gui_general_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +void CHdl_kodi_gui_general_h::kodi_gui_lock_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + lock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_general_h::kodi_gui_unlock_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_general_h::kodi_gui_get_screen_height_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return CServiceBroker::GetWinSystem()->GetGfxContext().GetHeight(); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_general_h::kodi_gui_get_screen_width_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth(); + + /*---AUTO_GEN_PARSE---*/ +} + +float CHdl_kodi_gui_general_h::kodi_gui_get_video_resolution_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0f; + + /*---AUTO_GEN_PARSE---*/ + + return (int)CServiceBroker::GetWinSystem()->GetGfxContext().GetVideoResolution(); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_general_h::kodi_gui_get_current_window_dialog_id_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + return (int)CServiceBroker::GetWinSystem()->GetGfxContext().GetVideoResolution(); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_general_h::kodi_gui_get_current_window_id_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + std::unique_lock lock(CServiceBroker::GetWinSystem()->GetGfxContext()); + return CServiceBroker::GetGUI()->GetWindowManager().GetTopmostModalDialog(); + + /*---AUTO_GEN_PARSE---*/ +} + +ADDON_HARDWARE_CONTEXT CHdl_kodi_gui_general_h::kodi_gui_get_hw_context_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return CServiceBroker::GetWinSystem()->GetHWContext(); + ; + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_general_h::lock() +{ + if (m_iAddonGUILockRef == 0) + CServiceBroker::GetWinSystem()->GetGfxContext().lock(); + ++m_iAddonGUILockRef; +} + +void CHdl_kodi_gui_general_h::unlock() +{ + if (m_iAddonGUILockRef > 0) + { + --m_iAddonGUILockRef; + if (m_iAddonGUILockRef == 0) + CServiceBroker::GetWinSystem()->GetGfxContext().unlock(); + } +} + +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/general.h b/xbmc/addons/interface/api/gui/general.h new file mode 100644 index 0000000000000..443158339a97d --- /dev/null +++ b/xbmc/addons/interface/api/gui/general.h @@ -0,0 +1,86 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/general.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_general_h; +struct directFuncToKodi_gui_general_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_general_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_general_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_general_h* ifcToKodi, + directFuncToAddon_gui_general_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + static void lock(); + static void unlock(); + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + static int m_iAddonGUILockRef; + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static void kodi_gui_lock_v1(void* thisClassHdl); // Added with API 1 + + static void kodi_gui_unlock_v1(void* thisClassHdl); // Added with API 1 + + static int kodi_gui_get_screen_height_v1(void* thisClassHdl); // Added with API 1 + + static int kodi_gui_get_screen_width_v1(void* thisClassHdl); // Added with API 1 + + static float kodi_gui_get_video_resolution_v1(void* thisClassHdl); // Added with API 1 + + static int kodi_gui_get_current_window_dialog_id_v1(void* thisClassHdl); // Added with API 1 + + static int kodi_gui_get_current_window_id_v1(void* thisClassHdl); // Added with API 1 + + static ADDON_HARDWARE_CONTEXT kodi_gui_get_hw_context_v1(void* thisClassHdl); // Added with API 1 + + directFuncToAddon_gui_general_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/list_item.cpp b/xbmc/addons/interface/api/gui/list_item.cpp new file mode 100644 index 0000000000000..2cea08762c7c6 --- /dev/null +++ b/xbmc/addons/interface/api/gui/list_item.cpp @@ -0,0 +1,624 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "list_item.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/list_item.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "FileItem.h" +#include "general.h" +#include "utils/StringUtils.h" +#include "utils/Variant.h" + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_list_item_h::InitDirect(directFuncToKodi_gui_list_item_h* ifcToKodi, + directFuncToAddon_gui_list_item_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_listitem_create_v1 = kodi_gui_listitem_create_v1; + ifcToKodi->kodi_gui_listitem_destroy_v1 = kodi_gui_listitem_destroy_v1; + ifcToKodi->kodi_gui_listitem_get_label_v1 = kodi_gui_listitem_get_label_v1; + ifcToKodi->kodi_gui_listitem_set_label_v1 = kodi_gui_listitem_set_label_v1; + ifcToKodi->kodi_gui_listitem_get_label2_v1 = kodi_gui_listitem_get_label2_v1; + ifcToKodi->kodi_gui_listitem_set_label2_v1 = kodi_gui_listitem_set_label2_v1; + ifcToKodi->kodi_gui_listitem_get_art_v1 = kodi_gui_listitem_get_art_v1; + ifcToKodi->kodi_gui_listitem_set_art_v1 = kodi_gui_listitem_set_art_v1; + ifcToKodi->kodi_gui_listitem_get_path_v1 = kodi_gui_listitem_get_path_v1; + ifcToKodi->kodi_gui_listitem_set_path_v1 = kodi_gui_listitem_set_path_v1; + ifcToKodi->kodi_gui_listitem_get_property_v1 = kodi_gui_listitem_get_property_v1; + ifcToKodi->kodi_gui_listitem_set_property_v1 = kodi_gui_listitem_set_property_v1; + ifcToKodi->kodi_gui_listitem_select_v1 = kodi_gui_listitem_select_v1; + ifcToKodi->kodi_gui_listitem_is_selected_v1 = kodi_gui_listitem_is_selected_v1; +} + +bool CHdl_kodi_gui_list_item_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_list_item_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_listitem_create_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_LISTITEM_HANDLE kodi_gui_listitem_create(const char* label, const char* label2, const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_create_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_create_v1 t = in.get().as(); + const std::string& label = std::get<0>(t); + const std::string& label2 = std::get<1>(t); + const std::string& path = std::get<2>(t); + KODI_GUI_LISTITEM_HANDLE auto_gen_ret = + kodi_gui_listitem_create_v1(this, label.c_str(), label2.c_str(), path.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_gui_listitem_create_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_listitem_destroy_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_destroy(KODI_GUI_LISTITEM_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_destroy_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_destroy_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_destroy_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_listitem_destroy_v1(this, handle); + return true; + } + case funcParent_kodi_gui_listitem_get_label_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_listitem_get_label(KODI_GUI_LISTITEM_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_get_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_get_label_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_listitem_get_label_v1(this, handle); + msgpack::pack(out, + msgParent_OUT_kodi_gui_listitem_get_label_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_listitem_set_label_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_set_label(KODI_GUI_LISTITEM_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_set_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_set_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_set_label_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& label = std::get<1>(t); + kodi_gui_listitem_set_label_v1(this, handle, label.c_str()); + return true; + } + case funcParent_kodi_gui_listitem_get_label2_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_listitem_get_label2(KODI_GUI_LISTITEM_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_get_label2_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_get_label2_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_get_label2_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_listitem_get_label2_v1(this, handle); + msgpack::pack( + out, msgParent_OUT_kodi_gui_listitem_get_label2_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_listitem_set_label2_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_set_label2(KODI_GUI_LISTITEM_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_set_label2_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_set_label2_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_set_label2_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& label = std::get<1>(t); + kodi_gui_listitem_set_label2_v1(this, handle, label.c_str()); + return true; + } + case funcParent_kodi_gui_listitem_get_art_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_listitem_get_art(KODI_GUI_LISTITEM_HANDLE handle, const char* type) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_get_art_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_get_art_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_get_art_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& type = std::get<1>(t); + char* auto_gen_ret = kodi_gui_listitem_get_art_v1(this, handle, type.c_str()); + msgpack::pack(out, + msgParent_OUT_kodi_gui_listitem_get_art_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_listitem_set_art_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_set_art(KODI_GUI_LISTITEM_HANDLE handle, const char* type, const char* image) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_set_art_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_set_art_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_set_art_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& type = std::get<1>(t); + const std::string& image = std::get<2>(t); + kodi_gui_listitem_set_art_v1(this, handle, type.c_str(), image.c_str()); + return true; + } + case funcParent_kodi_gui_listitem_get_path_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_listitem_get_path(KODI_GUI_LISTITEM_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_get_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_get_path_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_get_path_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + char* auto_gen_ret = kodi_gui_listitem_get_path_v1(this, handle); + msgpack::pack(out, + msgParent_OUT_kodi_gui_listitem_get_path_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_listitem_set_path_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_set_path(KODI_GUI_LISTITEM_HANDLE handle, const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_set_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_set_path_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_set_path_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& path = std::get<1>(t); + kodi_gui_listitem_set_path_v1(this, handle, path.c_str()); + return true; + } + case funcParent_kodi_gui_listitem_get_property_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_listitem_get_property(KODI_GUI_LISTITEM_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_get_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_get_property_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_get_property_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + char* auto_gen_ret = kodi_gui_listitem_get_property_v1(this, handle, key.c_str()); + msgpack::pack( + out, msgParent_OUT_kodi_gui_listitem_get_property_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_listitem_set_property_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_set_property(KODI_GUI_LISTITEM_HANDLE handle, const char* key, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_set_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_set_property_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_set_property_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + const std::string& value = std::get<2>(t); + kodi_gui_listitem_set_property_v1(this, handle, key.c_str(), value.c_str()); + return true; + } + case funcParent_kodi_gui_listitem_select_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_select(KODI_GUI_LISTITEM_HANDLE handle, bool select) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_select_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_select_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_select_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool select = std::get<1>(t); + kodi_gui_listitem_select_v1(this, handle, select); + return true; + } + case funcParent_kodi_gui_listitem_is_selected_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_listitem_is_selected(KODI_GUI_LISTITEM_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_is_selected_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_is_selected_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_listitem_is_selected_v1 t = in.get().as(); + KODI_GUI_LISTITEM_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_gui_listitem_is_selected_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_listitem_is_selected_v1(auto_gen_ret)); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_list_item_h::{}: addon called with unknown function id '{}' on " + "group 'gui_list_item_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +KODI_GUI_LISTITEM_HANDLE CHdl_kodi_gui_list_item_h::kodi_gui_listitem_create_v1(void* thisClassHdl, + const char* label, + const char* label2, + const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = new CFileItemPtr(new CFileItem()); + if (label) + item->get()->SetLabel(label); + if (label2) + item->get()->SetLabel2(label2); + if (path) + item->get()->SetPath(path); + + return item; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_list_item_h::kodi_gui_listitem_destroy_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item) + delete item; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_list_item_h::kodi_gui_listitem_get_label_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return nullptr; + } + + char* ret; + CHdl_kodi_gui_general_h::lock(); + ret = strdup(item->get()->GetLabel().c_str()); + CHdl_kodi_gui_general_h::unlock(); + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_list_item_h::kodi_gui_listitem_set_label_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* label) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + item->get()->SetLabel(label); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_list_item_h::kodi_gui_listitem_get_label2_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return nullptr; + } + + char* ret; + CHdl_kodi_gui_general_h::lock(); + ret = strdup(item->get()->GetLabel2().c_str()); + CHdl_kodi_gui_general_h::unlock(); + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_list_item_h::kodi_gui_listitem_set_label2_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* label) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + item->get()->SetLabel2(label); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_list_item_h::kodi_gui_listitem_get_art_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* type) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return nullptr; + } + + char* ret; + CHdl_kodi_gui_general_h::lock(); + ret = strdup(item->get()->GetArt(type).c_str()); + CHdl_kodi_gui_general_h::unlock(); + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_list_item_h::kodi_gui_listitem_set_art_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* type, + const char* image) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + item->get()->SetArt(type, image); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_list_item_h::kodi_gui_listitem_get_path_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return nullptr; + } + + char* ret; + CHdl_kodi_gui_general_h::lock(); + ret = strdup(item->get()->GetPath().c_str()); + CHdl_kodi_gui_general_h::unlock(); + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_list_item_h::kodi_gui_listitem_set_path_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* path) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + item->get()->SetPath(path); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_list_item_h::kodi_gui_listitem_get_property_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* key) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return nullptr; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + char* ret = strdup(item->get()->GetProperty(lowerKey).asString().c_str()); + CHdl_kodi_gui_general_h::unlock(); + + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_list_item_h::kodi_gui_listitem_set_property_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* key, + const char* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + item->get()->SetProperty(lowerKey, CVariant(value)); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_list_item_h::kodi_gui_listitem_select_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + bool select) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + item->get()->Select(select); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_list_item_h::kodi_gui_listitem_is_selected_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CFileItemPtr* item = static_cast(handle); + if (item->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_list_item_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return false; + } + + CHdl_kodi_gui_general_h::lock(); + bool ret = item->get()->IsSelected(); + CHdl_kodi_gui_general_h::unlock(); + + return ret; + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/list_item.h b/xbmc/addons/interface/api/gui/list_item.h new file mode 100644 index 0000000000000..3a74eb94e096f --- /dev/null +++ b/xbmc/addons/interface/api/gui/list_item.h @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/list_item.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_list_item_h; +struct directFuncToKodi_gui_list_item_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_list_item_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_list_item_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_list_item_h* ifcToKodi, + directFuncToAddon_gui_list_item_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static KODI_GUI_LISTITEM_HANDLE kodi_gui_listitem_create_v1(void* thisClassHdl, + const char* label, + const char* label2, + const char* path); // Added with API 1 + + static void kodi_gui_listitem_destroy_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle); // Added with API 1 + + static char* kodi_gui_listitem_get_label_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle); // Added with API 1 + + static void kodi_gui_listitem_set_label_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* label); // Added with API 1 + + static char* kodi_gui_listitem_get_label2_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle); // Added with API 1 + + static void kodi_gui_listitem_set_label2_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* label); // Added with API 1 + + static char* kodi_gui_listitem_get_art_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* type); // Added with API 1 + + static void kodi_gui_listitem_set_art_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* type, + const char* image); // Added with API 1 + + static char* kodi_gui_listitem_get_path_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle); // Added with API 1 + + static void kodi_gui_listitem_set_path_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* path); // Added with API 1 + + static char* kodi_gui_listitem_get_property_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* key); // Added with API 1 + + static void kodi_gui_listitem_set_property_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + const char* key, + const char* value); // Added with API 1 + + static void kodi_gui_listitem_select_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle, + bool select); // Added with API 1 + + static bool kodi_gui_listitem_is_selected_v1(void* thisClassHdl, + KODI_GUI_LISTITEM_HANDLE handle); // Added with API 1 + + directFuncToAddon_gui_list_item_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/window.cpp b/xbmc/addons/interface/api/gui/window.cpp new file mode 100644 index 0000000000000..3cb709615ad37 --- /dev/null +++ b/xbmc/addons/interface/api/gui/window.cpp @@ -0,0 +1,2324 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "window.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/gui/window.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "Application.h" +#include "FileItem.h" +#include "ServiceBroker.h" +#include "addons/Skin.h" +#include "addons/interface/tools/GUITranslator.h" +#include "general.h" +// #include "controls/Rendering.h" +#include "filesystem/File.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIRenderingControl.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/TextureManager.h" +#include "input/Key.h" +#include "messaging/ApplicationMessenger.h" +#include "threads/Event.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/Variant.h" + +using namespace ADDON; +using namespace KODI::MESSAGING; + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +CGUIAddonWindow::CGUIAddonWindow(int id, + const std::string& strXML, + std::shared_ptr addon, + bool isMedia) + : CGUIMediaWindow(id, strXML.c_str()), + m_windowId(id), + m_oldWindowId(0), + m_addon(addon), + m_isMedia(isMedia) +{ + m_loadType = LOAD_ON_GUI_INIT; +} + +CGUIControl* CGUIAddonWindow::GetAddonControl(int controlId, + CGUIControl::GUICONTROLTYPES type, + const std::string& typeName) +{ + // Load window resources, if not already done, to have related xml content + // present and to let control find it + if (!m_windowLoaded) + { + if (!Initialize()) + { + CLog::Log(LOGERROR, + "CGUIAddonGUI_Window::{}: {} - Window initialize failed by control id '{}' request " + "for '{}'", + __func__, m_addon->Name(), controlId, typeName); + return nullptr; + } + } + + CGUIControl* pGUIControl = GetControl(controlId); + if (!pGUIControl) + { + CLog::Log(LOGERROR, + "CGUIAddonGUI_Window::{}: {} - Requested GUI control Id '{}' for '{}' not present!", + __func__, m_addon->Name(), controlId, typeName); + return nullptr; + } + else if (pGUIControl->GetControlType() != type) + { + CLog::Log(LOGERROR, + "CGUIAddonGUI_Window::{}: {} - Requested GUI control Id '{}' not the type '{}'!", + __func__, m_addon->Name(), controlId, typeName); + return nullptr; + } + + return pGUIControl; +} + +bool CGUIAddonWindow::OnAction(const CAction& action) +{ + // Let addon decide whether it wants to handle action first + if (CBOnAction) + { + // Let addon decide whether it wants to handle action first + KODI_ADDON_ACTION_DATA actionAddon; + actionAddon.id = CAddonGUITranslator::TranslateActionIdToAddon(action.GetID()); + actionAddon.name = action.GetName().c_str(); + actionAddon.repeat = action.GetRepeat(); + actionAddon.hold_time = action.GetHoldTime(); + actionAddon.button_code = action.GetButtonCode(); + actionAddon.unicode = action.GetUnicode(); + actionAddon.text = action.GetText().c_str(); + for (unsigned int i = 0; i < ADDON_ACTION_AMOUNT_MAX; i++) + actionAddon.amount[i] = action.GetAmount(i); + + if (CBOnAction(m_clientHandle, &actionAddon)) + return true; + } + + return CGUIWindow::OnAction(action); +} +bool CGUIAddonWindow::OnMessage(CGUIMessage& message) +{ + switch (message.GetMessage()) + { + case GUI_MSG_WINDOW_DEINIT: + { + return CGUIMediaWindow::OnMessage(message); + } + break; + + case GUI_MSG_WINDOW_INIT: + { + CGUIMediaWindow::OnMessage(message); + + if (CBOnInit) + CBOnInit(m_clientHandle); + return true; + } + break; + + case GUI_MSG_FOCUSED: + { + if (m_viewControl.HasControl(message.GetControlId()) && + m_viewControl.GetCurrentControl() != message.GetControlId()) + { + m_viewControl.SetFocused(); + return true; + } + // check if our focused control is one of our category buttons + int iControl = message.GetControlId(); + if (CBOnFocus) + CBOnFocus(m_clientHandle, iControl); + } + break; + + case GUI_MSG_NOTIFY_ALL: + { + // most messages from GUI_MSG_NOTIFY_ALL break container content, whitelist working ones. + if (message.GetParam1() == GUI_MSG_PAGE_CHANGE || + message.GetParam1() == GUI_MSG_WINDOW_RESIZE) + return CGUIMediaWindow::OnMessage(message); + return true; + } + + case GUI_MSG_CLICKED: + { + int iControl = message.GetSenderId(); + if (iControl && iControl != this->GetID()) + { + CGUIControl* controlClicked = this->GetControl(iControl); + + // The old python way used to check list AND SELECITEM method or if its a button, checkmark. + // Its done this way for now to allow other controls without a python version like togglebutton to still raise a onAction event + if (controlClicked) // Will get problems if we the id is not on the window and we try to do GetControlType on it. So check to make sure it exists + { + if ((controlClicked->IsContainer() && (message.GetParam1() == ACTION_SELECT_ITEM || + message.GetParam1() == ACTION_MOUSE_LEFT_CLICK)) || + !controlClicked->IsContainer()) + { + if (CBOnClick) + return CBOnClick(m_clientHandle, iControl); + } + else if (controlClicked->IsContainer() && + (message.GetParam1() == ACTION_MOUSE_RIGHT_CLICK || + message.GetParam1() == ACTION_CONTEXT_MENU)) + { + if (CBOnAction) + { + // Check addon want to handle right click for a context menu, if + // not used from addon becomes "GetContextButtons(...)" called. + KODI_ADDON_ACTION_DATA actionAddon; + actionAddon.id = ADDON_ACTION_CONTEXT_MENU; + if (CBOnAction(m_clientHandle, &actionAddon)) + return true; + } + } + } + } + } + break; + } + + return CGUIMediaWindow::OnMessage(message); +} + +void CGUIAddonWindow::AllocResources(bool forceLoad /*= false */) +{ + std::string tmpDir = URIUtils::GetDirectory(GetProperty("xmlfile").asString()); + std::string fallbackMediaPath; + URIUtils::GetParentPath(tmpDir, fallbackMediaPath); + URIUtils::RemoveSlashAtEnd(fallbackMediaPath); + m_mediaDir = fallbackMediaPath; + + auto& mgr = CServiceBroker::GetGUI()->GetTextureManager(); + + mgr.AddTexturePath(m_mediaDir); + CGUIMediaWindow::AllocResources(forceLoad); + mgr.RemoveTexturePath(m_mediaDir); +} + +void CGUIAddonWindow::Render() +{ + auto& mgr = CServiceBroker::GetGUI()->GetTextureManager(); + + mgr.AddTexturePath(m_mediaDir); + CGUIMediaWindow::Render(); + mgr.RemoveTexturePath(m_mediaDir); +} + +void CGUIAddonWindow::AddItem(CFileItemPtr* fileItem, int itemPosition) +{ + if (itemPosition == -1 || itemPosition > m_vecItems->Size()) + { + m_vecItems->Add(*fileItem); + } + else if (itemPosition < -1 && !(itemPosition - 1 < m_vecItems->Size())) + { + m_vecItems->AddFront(*fileItem, 0); + } + else + { + m_vecItems->AddFront(*fileItem, itemPosition); + } + m_viewControl.SetItems(*m_vecItems); + UpdateButtons(); +} + +void CGUIAddonWindow::RemoveItem(int itemPosition) +{ + m_vecItems->Remove(itemPosition); + m_viewControl.SetItems(*m_vecItems); + UpdateButtons(); +} + +void CGUIAddonWindow::RemoveItem(CFileItemPtr* fileItem) +{ + m_vecItems->Remove(fileItem->get()); + m_viewControl.SetItems(*m_vecItems); + UpdateButtons(); +} + +int CGUIAddonWindow::GetCurrentListPosition() +{ + return m_viewControl.GetSelectedItem(); +} + +void CGUIAddonWindow::SetCurrentListPosition(int item) +{ + m_viewControl.SetSelectedItem(item); +} + +int CGUIAddonWindow::GetListSize() +{ + return m_vecItems->Size(); +} + +CFileItemPtr* CGUIAddonWindow::GetListItem(int position) +{ + if (position < 0 || position >= m_vecItems->Size()) + return nullptr; + return new CFileItemPtr(m_vecItems->Get(position)); +} + +void CGUIAddonWindow::ClearList() +{ + ClearFileItems(); + + m_viewControl.SetItems(*m_vecItems); + UpdateButtons(); +} + +void CGUIAddonWindow::SetContainerProperty(const std::string& key, const std::string& value) +{ + m_vecItems->SetProperty(key, value); +} + +void CGUIAddonWindow::SetContainerContent(const std::string& value) +{ + m_vecItems->SetContent(value); +} + +int CGUIAddonWindow::GetCurrentContainerControlId() +{ + return m_viewControl.GetCurrentControl(); +} + +void CGUIAddonWindow::GetContextButtons(int itemNumber, CContextButtons& buttons) +{ + gui_context_menu_pair c_buttons[ADDON_MAX_CONTEXT_ENTRIES]; + memset(&c_buttons, 0, sizeof(c_buttons)); + unsigned int size = ADDON_MAX_CONTEXT_ENTRIES; + if (CBGetContextButtons) + { + CBGetContextButtons(m_clientHandle, itemNumber, c_buttons, &size); + for (unsigned int i = 0; i < size; ++i) + buttons.push_back(std::pair(c_buttons[i].id, c_buttons[i].name)); + } +} + +bool CGUIAddonWindow::OnContextButton(int itemNumber, CONTEXT_BUTTON button) +{ + if (CBOnContextButton) + return CBOnContextButton(m_clientHandle, itemNumber, static_cast(button)); + return false; +} + +void CGUIAddonWindow::WaitForActionEvent(unsigned int timeout) +{ + m_actionEvent.Wait(std::chrono::milliseconds(timeout)); + m_actionEvent.Reset(); +} + +void CGUIAddonWindow::PulseActionEvent() +{ + m_actionEvent.Set(); +} + +void CGUIAddonWindow::SetupShares() +{ + UpdateButtons(); +} + +CGUIAddonWindowDialog::CGUIAddonWindowDialog(int id, + const std::string& strXML, + std::shared_ptr addon) + : CGUIAddonWindow(id, strXML, addon, false), m_bRunning(false) +{ +} + +void CGUIAddonWindowDialog::Show(bool show /* = true */, bool modal /* = true*/) +{ + if (modal) + { + unsigned int count = CServiceBroker::GetWinSystem()->GetGfxContext().exit(); + CServiceBroker::GetAppMessenger()->SendMsg(TMSG_GUI_ADDON_DIALOG, 0, show ? 1 : 0, + static_cast(this)); + CServiceBroker::GetWinSystem()->GetGfxContext().restore(count); + } + else + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_GUI_ADDON_DIALOG, 0, show ? 1 : 0, + static_cast(this)); +} + +void CGUIAddonWindowDialog::Show_Internal(bool show /* = true */) +{ + if (show) + { + m_bRunning = true; + CServiceBroker::GetGUI()->GetWindowManager().RegisterDialog(this); + + // activate this window... + CGUIMessage msg(GUI_MSG_WINDOW_INIT, 0, 0, WINDOW_INVALID, GetID()); + OnMessage(msg); + + // this dialog is derived from GUIMediaWindow + // make sure it is rendered last + m_renderOrder = RENDER_ORDER_DIALOG; + while (m_bRunning) + { + if (!ProcessRenderLoop(false)) + break; + } + } + else // hide + { + m_bRunning = false; + + CGUIMessage msg(GUI_MSG_WINDOW_DEINIT, 0, 0); + OnMessage(msg); + + CServiceBroker::GetGUI()->GetWindowManager().RemoveDialog(GetID()); + } +} + +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_window_h::InitDirect(directFuncToKodi_gui_window_h* ifcToKodi, + directFuncToAddon_gui_window_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_gui_window_create_v1 = kodi_gui_window_create_v1; + ifcToKodi->kodi_gui_window_destroy_v1 = kodi_gui_window_destroy_v1; + ifcToKodi->kodi_gui_window_show_v1 = kodi_gui_window_show_v1; + ifcToKodi->kodi_gui_window_close_v1 = kodi_gui_window_close_v1; + ifcToKodi->kodi_gui_window_do_modal_v1 = kodi_gui_window_do_modal_v1; + ifcToKodi->kodi_gui_window_set_focus_id_v1 = kodi_gui_window_set_focus_id_v1; + ifcToKodi->kodi_gui_window_get_focus_id_v1 = kodi_gui_window_get_focus_id_v1; + ifcToKodi->kodi_gui_window_set_control_label_v1 = kodi_gui_window_set_control_label_v1; + ifcToKodi->kodi_gui_window_set_control_visible_v1 = kodi_gui_window_set_control_visible_v1; + ifcToKodi->kodi_gui_window_set_control_selected_v1 = kodi_gui_window_set_control_selected_v1; + ifcToKodi->kodi_gui_window_set_property_v1 = kodi_gui_window_set_property_v1; + ifcToKodi->kodi_gui_window_set_property_int_v1 = kodi_gui_window_set_property_int_v1; + ifcToKodi->kodi_gui_window_set_property_bool_v1 = kodi_gui_window_set_property_bool_v1; + ifcToKodi->kodi_gui_window_set_property_double_v1 = kodi_gui_window_set_property_double_v1; + ifcToKodi->kodi_gui_window_get_property_v1 = kodi_gui_window_get_property_v1; + ifcToKodi->kodi_gui_window_get_property_int_v1 = kodi_gui_window_get_property_int_v1; + ifcToKodi->kodi_gui_window_get_property_bool_v1 = kodi_gui_window_get_property_bool_v1; + ifcToKodi->kodi_gui_window_get_property_double_v1 = kodi_gui_window_get_property_double_v1; + ifcToKodi->kodi_gui_window_clear_properties_v1 = kodi_gui_window_clear_properties_v1; + ifcToKodi->kodi_gui_window_clear_property_v1 = kodi_gui_window_clear_property_v1; + ifcToKodi->kodi_gui_window_clear_item_list_v1 = kodi_gui_window_clear_item_list_v1; + ifcToKodi->kodi_gui_window_add_list_item_v1 = kodi_gui_window_add_list_item_v1; + ifcToKodi->kodi_gui_window_remove_list_item_from_position_v1 = + kodi_gui_window_remove_list_item_from_position_v1; + ifcToKodi->kodi_gui_window_remove_list_item_v1 = kodi_gui_window_remove_list_item_v1; + ifcToKodi->kodi_gui_window_get_list_item_v1 = kodi_gui_window_get_list_item_v1; + ifcToKodi->kodi_gui_window_set_current_list_position_v1 = + kodi_gui_window_set_current_list_position_v1; + ifcToKodi->kodi_gui_window_get_current_list_position_v1 = + kodi_gui_window_get_current_list_position_v1; + ifcToKodi->kodi_gui_window_get_list_size_v1 = kodi_gui_window_get_list_size_v1; + ifcToKodi->kodi_gui_window_set_container_property_v1 = kodi_gui_window_set_container_property_v1; + ifcToKodi->kodi_gui_window_set_container_content_v1 = kodi_gui_window_set_container_content_v1; + ifcToKodi->kodi_gui_window_get_current_container_id_v1 = + kodi_gui_window_get_current_container_id_v1; + ifcToKodi->kodi_gui_window_mark_dirty_region_v1 = kodi_gui_window_mark_dirty_region_v1; + ifcToKodi->kodi_gui_window_get_control_button_v1 = kodi_gui_window_get_control_button_v1; + ifcToKodi->kodi_gui_window_get_control_edit_v1 = kodi_gui_window_get_control_edit_v1; + ifcToKodi->kodi_gui_window_get_control_fade_label_v1 = kodi_gui_window_get_control_fade_label_v1; + ifcToKodi->kodi_gui_window_get_control_image_v1 = kodi_gui_window_get_control_image_v1; + ifcToKodi->kodi_gui_window_get_control_label_v1 = kodi_gui_window_get_control_label_v1; + ifcToKodi->kodi_gui_window_get_control_progress_v1 = kodi_gui_window_get_control_progress_v1; + ifcToKodi->kodi_gui_window_get_control_radio_button_v1 = + kodi_gui_window_get_control_radio_button_v1; + ifcToKodi->kodi_gui_window_get_control_render_addon_v1 = + kodi_gui_window_get_control_render_addon_v1; + ifcToKodi->kodi_gui_window_get_control_settings_slider_v1 = + kodi_gui_window_get_control_settings_slider_v1; + ifcToKodi->kodi_gui_window_get_control_slider_v1 = kodi_gui_window_get_control_slider_v1; + ifcToKodi->kodi_gui_window_get_control_spin_v1 = kodi_gui_window_get_control_spin_v1; + ifcToKodi->kodi_gui_window_get_control_text_box_v1 = kodi_gui_window_get_control_text_box_v1; +} + +bool CHdl_kodi_gui_window_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_gui_window_h) + return false; + + switch (func) + { + case funcParent_kodi_gui_window_create_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_WINDOW_HANDLE kodi_gui_window_create(KODI_HANDLE kodiBase, const char* xml_filename, const char* default_skin, bool as_dialog, bool is_media) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_create_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_create_v1 t = in.get().as(); + KODI_HANDLE kodiBase = reinterpret_cast(std::get<0>(t)); + const std::string& xml_filename = std::get<1>(t); + const std::string& default_skin = std::get<2>(t); + bool as_dialog = std::get<3>(t); + bool is_media = std::get<4>(t); + KODI_GUI_WINDOW_HANDLE auto_gen_ret = kodi_gui_window_create_v1( + this, kodiBase, xml_filename.c_str(), default_skin.c_str(), as_dialog, is_media); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_create_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_destroy_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_destroy(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_destroy_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_destroy_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_destroy_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_window_destroy_v1(this, handle); + return true; + } + case funcParent_kodi_gui_window_show_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_window_show(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_show_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_show_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_show_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_gui_window_show_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_show_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_close_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_window_close(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_close_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_close_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_close_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_gui_window_close_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_close_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_do_modal_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_window_do_modal(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_do_modal_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_do_modal_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_do_modal_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + bool auto_gen_ret = kodi_gui_window_do_modal_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_do_modal_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_set_focus_id_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_window_set_focus_id(KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_focus_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_focus_id_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_focus_id_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + bool auto_gen_ret = kodi_gui_window_set_focus_id_v1(this, handle, control_id); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_set_focus_id_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_get_focus_id_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_window_get_focus_id(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_focus_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_focus_id_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_focus_id_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_gui_window_get_focus_id_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_focus_id_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_set_control_label_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_control_label(KODI_GUI_WINDOW_HANDLE handle, int control_id, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_control_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_control_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_control_label_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + const std::string& label = std::get<2>(t); + kodi_gui_window_set_control_label_v1(this, handle, control_id, label.c_str()); + return true; + } + case funcParent_kodi_gui_window_set_control_visible_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_control_visible(KODI_GUI_WINDOW_HANDLE handle, int control_id, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_control_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_control_visible_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_control_visible_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + bool visible = std::get<2>(t); + kodi_gui_window_set_control_visible_v1(this, handle, control_id, visible); + return true; + } + case funcParent_kodi_gui_window_set_control_selected_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_control_selected(KODI_GUI_WINDOW_HANDLE handle, int control_id, bool selected) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_control_selected_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_control_selected_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_control_selected_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + bool selected = std::get<2>(t); + kodi_gui_window_set_control_selected_v1(this, handle, control_id, selected); + return true; + } + case funcParent_kodi_gui_window_set_property_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_property(KODI_GUI_WINDOW_HANDLE handle, const char* key, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_property_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_property_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + const std::string& value = std::get<2>(t); + kodi_gui_window_set_property_v1(this, handle, key.c_str(), value.c_str()); + return true; + } + case funcParent_kodi_gui_window_set_property_int_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_property_int(KODI_GUI_WINDOW_HANDLE handle, const char* key, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_property_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_property_int_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_property_int_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + int value = std::get<2>(t); + kodi_gui_window_set_property_int_v1(this, handle, key.c_str(), value); + return true; + } + case funcParent_kodi_gui_window_set_property_bool_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_property_bool(KODI_GUI_WINDOW_HANDLE handle, const char* key, bool value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_property_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_property_bool_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_property_bool_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + bool value = std::get<2>(t); + kodi_gui_window_set_property_bool_v1(this, handle, key.c_str(), value); + return true; + } + case funcParent_kodi_gui_window_set_property_double_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_property_double(KODI_GUI_WINDOW_HANDLE handle, const char* key, double value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_property_double_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_property_double_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_property_double_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + double value = std::get<2>(t); + kodi_gui_window_set_property_double_v1(this, handle, key.c_str(), value); + return true; + } + case funcParent_kodi_gui_window_get_property_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_window_get_property(KODI_GUI_WINDOW_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_property_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_property_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + char* auto_gen_ret = kodi_gui_window_get_property_v1(this, handle, key.c_str()); + msgpack::pack( + out, msgParent_OUT_kodi_gui_window_get_property_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_gui_window_get_property_int_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_window_get_property_int(KODI_GUI_WINDOW_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_property_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_property_int_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_property_int_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + int auto_gen_ret = kodi_gui_window_get_property_int_v1(this, handle, key.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_property_int_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_get_property_bool_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_window_get_property_bool(KODI_GUI_WINDOW_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_property_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_property_bool_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_property_bool_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + bool auto_gen_ret = kodi_gui_window_get_property_bool_v1(this, handle, key.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_property_bool_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_get_property_double_v1: + { + // Original API call: ATTR_DLL_EXPORT double kodi_gui_window_get_property_double(KODI_GUI_WINDOW_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_property_double_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_property_double_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_property_double_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + double auto_gen_ret = kodi_gui_window_get_property_double_v1(this, handle, key.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_property_double_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_clear_properties_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_clear_properties(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_clear_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_clear_properties_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_clear_properties_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_window_clear_properties_v1(this, handle); + return true; + } + case funcParent_kodi_gui_window_clear_property_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_clear_property(KODI_GUI_WINDOW_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_clear_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_clear_property_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_clear_property_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + kodi_gui_window_clear_property_v1(this, handle, key.c_str()); + return true; + } + case funcParent_kodi_gui_window_clear_item_list_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_clear_item_list(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_clear_item_list_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_clear_item_list_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_clear_item_list_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_window_clear_item_list_v1(this, handle); + return true; + } + case funcParent_kodi_gui_window_add_list_item_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_add_list_item(KODI_GUI_WINDOW_HANDLE handle, KODI_GUI_LISTITEM_HANDLE item, int list_position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_add_list_item_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_add_list_item_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_add_list_item_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + KODI_GUI_LISTITEM_HANDLE item = reinterpret_cast(std::get<1>(t)); + int list_position = std::get<2>(t); + kodi_gui_window_add_list_item_v1(this, handle, item, list_position); + return true; + } + case funcParent_kodi_gui_window_remove_list_item_from_position_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_remove_list_item_from_position(KODI_GUI_WINDOW_HANDLE handle, int list_position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_remove_list_item_from_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_remove_list_item_from_position_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_remove_list_item_from_position_v1 t = + in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int list_position = std::get<1>(t); + kodi_gui_window_remove_list_item_from_position_v1(this, handle, list_position); + return true; + } + case funcParent_kodi_gui_window_remove_list_item_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_remove_list_item(KODI_GUI_WINDOW_HANDLE handle, KODI_GUI_LISTITEM_HANDLE item) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_remove_list_item_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_remove_list_item_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_remove_list_item_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + KODI_GUI_LISTITEM_HANDLE item = reinterpret_cast(std::get<1>(t)); + kodi_gui_window_remove_list_item_v1(this, handle, item); + return true; + } + case funcParent_kodi_gui_window_get_list_item_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_LISTITEM_HANDLE kodi_gui_window_get_list_item( KODI_GUI_WINDOW_HANDLE handle, int list_position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_list_item_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_list_item_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_list_item_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int list_position = std::get<1>(t); + KODI_GUI_LISTITEM_HANDLE auto_gen_ret = + kodi_gui_window_get_list_item_v1(this, handle, list_position); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_list_item_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_set_current_list_position_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_current_list_position(KODI_GUI_WINDOW_HANDLE handle, int list_position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_current_list_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_current_list_position_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_current_list_position_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int list_position = std::get<1>(t); + kodi_gui_window_set_current_list_position_v1(this, handle, list_position); + return true; + } + case funcParent_kodi_gui_window_get_current_list_position_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_window_get_current_list_position(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_current_list_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_current_list_position_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_current_list_position_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_gui_window_get_current_list_position_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_current_list_position_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_get_list_size_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_window_get_list_size(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_list_size_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_list_size_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_list_size_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_gui_window_get_list_size_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_list_size_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_set_container_property_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_container_property(KODI_GUI_WINDOW_HANDLE handle, const char* key, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_container_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_container_property_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_container_property_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& key = std::get<1>(t); + const std::string& value = std::get<2>(t); + kodi_gui_window_set_container_property_v1(this, handle, key.c_str(), value.c_str()); + return true; + } + case funcParent_kodi_gui_window_set_container_content_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_container_content(KODI_GUI_WINDOW_HANDLE handle, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_container_content_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_container_content_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_set_container_content_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + const std::string& value = std::get<1>(t); + kodi_gui_window_set_container_content_v1(this, handle, value.c_str()); + return true; + } + case funcParent_kodi_gui_window_get_current_container_id_v1: + { + // Original API call: ATTR_DLL_EXPORT int kodi_gui_window_get_current_container_id(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_current_container_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_current_container_id_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_current_container_id_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int auto_gen_ret = kodi_gui_window_get_current_container_id_v1(this, handle); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_current_container_id_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_gui_window_mark_dirty_region_v1: + { + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_mark_dirty_region(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_mark_dirty_region_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_mark_dirty_region_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_mark_dirty_region_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + kodi_gui_window_mark_dirty_region_v1(this, handle); + return true; + } + case funcParent_kodi_gui_window_get_control_button_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_button( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_button_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_button_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_button_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_button_v1(this, handle, control_id); + msgpack::pack(out, + msgParent_OUT_kodi_gui_window_get_control_button_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_edit_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_edit( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_edit_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_edit_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_edit_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_edit_v1(this, handle, control_id); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_control_edit_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_fade_label_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_fade_label( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_fade_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_fade_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_fade_label_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_fade_label_v1(this, handle, control_id); + msgpack::pack( + out, msgParent_OUT_kodi_gui_window_get_control_fade_label_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_image_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_image( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_image_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_image_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_image_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_image_v1(this, handle, control_id); + msgpack::pack(out, + msgParent_OUT_kodi_gui_window_get_control_image_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_label_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_label( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_label_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_label_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_label_v1(this, handle, control_id); + msgpack::pack(out, + msgParent_OUT_kodi_gui_window_get_control_label_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_progress_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_progress( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_progress_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_progress_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_progress_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_progress_v1(this, handle, control_id); + msgpack::pack(out, + msgParent_OUT_kodi_gui_window_get_control_progress_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_radio_button_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_radio_button( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_radio_button_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_radio_button_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_radio_button_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_radio_button_v1(this, handle, control_id); + msgpack::pack( + out, msgParent_OUT_kodi_gui_window_get_control_radio_button_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_render_addon_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_render_addon( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_render_addon_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_render_addon_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_render_addon_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_render_addon_v1(this, handle, control_id); + msgpack::pack( + out, msgParent_OUT_kodi_gui_window_get_control_render_addon_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_settings_slider_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_settings_slider( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_settings_slider_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_settings_slider_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_settings_slider_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_settings_slider_v1(this, handle, control_id); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_control_settings_slider_v1( + PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_slider_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_slider( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_slider_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_slider_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_slider_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_slider_v1(this, handle, control_id); + msgpack::pack(out, + msgParent_OUT_kodi_gui_window_get_control_slider_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_spin_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_spin( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_spin_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_spin_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_spin_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_spin_v1(this, handle, control_id); + msgpack::pack(out, msgParent_OUT_kodi_gui_window_get_control_spin_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcParent_kodi_gui_window_get_control_text_box_v1: + { + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_text_box( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_text_box_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_text_box_v1; /* Autogenerated */ + msgParent__IN_kodi_gui_window_get_control_text_box_v1 t = in.get().as(); + KODI_GUI_WINDOW_HANDLE handle = reinterpret_cast(std::get<0>(t)); + int control_id = std::get<1>(t); + KODI_GUI_CONTROL_HANDLE auto_gen_ret = + kodi_gui_window_get_control_text_box_v1(this, handle, control_id); + msgpack::pack(out, + msgParent_OUT_kodi_gui_window_get_control_text_box_v1(PtrValue(auto_gen_ret))); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{}: addon called with unknown function id '{}' on group " + "'gui_window_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +KODI_GUI_WINDOW_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_create_v1(void* thisClassHdl, + KODI_HANDLE kodiBase, + const char* xml_filename, + const char* default_skin, + bool as_dialog, + bool is_media) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::shared_ptr addon = thisClass->m_process->GetAddon(); + if (as_dialog && is_media) + { + CLog::Log( + LOGWARNING, + "CHdl_kodi_gui_window_h::{}: {}/{} - addon tries to create dialog as media window who " + "not allowed, contact Developer '{}' of this addon", + __func__, CAddonInfo::TranslateType(addon->Type()), addon->Name(), addon->Author()); + } + + RESOLUTION_INFO res; + std::string strSkinPath = g_SkinInfo->GetSkinPath(xml_filename, &res); + + if (!XFILE::CFile::Exists(strSkinPath)) + { + std::string str("none"); + ADDON::AddonInfoPtr addonInfo = std::make_shared(str, ADDON::ADDON_SKIN); + + // Check for the matching folder for the skin in the fallback skins folder + std::string fallbackPath = URIUtils::AddFileToFolder(addon->Path(), "resources", "skins"); + std::string basePath = URIUtils::AddFileToFolder(fallbackPath, g_SkinInfo->ID()); + + strSkinPath = g_SkinInfo->GetSkinPath(xml_filename, &res, basePath); + + // Check for the matching folder for the skin in the fallback skins folder (if it exists) + if (XFILE::CFile::Exists(basePath)) + { + addonInfo->SetPath(basePath); + const std::shared_ptr skinInfo = + std::make_shared(addonInfo, res); + skinInfo->Start(); + strSkinPath = skinInfo->GetSkinPath(xml_filename, &res); + } + + if (!XFILE::CFile::Exists(strSkinPath)) + { + // Finally fallback to the DefaultSkin as it didn't exist in either the Kodi Skin folder or the fallback skin folder + addonInfo->SetPath(URIUtils::AddFileToFolder(fallbackPath, default_skin)); + const std::shared_ptr skinInfo = + std::make_shared(addonInfo, res); + + skinInfo->Start(); + strSkinPath = skinInfo->GetSkinPath(xml_filename, &res); + if (!XFILE::CFile::Exists(strSkinPath)) + { + CLog::Log( + LOGERROR, + "CHdl_kodi_gui_window_h::{}: {}/{} - XML File '{}' for Window is missing, contact " + "Developer '{}' of this addon", + __func__, CAddonInfo::TranslateType(addon->Type()), addon->Name(), strSkinPath, + addon->Author()); + return nullptr; + } + } + } + + int id = GetNextAvailableWindowId(); + if (id < 0) + return nullptr; + + CGUIWindow* window; + if (!as_dialog) + window = new CGUIAddonWindow(id, strSkinPath, addon, is_media); + else + window = new CGUIAddonWindowDialog(id, strSkinPath, addon); + + CHdl_kodi_gui_general_h::lock(); + CServiceBroker::GetGUI()->GetWindowManager().Add(window); + CHdl_kodi_gui_general_h::unlock(); + + if (!CServiceBroker::GetGUI()->GetWindowManager().GetWindow(id)) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - Requested window id '{}' does not exist for addon '{}'", + __func__, id, thisClass->m_process->GetAddonID()); + delete window; + return nullptr; + } + window->SetCoordsRes(res); + return window; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_destroy_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + CGUIWindow* pWindow = + CServiceBroker::GetGUI()->GetWindowManager().GetWindow(pAddonWindow->GetID()); + if (pWindow) + { + // first change to an existing window + if (CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == pAddonWindow->GetID() && + !g_application.m_bStop) + { + if (CServiceBroker::GetGUI()->GetWindowManager().GetWindow(pAddonWindow->m_oldWindowId)) + CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->m_oldWindowId); + else // old window does not exist anymore, switch to home + CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_HOME); + } + // Free any window properties + pAddonWindow->ClearProperties(); + // free the window's resources and unload it (free all guicontrols) + pAddonWindow->FreeResources(true); + + CServiceBroker::GetGUI()->GetWindowManager().Remove(pAddonWindow->GetID()); + } + delete pAddonWindow; + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_window_h::kodi_gui_window_show_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return false; + } + + if (pAddonWindow->m_oldWindowId != pAddonWindow->m_windowId && + pAddonWindow->m_windowId != CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow()) + pAddonWindow->m_oldWindowId = CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(); + + CHdl_kodi_gui_general_h::lock(); + if (pAddonWindow->IsDialog()) + dynamic_cast(pAddonWindow)->Show(true, false); + else + CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->GetID()); + CHdl_kodi_gui_general_h::unlock(); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_window_h::kodi_gui_window_close_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return false; + } + + pAddonWindow->PulseActionEvent(); + + CHdl_kodi_gui_general_h::lock(); + + // if it's a dialog, we have to close it a bit different + if (pAddonWindow->IsDialog()) + dynamic_cast(pAddonWindow)->Show(false); + else + CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->m_oldWindowId); + pAddonWindow->m_oldWindowId = 0; + + CHdl_kodi_gui_general_h::unlock(); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_window_h::kodi_gui_window_do_modal_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return false; + } + + if (pAddonWindow->GetID() == CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow()) + return true; + + if (pAddonWindow->m_oldWindowId != pAddonWindow->m_windowId && + pAddonWindow->m_windowId != CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow()) + pAddonWindow->m_oldWindowId = CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(); + + CHdl_kodi_gui_general_h::lock(); + if (pAddonWindow->IsDialog()) + dynamic_cast(pAddonWindow)->Show(true, true); + else + CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->GetID()); + CHdl_kodi_gui_general_h::unlock(); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_window_h::kodi_gui_window_set_focus_id_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return false; + } + + CHdl_kodi_gui_general_h::lock(); + CGUIMessage msg(GUI_MSG_SETFOCUS, pAddonWindow->m_windowId, control_id); + pAddonWindow->OnMessage(msg); + CHdl_kodi_gui_general_h::unlock(); + + return true; + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_window_h::kodi_gui_window_get_focus_id_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return -1; + } + + CHdl_kodi_gui_general_h::lock(); + int control_id = pAddonWindow->GetFocusedControlID(); + CHdl_kodi_gui_general_h::unlock(); + + if (control_id == -1) + CLog::Log(LOGERROR, "CHdl_kodi_gui_window_h - {}: {} - No control in this window has focus", + __func__, thisClass->m_process->GetAddonID()); + + return control_id; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_set_control_label_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + int control_id, + const char* label) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + CGUIMessage msg(GUI_MSG_LABEL_SET, pAddonWindow->m_windowId, control_id); + msg.SetLabel(label); + pAddonWindow->OnMessage(msg); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_set_control_visible_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + int control_id, + bool visible) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + CGUIMessage msg(visible ? GUI_MSG_VISIBLE : GUI_MSG_HIDDEN, pAddonWindow->m_windowId, control_id); + pAddonWindow->OnMessage(msg); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_set_control_selected_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + int control_id, + bool selected) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + CGUIMessage msg(selected ? GUI_MSG_SET_SELECTED : GUI_MSG_SET_DESELECTED, + pAddonWindow->m_windowId, control_id); + pAddonWindow->OnMessage(msg); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_set_property_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key, + const char* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->SetProperty(lowerKey, value); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_set_property_int_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key, + int value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->SetProperty(lowerKey, value); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_set_property_bool_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key, + bool value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->SetProperty(lowerKey, value); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_set_property_double_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key, + double value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->SetProperty(lowerKey, value); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_gui_window_h::kodi_gui_window_get_property_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return nullptr; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + std::string value = pAddonWindow->GetProperty(lowerKey).asString(); + CHdl_kodi_gui_general_h::unlock(); + + return strdup(value.c_str()); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_window_h::kodi_gui_window_get_property_int_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return -1; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + int value = static_cast(pAddonWindow->GetProperty(lowerKey).asInteger()); + CHdl_kodi_gui_general_h::unlock(); + + return value; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_gui_window_h::kodi_gui_window_get_property_bool_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return false; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + bool value = pAddonWindow->GetProperty(lowerKey).asBoolean(); + CHdl_kodi_gui_general_h::unlock(); + + return value; + + /*---AUTO_GEN_PARSE---*/ +} + +double CHdl_kodi_gui_window_h::kodi_gui_window_get_property_double_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0.0; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return 0.0; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + double value = pAddonWindow->GetProperty(lowerKey).asDouble(); + CHdl_kodi_gui_general_h::unlock(); + + return value; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_clear_properties_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->ClearProperties(); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_clear_property_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + std::string lowerKey = key; + StringUtils::ToLower(lowerKey); + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->SetProperty(lowerKey, ""); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_clear_item_list_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->ClearList(); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_add_list_item_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + KODI_GUI_LISTITEM_HANDLE item, + int list_position) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CFileItemPtr* pItem(static_cast(item)); + if (pItem->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_window_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->AddItem(pItem, list_position); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_remove_list_item_from_position_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int list_position) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->RemoveItem(list_position); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_remove_list_item_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + KODI_GUI_LISTITEM_HANDLE item) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CFileItemPtr* pItem(static_cast(item)); + if (pItem->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_window_h::{} - empty list item called on addon '{}'", + __func__, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->RemoveItem(pItem); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_LISTITEM_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_list_item_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int list_position) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return nullptr; + } + + CHdl_kodi_gui_general_h::lock(); + CFileItemPtr* pItem(pAddonWindow->GetListItem(list_position)); + if (pItem == nullptr || pItem->get() == nullptr) + { + CLog::Log(LOGERROR, "CHdl_kodi_gui_window_h - {}: {} - Index out of range", __func__, + thisClass->m_process->GetAddonID()); + + if (pItem) + { + delete pItem; + pItem = nullptr; + } + } + CHdl_kodi_gui_general_h::unlock(); + + return pItem; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_set_current_list_position_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int list_position) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->SetCurrentListPosition(list_position); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_window_h::kodi_gui_window_get_current_list_position_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return -1; + } + + CHdl_kodi_gui_general_h::lock(); + int listPos = pAddonWindow->GetCurrentListPosition(); + CHdl_kodi_gui_general_h::unlock(); + + return listPos; + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_window_h::kodi_gui_window_get_list_size_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return -1; + } + + CHdl_kodi_gui_general_h::lock(); + int listSize = pAddonWindow->GetListSize(); + CHdl_kodi_gui_general_h::unlock(); + + return listSize; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_set_container_property_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, const char* key, const char* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->SetContainerProperty(key, value); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_set_container_content_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* value) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->SetContainerContent(value); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +int CHdl_kodi_gui_window_h::kodi_gui_window_get_current_container_id_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return -1; + } + + CHdl_kodi_gui_general_h::lock(); + int id = pAddonWindow->GetCurrentContainerControlId(); + CHdl_kodi_gui_general_h::unlock(); + + return id; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_gui_window_h::kodi_gui_window_mark_dirty_region_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return; + } + + CHdl_kodi_gui_general_h::lock(); + pAddonWindow->MarkDirtyRegion(); + CHdl_kodi_gui_general_h::unlock(); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_button_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return GetControl(thisClass, handle, control_id, __func__, CGUIControl::GUICONTROL_BUTTON, + "button"); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_edit_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return GetControl(thisClass, handle, control_id, __func__, CGUIControl::GUICONTROL_EDIT, "edit"); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_fade_label_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return GetControl(thisClass, handle, control_id, __func__, CGUIControl::GUICONTROL_FADELABEL, + "fade label"); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_image_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return GetControl(thisClass, handle, control_id, __func__, CGUIControl::GUICONTROL_IMAGE, + "image"); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_label_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return GetControl(thisClass, handle, control_id, __func__, CGUIControl::GUICONTROL_LABEL, + "label"); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_progress_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return GetControl(thisClass, handle, control_id, __func__, CGUIControl::GUICONTROL_PROGRESS, + "progress"); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_radio_button_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return GetControl(thisClass, handle, control_id, __func__, CGUIControl::GUICONTROL_RADIO, + "radio button"); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_render_addon_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + // Code below must be set manually by hand to make work to Kodi + + return nullptr; +#warning Function "CHdl_kodi_gui_window_h::kodi_gui_window_get_control_render_addon" must be set by hand. Alternatively add /*---AUTO_GEN_PARSE---*/ on back of target function in header to find on scan. + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_settings_slider_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + // Code below must be set manually by hand to make work to Kodi + + return GetControl(thisClass, handle, control_id, __func__, + CGUIControl::GUICONTROL_SETTINGS_SLIDER, "settings slider"); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_slider_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return GetControl(thisClass, handle, control_id, __func__, CGUIControl::GUICONTROL_SLIDER, + "slider"); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_spin_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return GetControl(thisClass, handle, control_id, __func__, CGUIControl::GUICONTROL_SPINEX, + "spin"); + + /*---AUTO_GEN_PARSE---*/ +} + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::kodi_gui_window_get_control_text_box_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + return GetControl(thisClass, handle, control_id, __func__, CGUIControl::GUICONTROL_TEXTBOX, + "textbox"); + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +KODI_GUI_CONTROL_HANDLE CHdl_kodi_gui_window_h::GetControl(CHdl_kodi_gui_window_h* thisClass, + KODI_GUI_WINDOW_HANDLE handle, + int control_id, + const char* function, + CGUIControl::GUICONTROLTYPES type, + const std::string& typeName) +{ + CGUIAddonWindow* pAddonWindow = static_cast(handle); + if (!pAddonWindow) + { + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - invalid handler data (handle='{}') on " + "addon '{}'", + __func__, handle, thisClass->m_process->GetAddonID()); + return nullptr; + } + + return pAddonWindow->GetAddonControl(control_id, type, typeName); +} + +int CHdl_kodi_gui_window_h::GetNextAvailableWindowId() +{ + CHdl_kodi_gui_general_h::lock(); + + // if window WINDOW_ADDON_END is in use it means addon can't create more windows + if (CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_ADDON_END)) + { + CHdl_kodi_gui_general_h::unlock(); + CLog::Log(LOGERROR, + "CHdl_kodi_gui_window_h::{} - Maximum number of windows for binary addons reached", + __func__); + return -1; + } + + // window id's WINDOW_ADDON_START - WINDOW_ADDON_END are reserved for addons + // get first window id that is not in use + int id = WINDOW_ADDON_START; + while (id < WINDOW_ADDON_END && + CServiceBroker::GetGUI()->GetWindowManager().GetWindow(id) != nullptr) + id++; + + CHdl_kodi_gui_general_h::unlock(); + return id; +} + +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/gui/window.h b/xbmc/addons/interface/api/gui/window.h new file mode 100644 index 0000000000000..b071eaaf3e1e4 --- /dev/null +++ b/xbmc/addons/interface/api/gui/window.h @@ -0,0 +1,327 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/gui/window.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +#include "windows/GUIMediaWindow.h" + +namespace ADDON +{ +class IAddon; +} + +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_window_h; +struct directFuncToKodi_gui_window_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +class CGUIAddonWindow : public CGUIMediaWindow +{ + friend class CHdl_kodi_gui_window_h; + +public: + CGUIAddonWindow(int id, + const std::string& strXML, + std::shared_ptr addon, + bool isMedia); + ~CGUIAddonWindow() override = default; + + bool OnMessage(CGUIMessage& message) override; + bool OnAction(const CAction& action) override; + void AllocResources(bool forceLoad = false) override; + void Render() override; + bool IsMediaWindow() const override { return m_isMedia; } + + /* Addon to Kodi call functions */ + void PulseActionEvent(); + void AddItem(CFileItemPtr* fileItem, int itemPosition); + void RemoveItem(int itemPosition); + void RemoveItem(CFileItemPtr* fileItem); + void ClearList(); + CFileItemPtr* GetListItem(int position); + int GetListSize(); + int GetCurrentListPosition(); + void SetCurrentListPosition(int item); + void SetContainerProperty(const std::string& key, const std::string& value); + void SetContainerContent(const std::string& value); + int GetCurrentContainerControlId(); + CGUIControl* GetAddonControl(int controlId, + CGUIControl::GUICONTROLTYPES type, + const std::string& typeName); + + const int m_windowId; + int m_oldWindowId; + +protected: + void GetContextButtons(int itemNumber, CContextButtons& buttons) override; + bool OnContextButton(int itemNumber, CONTEXT_BUTTON button) override; + void SetupShares() override; + + /* kodi to addon callback function addresses */ + KODI_GUI_CLIENT_HANDLE m_clientHandle{nullptr}; + bool (*CBOnInit)(KODI_GUI_CLIENT_HANDLE cbhdl){nullptr}; + bool (*CBOnFocus)(KODI_GUI_CLIENT_HANDLE cbhdl, int controlId){nullptr}; + bool (*CBOnClick)(KODI_GUI_CLIENT_HANDLE cbhdl, int controlId){nullptr}; + bool (*CBOnAction)(KODI_GUI_CLIENT_HANDLE cbhdl, const KODI_ADDON_ACTION_DATA* action){nullptr}; + void (*CBGetContextButtons)(KODI_GUI_CLIENT_HANDLE cbhdl, + int itemNumber, + gui_context_menu_pair* buttons, + unsigned int* size){nullptr}; + bool (*CBOnContextButton)(KODI_GUI_CLIENT_HANDLE cbhdl, int itemNumber, unsigned int button){ + nullptr}; + +private: + void WaitForActionEvent(unsigned int timeout); + + CEvent m_actionEvent{true}; + std::shared_ptr m_addon; + std::string m_mediaDir; + bool m_isMedia; +}; + +class CGUIAddonWindowDialog : public CGUIAddonWindow +{ +public: + CGUIAddonWindowDialog(int id, const std::string& strXML, std::shared_ptr addon); + + bool IsDialogRunning() const override { return m_bRunning; } + bool IsDialog() const override { return true; } + bool IsModalDialog() const override { return true; } + + void Show(bool show = true, bool modal = true); + void Show_Internal(bool show = true); + +private: + bool m_bRunning; +}; + +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_gui_window_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_window_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_gui_window_h* ifcToKodi, + directFuncToAddon_gui_window_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + static KODI_GUI_CONTROL_HANDLE GetControl(CHdl_kodi_gui_window_h* thisClass, + KODI_GUI_WINDOW_HANDLE handle, + int control_id, + const char* function, + CGUIControl::GUICONTROLTYPES type, + const std::string& typeName); + static int GetNextAvailableWindowId(); + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static KODI_GUI_WINDOW_HANDLE kodi_gui_window_create_v1(void* thisClassHdl, + KODI_HANDLE kodiBase, + const char* xml_filename, + const char* default_skin, + bool as_dialog, + bool is_media); // Added with API 1 + + static void kodi_gui_window_destroy_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static bool kodi_gui_window_show_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static bool kodi_gui_window_close_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static bool kodi_gui_window_do_modal_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static bool kodi_gui_window_set_focus_id_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + int control_id); // Added with API 1 + + static int kodi_gui_window_get_focus_id_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static void kodi_gui_window_set_control_label_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + int control_id, + const char* label); // Added with API 1 + + static void kodi_gui_window_set_control_visible_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + int control_id, + bool visible); // Added with API 1 + + static void kodi_gui_window_set_control_selected_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + int control_id, + bool selected); // Added with API 1 + + static void kodi_gui_window_set_property_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key, + const char* value); // Added with API 1 + + static void kodi_gui_window_set_property_int_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key, + int value); // Added with API 1 + + static void kodi_gui_window_set_property_bool_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key, + bool value); // Added with API 1 + + static void kodi_gui_window_set_property_double_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key, + double value); // Added with API 1 + + static char* kodi_gui_window_get_property_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key); // Added with API 1 + + static int kodi_gui_window_get_property_int_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key); // Added with API 1 + + static bool kodi_gui_window_get_property_bool_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key); // Added with API 1 + + static double kodi_gui_window_get_property_double_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key); // Added with API 1 + + static void kodi_gui_window_clear_properties_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static void kodi_gui_window_clear_property_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key); // Added with API 1 + + static void kodi_gui_window_clear_item_list_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static void kodi_gui_window_add_list_item_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + KODI_GUI_LISTITEM_HANDLE item, + int list_position); // Added with API 1 + + static void kodi_gui_window_remove_list_item_from_position_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int list_position); // Added with API 1 + + static void kodi_gui_window_remove_list_item_v1( + void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + KODI_GUI_LISTITEM_HANDLE item); // Added with API 1 + + static KODI_GUI_LISTITEM_HANDLE kodi_gui_window_get_list_item_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int list_position); // Added with API 1 + + static void kodi_gui_window_set_current_list_position_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + int list_position); // Added with API 1 + + static int kodi_gui_window_get_current_list_position_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static int kodi_gui_window_get_list_size_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static void kodi_gui_window_set_container_property_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* key, + const char* value); // Added with API 1 + + static void kodi_gui_window_set_container_content_v1(void* thisClassHdl, + KODI_GUI_WINDOW_HANDLE handle, + const char* value); // Added with API 1 + + static int kodi_gui_window_get_current_container_id_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static void kodi_gui_window_mark_dirty_region_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_button_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_edit_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_fade_label_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_image_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_label_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_progress_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_radio_button_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_render_addon_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_settings_slider_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_slider_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_spin_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + static KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_text_box_v1( + void* thisClassHdl, KODI_GUI_WINDOW_HANDLE handle, int control_id); // Added with API 1 + + directFuncToAddon_gui_window_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/monitor.cpp b/xbmc/addons/interface/api/monitor.cpp new file mode 100644 index 0000000000000..cd271952d2983 --- /dev/null +++ b/xbmc/addons/interface/api/monitor.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "monitor.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/monitor.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_monitor_h::InitDirect(directFuncToKodi_monitor_h* ifcToKodi, + directFuncToAddon_monitor_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + // Unused "kodi_monitor_wait_for_abort", done only in addon lib + // Unused "kodi_monitor_abort_requested", done only in addon lib +} + +bool CHdl_kodi_monitor_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_monitor_h) + return false; + + switch (func) + { + default: + CLog::Log(LOGERROR, + "CHdl_kodi_monitor_h::{}: addon called with unknown function id '{}' on group " + "'monitor_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi +/* NOTE: unused (no callbacks here) */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/monitor.h b/xbmc/addons/interface/api/monitor.h new file mode 100644 index 0000000000000..721f1c954836d --- /dev/null +++ b/xbmc/addons/interface/api/monitor.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/monitor.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_monitor_h; +struct directFuncToKodi_monitor_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_monitor_h : public IMsgHdl +{ +public: + CHdl_kodi_monitor_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_monitor_h* ifcToKodi, directFuncToAddon_monitor_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + + directFuncToAddon_monitor_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/network.cpp b/xbmc/addons/interface/api/network.cpp new file mode 100644 index 0000000000000..4989082487f95 --- /dev/null +++ b/xbmc/addons/interface/api/network.cpp @@ -0,0 +1,324 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "network.h" + +// Shared API +#include "addons/kodi-dev-kit/src/shared/api/network.h" + +// Kodi +#include "addons/interface/RunningProcess.h" +#include "utils/log.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +#include "ServiceBroker.h" +#include "URL.h" +#include "network/DNSNameCache.h" +#include "network/Network.h" +#include "utils/SystemInfo.h" +#include "utils/URIUtils.h" +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_network_h::InitDirect(directFuncToKodi_network_h* ifcToKodi, + directFuncToAddon_network_h* ifcToAddon) +{ + ifcToKodi->thisClassHdl = this; + m_ifcToAddon = ifcToAddon; + ifcToKodi->kodi_network_wake_on_lan_v1 = kodi_network_wake_on_lan_v1; + ifcToKodi->kodi_network_get_ip_address_v1 = kodi_network_get_ip_address_v1; + ifcToKodi->kodi_network_dns_lookup_v1 = kodi_network_dns_lookup_v1; + ifcToKodi->kodi_network_url_encode_v1 = kodi_network_url_encode_v1; + ifcToKodi->kodi_network_get_hostname_v1 = kodi_network_get_hostname_v1; + ifcToKodi->kodi_network_is_local_host_v1 = kodi_network_is_local_host_v1; + ifcToKodi->kodi_network_is_host_on_lan_v1 = kodi_network_is_host_on_lan_v1; + ifcToKodi->kodi_network_get_user_agent_v1 = kodi_network_get_user_agent_v1; +} + +bool CHdl_kodi_network_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_network_h) + return false; + + switch (func) + { + case funcParent_kodi_network_wake_on_lan_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_network_wake_on_lan(const char* mac) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_wake_on_lan_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_wake_on_lan_v1; /* Autogenerated */ + msgParent__IN_kodi_network_wake_on_lan_v1 t = in.get().as(); + const std::string& mac = std::get<0>(t); + bool auto_gen_ret = kodi_network_wake_on_lan_v1(this, mac.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_network_wake_on_lan_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_network_get_ip_address_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_network_get_ip_address() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_get_ip_address_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_get_ip_address_v1; /* Autogenerated */ + char* auto_gen_ret = kodi_network_get_ip_address_v1(this); + msgpack::pack(out, + msgParent_OUT_kodi_network_get_ip_address_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_network_dns_lookup_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_network_dns_lookup(const char* url, bool* ret) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_dns_lookup_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_dns_lookup_v1; /* Autogenerated */ + msgParent__IN_kodi_network_dns_lookup_v1 t = in.get().as(); + const std::string& url = std::get<0>(t); + bool ret = std::get<1>(t); + char* auto_gen_ret = kodi_network_dns_lookup_v1(this, url.c_str(), &ret); + msgpack::pack( + out, msgParent_OUT_kodi_network_dns_lookup_v1(auto_gen_ret ? auto_gen_ret : "", ret)); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_network_url_encode_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_network_url_encode(const char* url) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_url_encode_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_url_encode_v1; /* Autogenerated */ + msgParent__IN_kodi_network_url_encode_v1 t = in.get().as(); + const std::string& url = std::get<0>(t); + char* auto_gen_ret = kodi_network_url_encode_v1(this, url.c_str()); + msgpack::pack(out, + msgParent_OUT_kodi_network_url_encode_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_network_get_hostname_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_network_get_hostname() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_get_hostname_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_get_hostname_v1; /* Autogenerated */ + char* auto_gen_ret = kodi_network_get_hostname_v1(this); + msgpack::pack(out, + msgParent_OUT_kodi_network_get_hostname_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + case funcParent_kodi_network_is_local_host_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_network_is_local_host(const char* hostname) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_is_local_host_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_is_local_host_v1; /* Autogenerated */ + msgParent__IN_kodi_network_is_local_host_v1 t = in.get().as(); + const std::string& hostname = std::get<0>(t); + bool auto_gen_ret = kodi_network_is_local_host_v1(this, hostname.c_str()); + msgpack::pack(out, msgParent_OUT_kodi_network_is_local_host_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_network_is_host_on_lan_v1: + { + // Original API call: ATTR_DLL_EXPORT bool kodi_network_is_host_on_lan(const char* hostname, bool offLineCheck) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_is_host_on_lan_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_is_host_on_lan_v1; /* Autogenerated */ + msgParent__IN_kodi_network_is_host_on_lan_v1 t = in.get().as(); + const std::string& hostname = std::get<0>(t); + bool offLineCheck = std::get<1>(t); + bool auto_gen_ret = kodi_network_is_host_on_lan_v1(this, hostname.c_str(), offLineCheck); + msgpack::pack(out, msgParent_OUT_kodi_network_is_host_on_lan_v1(auto_gen_ret)); + return true; + } + case funcParent_kodi_network_get_user_agent_v1: + { + // Original API call: ATTR_DLL_EXPORT char* kodi_network_get_user_agent() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_get_user_agent_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_get_user_agent_v1; /* Autogenerated */ + char* auto_gen_ret = kodi_network_get_user_agent_v1(this); + msgpack::pack(out, + msgParent_OUT_kodi_network_get_user_agent_v1(auto_gen_ret ? auto_gen_ret : "")); + if (auto_gen_ret) + free(auto_gen_ret); + return true; + } + default: + CLog::Log(LOGERROR, + "CHdl_kodi_network_h::{}: addon called with unknown function id '{}' on group " + "'network_h'", + __func__, func); + } + + return false; +} + +// Function calls from Kodi to addon +/* NOTE: unused (no functions here) */ + +// Callbacks from addon to Kodi + +bool CHdl_kodi_network_h::kodi_network_wake_on_lan_v1(void* thisClassHdl, const char* mac) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CServiceBroker::GetNetwork().WakeOnLan(mac); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_network_h::kodi_network_get_ip_address_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string titleIP; + CNetworkInterface* iface = CServiceBroker::GetNetwork().GetFirstConnectedInterface(); + if (iface) + titleIP = iface->GetCurrentIPAddress(); + else + titleIP = "127.0.0.1"; + + char* buffer = nullptr; + if (!titleIP.empty()) + buffer = strdup(titleIP.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_network_h::kodi_network_dns_lookup_v1(void* thisClassHdl, + const char* url, + bool* ret) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string; + *ret = CDNSNameCache::Lookup(url, string); + char* buffer = nullptr; + if (!string.empty()) + buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_network_h::kodi_network_url_encode_v1(void* thisClassHdl, const char* url) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string = CURL::Encode(url); + char* buffer = nullptr; + if (!string.empty()) + buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_network_h::kodi_network_get_hostname_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string hostname; + if (!CServiceBroker::GetNetwork().GetHostName(hostname)) + return nullptr; + + char* buffer = nullptr; + if (!hostname.empty()) + buffer = strdup(hostname.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_network_h::kodi_network_is_local_host_v1(void* thisClassHdl, const char* hostname) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return CServiceBroker::GetNetwork().IsLocalHost(hostname); + + /*---AUTO_GEN_PARSE---*/ +} + +bool CHdl_kodi_network_h::kodi_network_is_host_on_lan_v1(void* thisClassHdl, + const char* hostname, + bool offLineCheck) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + /*---AUTO_GEN_PARSE---*/ + + return URIUtils::IsHostOnLAN(hostname, offLineCheck); + + /*---AUTO_GEN_PARSE---*/ +} + +char* CHdl_kodi_network_h::kodi_network_get_user_agent_v1(void* thisClassHdl) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + /*---AUTO_GEN_PARSE---*/ + + std::string string = CSysInfo::GetUserAgent(); + char* buffer = nullptr; + if (!string.empty()) + buffer = strdup(string.c_str()); + return buffer; + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/api/network.h b/xbmc/addons/interface/api/network.h new file mode 100644 index 0000000000000..c214652870944 --- /dev/null +++ b/xbmc/addons/interface/api/network.h @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "addons/interface/IMsgHdl.h" + +// API include +#include "addons/kodi-dev-kit/include/kodi/c-api/network.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_network_h; +struct directFuncToKodi_network_h; + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +class CHdl_kodi_network_h : public IMsgHdl +{ +public: + CHdl_kodi_network_h(CInterface& interface) : IMsgHdl(interface) {} + + void InitDirect(directFuncToKodi_network_h* ifcToKodi, directFuncToAddon_network_h* ifcToAddon); + + // To handle callbacks from addon by shared sandbox API (static functions below in private becomes used) + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Function calls from Kodi to addon + +private: + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Callbacks from addon to Kodi + static bool kodi_network_wake_on_lan_v1(void* thisClassHdl, const char* mac); // Added with API 1 + + static char* kodi_network_get_ip_address_v1(void* thisClassHdl); // Added with API 1 + + static char* kodi_network_dns_lookup_v1(void* thisClassHdl, + const char* url, + bool* ret); // Added with API 1 + + static char* kodi_network_url_encode_v1(void* thisClassHdl, const char* url); // Added with API 1 + + static char* kodi_network_get_hostname_v1(void* thisClassHdl); // Added with API 1 + + static bool kodi_network_is_local_host_v1(void* thisClassHdl, + const char* hostname); // Added with API 1 + + static bool kodi_network_is_host_on_lan_v1(void* thisClassHdl, + const char* hostname, + bool offLineCheck); // Added with API 1 + + static char* kodi_network_get_user_agent_v1(void* thisClassHdl); // Added with API 1 + + directFuncToAddon_network_h* m_ifcToAddon{nullptr}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/gui/CMakeLists.txt b/xbmc/addons/interface/gui/CMakeLists.txt new file mode 100644 index 0000000000000..b118bb7e68cdc --- /dev/null +++ b/xbmc/addons/interface/gui/CMakeLists.txt @@ -0,0 +1,14 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + GUIDialogCrashReporter.cpp +) + +set(HEADERS + GUIDialogCrashReporter.h +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface_gui) +endif() diff --git a/xbmc/addons/interface/gui/GUIDialogCrashReporter.cpp b/xbmc/addons/interface/gui/GUIDialogCrashReporter.cpp new file mode 100644 index 0000000000000..b0970f97a5225 --- /dev/null +++ b/xbmc/addons/interface/gui/GUIDialogCrashReporter.cpp @@ -0,0 +1,206 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "GUIDialogCrashReporter.h" + +#include "ServiceBroker.h" +#include "addons/AddonManager.h" +#include "addons/interface/Controller.h" +#include "dialogs/GUIDialogTextViewer.h" +#include "filesystem/File.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/LocalizeStrings.h" +#include "input/Key.h" +#include "utils/Variant.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +#define CONTROL_DISABLE_ADDON_BUTTON CONTROL_CUSTOM_BUTTON + +CGUIDialogCrashReporter::CGUIDialogCrashReporter() + : CGUIDialogBoxBase(WINDOW_DIALOG_ADDON_CRASH_REPORTER, "DialogConfirm.xml") +{ +} + +void CGUIDialogCrashReporter::OnInitWindow() +{ + SET_CONTROL_VISIBLE(CONTROL_DISABLE_ADDON_BUTTON); + SET_CONTROL_HIDDEN(CONTROL_PROGRESS_BAR); + SET_CONTROL_FOCUS(CONTROL_YES_BUTTON, 0); + + CGUIDialogBoxBase::OnInitWindow(); +} + +bool CGUIDialogCrashReporter::OnAction(const CAction& action) +{ + + return CGUIDialogBoxBase::OnAction(action); +} + +bool CGUIDialogCrashReporter::OnMessage(CGUIMessage& message) +{ + switch (message.GetMessage()) + { + case GUI_MSG_CLICKED: + { + int iControl = message.GetSenderId(); + int iAction = message.GetParam1(); + if (true || ACTION_SELECT_ITEM == iAction) + { + if (iControl == CONTROL_NO_BUTTON) + { + m_bConfirmed = false; + Close(); + return true; + } + if (iControl == CONTROL_YES_BUTTON) + { + m_bConfirmed = true; + Close(); + return true; + } + if (iControl == CONTROL_DISABLE_ADDON_BUTTON) + { + m_bConfirmed = false; + m_disableAddon = true; + Close(); + return true; + } + } + } + break; + } + return CGUIDialogBoxBase::OnMessage(message); +} + +bool CGUIDialogCrashReporter::OnBack(int actionID) +{ + m_canceled = true; + m_bConfirmed = false; + m_disableAddon = false; + return CGUIDialogBoxBase::OnBack(actionID); +} + +CGUIDialogCrashReporter::RESULT CGUIDialogCrashReporter::GetResult() const +{ + if (m_canceled) + return RESULT::Canceled; + else if (m_disableAddon) + return RESULT::DisableAddon; + else if (m_bConfirmed) + return RESULT::DisableAddonAndReport; + else + return RESULT::IgnoreCrash; +} + +void CGUIDialogCrashReporter::ReportCrash(const KODI::MESSAGING::HELPERS::DialogCrashReportMessage* options) +{ + ReportCrash(options->addon, options->uuid, options->stacktrace); + delete options; +} + +void CGUIDialogCrashReporter::ReportCrash(const std::string& addon, + const std::string& uuid, + const std::string& stacktrace) +{ + using namespace ADDON; + + AddonInfoPtr addonInfo = CServiceBroker::GetAddonMgr().GetAddonInfo(addon); + if (!addonInfo) + return; + + const auto gui = CServiceBroker::GetGUI(); + if (!gui) + return; + + CGUIDialogCrashReporter* dialog = gui->GetWindowManager().GetWindow( + WINDOW_DIALOG_ADDON_CRASH_REPORTER); + if (!dialog) + return; + + const std::string text = StringUtils::Format(g_localizeStrings.Get(2296), addonInfo->Name()); + dialog->SetHeading(2295); + dialog->SetText(text); + dialog->m_canceled = false; + dialog->m_bConfirmed = false; + dialog->m_disableAddon = false; + dialog->SetChoice(0, 2297); + dialog->SetChoice(1, 2299); + dialog->SetChoice(2, 2298); + dialog->Open(); + const RESULT result = dialog->GetResult(); + switch (result) + { + case RESULT::Canceled: + case RESULT::IgnoreCrash: + break; + case RESULT::DisableAddonAndReport: + SendCrashReport(gui, addonInfo, uuid, stacktrace); + // fallthru is intended + [[fallthrough]]; + case RESULT::DisableAddon: + CServiceBroker::GetAddonMgr().DisableAddon(addonInfo->ID(), + AddonDisabledReason::PERMANENT_FAILURE); + break; + + default: + break; + } +} + +void CGUIDialogCrashReporter::SendCrashReport(CGUIComponent* const gui, + const ADDON::AddonInfoPtr& addonInfo, + const std::string& uuid, + const std::string& stacktrace) +{ + using namespace ADDON; + using namespace XFILE; + + CGUIDialogTextViewer* dialog = + gui->GetWindowManager().GetWindow(WINDOW_DIALOG_TEXT_VIEWER); + if (!dialog) + return; + + dialog->SetHeading(g_localizeStrings.Get(2294)); + dialog->UseMonoFont(true); + + if (addonInfo->Type(addonInfo->MainType())->Language() == AddonLanguage::Java) + { + + const std::string path = + CServiceBroker::GetAddonIfcCtrl().GetDevkitReportPath() + "/hs_err_pid" + uuid + ".log"; + if (CFile::Exists(path)) + { + CFile file; + std::vector buf; + if (file.LoadFile(path, buf) > 0) + { + const std::string text(reinterpret_cast(buf.data()), buf.size()); + dialog->SetText(text); + } + } + } + else if (!stacktrace.empty()) + dialog->SetText(stacktrace); + else + { + dialog->SetText("NEED TODO"); + } + + dialog->Open(); +} + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/gui/GUIDialogCrashReporter.h b/xbmc/addons/interface/gui/GUIDialogCrashReporter.h new file mode 100644 index 0000000000000..2c4ea83e457cf --- /dev/null +++ b/xbmc/addons/interface/gui/GUIDialogCrashReporter.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "addons/IAddon.h" +#include "dialogs/GUIDialogBoxBase.h" +#include "messaging/helpers/DialogCrashReporter.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CGUIDialogCrashReporter : public CGUIDialogBoxBase +{ +public: + CGUIDialogCrashReporter(void); + ~CGUIDialogCrashReporter(void) override = default; + + bool OnMessage(CGUIMessage& message) override; + bool OnAction(const CAction& action) override; + bool OnBack(int actionID) override; + + static void ReportCrash(const std::string& addon, const std::string& uuid, const std::string& stacktrace); + + /*! + \brief Open a add-on crash report dialog and wait for input + + \param[in] options a struct of type DialogCrashReportMessage containing + the options to set for this dialog. + + \sa KODI::MESSAGING::HELPERS::DialogCrashReportMessage + */ + void ReportCrash(const KODI::MESSAGING::HELPERS::DialogCrashReportMessage* options); + +private: + void OnInitWindow() override; + + enum class RESULT + { + Canceled = -1, + IgnoreCrash, + DisableAddon, + DisableAddonAndReport, + }; + RESULT GetResult() const; + static void SendCrashReport(CGUIComponent* const gui, + const ADDON::AddonInfoPtr& addonInfo, + const std::string& uuid, + const std::string& stacktrace); + + bool m_canceled; + bool m_disableAddon; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/launcher/CMakeLists.txt b/xbmc/addons/interface/launcher/CMakeLists.txt new file mode 100644 index 0000000000000..84762bfd4bbdd --- /dev/null +++ b/xbmc/addons/interface/launcher/CMakeLists.txt @@ -0,0 +1,25 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + LauncherDirectDll.cpp + $<$:LauncherPosix.cpp> + $<$:LauncherPosix.cpp> + $<$:LauncherPosix.cpp> + $<$:LauncherPosix.cpp> + $<$:LauncherPosix.cpp> +) + +set(HEADERS + ILauncher.h + LauncherDirectDll.h + $<$:LauncherPosix.h> + $<$:LauncherPosix.h> + $<$:LauncherPosix.h> + $<$:LauncherPosix.h> + $<$:LauncherPosix.h> +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface_launcher) +endif() diff --git a/xbmc/addons/interface/launcher/ILauncher.h b/xbmc/addons/interface/launcher/ILauncher.h new file mode 100644 index 0000000000000..586ed97fec00c --- /dev/null +++ b/xbmc/addons/interface/launcher/ILauncher.h @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include +#include +#include +#include + +namespace ADDON +{ +class IAddon; +} + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +enum class ChildStatus +{ + Running, + NotStarted, + ExitedNormal, + StoppedBySignal, + StoppedByUnknown, + KilledFromOutside, + SeqmentionFault, +}; + +class ILauncher +{ +public: + ILauncher(std::shared_ptr addonInfo, const std::string& uuid) + : m_addonInfo(addonInfo), m_uuid(uuid) + { + } + virtual ~ILauncher() = default; + + virtual bool Launch(const std::vector& argv, bool waitForExit) = 0; + virtual bool Kill(bool wait = true) = 0; + virtual int64_t GetMainProcessPID() const = 0; + virtual ChildStatus ProcessActive() = 0; + virtual bool SupportNonBlocking() { return false; } + virtual bool SupportNonBlocking(const std::string& path) { return false; } + + int GetExitCode() const { return m_exitCode; } + ChildStatus GetLastChildStatus() const { return m_lastStatus; } + const std::string& GetStackTrace() const { return m_stacktrace; } + +protected: + const std::shared_ptr m_addonInfo; + const std::string m_uuid; + + int m_exitCode = 0; + std::atomic m_lastStatus{ChildStatus::NotStarted}; + std::string m_stacktrace; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/launcher/LauncherDirectDll.cpp b/xbmc/addons/interface/launcher/LauncherDirectDll.cpp new file mode 100644 index 0000000000000..5e79dc3696ca9 --- /dev/null +++ b/xbmc/addons/interface/launcher/LauncherDirectDll.cpp @@ -0,0 +1,229 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "LauncherDirectDll.h" + +#include "addons/IAddon.h" +#include "filesystem/File.h" +#include "filesystem/SpecialProtocol.h" +#include "utils/URIUtils.h" +#include "utils/Variant.h" +#include "utils/log.h" + +using namespace std::chrono_literals; + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +CLauncherDirectDll::CLauncherDirectDll(std::shared_ptr addon, + const std::string& uuid) + : ILauncher(addon, uuid), CThread(addon->ID().c_str()) +{ +} + +CLauncherDirectDll::~CLauncherDirectDll() +{ + Kill(true); +} + +bool CLauncherDirectDll::Launch(const std::vector& argv, bool waitForExit) +{ + std::string strFileName = argv[0]; + if (strFileName.empty()) + return false; + + m_argv = argv; + + /* Load the Dll */ + if (!m_pDll) + { + m_pDll = new DllAddon; + m_pDll->SetFile(strFileName); + m_pDll->EnableDelayedUnload(false); + if (!m_pDll->Load()) + { + delete m_pDll; + m_pDll = nullptr; + + return false; + } + } + + if (SupportNonBlocking()) + { + int ret = m_pDll->non_blocking_main_start(m_argv.size(), m_argv.data()); + if (ret != 0) + return false; + } + else if (waitForExit) + { + int ret = m_pDll->main(m_argv.size(), m_argv.data()); + if (ret != 0) + return false; + } + else + { + CThread::Create(); + while (!m_startDone) + { + CThread::Sleep(1ms); + } + CThread::Sleep(10ms); + } + + return true; +} + +bool CLauncherDirectDll::Kill(bool wait) +{ + if (!m_pDll) + return true; + + if (SupportNonBlocking()) + { + m_pDll->non_blocking_main_stop(); + } + else + { + CThread::StopThread(); + } + + /* Unload library file */ + if (m_pDll) + { + m_pDll->Unload(); + delete m_pDll; + m_pDll = nullptr; + } + + return true; +} + +ChildStatus CLauncherDirectDll::ProcessActive() +{ + return m_pDll ? ChildStatus::Running : ChildStatus::ExitedNormal; +} + +std::string CLauncherDirectDll::GetDllPath(const std::string& libPath) +{ + std::string strFileName = libPath; + std::string strLibName = URIUtils::GetFileName(strFileName); + + if (strLibName.empty()) + return ""; + + /* Check if lib being loaded exists, else check in XBMC binary location */ +#if defined(TARGET_ANDROID) + if (XFILE::CFile::Exists(strFileName)) + { + bool doCopy = true; + std::string dstfile = URIUtils::AddFileToFolder( + CSpecialProtocol::TranslatePath("special://xbmcaltbinaddons/"), strLibName); + + struct __stat64 dstFileStat; + if (XFILE::CFile::Stat(dstfile, &dstFileStat) == 0) + { + struct __stat64 srcFileStat; + if (XFILE::CFile::Stat(strFileName, &srcFileStat) == 0) + { + if (dstFileStat.st_size == srcFileStat.st_size && + dstFileStat.st_mtime > srcFileStat.st_mtime) + doCopy = false; + } + } + + if (doCopy) + { + CLog::Log(LOGDEBUG, "ADDON: caching {} to {}", strFileName, dstfile); + XFILE::CFile::Copy(strFileName, dstfile); + } + + strFileName = dstfile; + } + if (!XFILE::CFile::Exists(strFileName)) + { + std::string tempbin = getenv("KODI_ANDROID_LIBS"); + strFileName = tempbin + "/" + strLibName; + } +#endif + + if (!XFILE::CFile::Exists(strFileName)) + { + std::string strAltFileName; + + std::string altbin = CSpecialProtocol::TranslatePath("special://xbmcaltbinaddons/"); + if (!altbin.empty()) + { + strAltFileName = altbin + strLibName; + if (!XFILE::CFile::Exists(strAltFileName)) + { + std::string temp = CSpecialProtocol::TranslatePath("special://xbmc/addons/"); + strAltFileName = strFileName; + strAltFileName.erase(0, temp.size()); + strAltFileName = altbin + strAltFileName; + } + CLog::Log(LOGDEBUG, "ADDON: Trying to load {}", strAltFileName); + } + + if (XFILE::CFile::Exists(strAltFileName)) + strFileName = strAltFileName; + else + { + std::string temp = CSpecialProtocol::TranslatePath("special://xbmc/"); + std::string tempbin = CSpecialProtocol::TranslatePath("special://xbmcbin/"); + strFileName.erase(0, temp.size()); + strFileName = tempbin + strFileName; + if (!XFILE::CFile::Exists(strFileName)) + { + CLog::Log(LOGERROR, "ADDON: Could not locate {}", strLibName); + strFileName.clear(); + } + } + } + + return strFileName; +} + +void CLauncherDirectDll::Process() +{ + m_startDone = true; + m_pDll->main(m_argv.size(), m_argv.data()); +} + +bool CLauncherDirectDll::SupportNonBlocking() +{ + return m_pDll->non_blocking_main_start_available(); +} + +bool CLauncherDirectDll::SupportNonBlocking(const std::string& path) +{ + /* Load the Dll */ + if (!m_pDll) + { + m_pDll = new DllAddon; + m_pDll->SetFile(path); + m_pDll->EnableDelayedUnload(false); + if (!m_pDll->Load()) + { + delete m_pDll; + m_pDll = nullptr; + + return false; + } + } + + return SupportNonBlocking(); +} + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/launcher/LauncherDirectDll.h b/xbmc/addons/interface/launcher/LauncherDirectDll.h new file mode 100644 index 0000000000000..549bd16cd5291 --- /dev/null +++ b/xbmc/addons/interface/launcher/LauncherDirectDll.h @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "DynamicDll.h" +#include "ILauncher.h" +#include "threads/Thread.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class DllAddonInterface +{ +public: + virtual ~DllAddonInterface() = default; + virtual int main(int argc, char* argv[]) = 0; + virtual int non_blocking_main_start(int argc, char* argv[]) = 0; + virtual void non_blocking_main_stop() = 0; +}; + +class DllAddon : public DllDynamic, public DllAddonInterface +{ +public: + DECLARE_DLL_WRAPPER_TEMPLATE(DllAddon) + DEFINE_METHOD2(int, main, (int p1, char* p2[])) + DEFINE_METHOD2(int, non_blocking_main_start, (int p1, char* p2[])) + DEFINE_METHOD0(void, non_blocking_main_stop) + bool main_available() { return m_main != nullptr; } + bool non_blocking_main_start_available() { return m_non_blocking_main_start != nullptr; } + BEGIN_METHOD_RESOLVE() + RESOLVE_METHOD_RENAME_OPTIONAL(main, main) + RESOLVE_METHOD_RENAME_OPTIONAL(non_blocking_main_start, non_blocking_main_start) + RESOLVE_METHOD_RENAME_OPTIONAL(non_blocking_main_stop, non_blocking_main_stop) + END_METHOD_RESOLVE() +}; + +class CLauncherDirectDll : public ILauncher, private CThread +{ +public: + CLauncherDirectDll(std::shared_ptr addon, const std::string& uuid); + ~CLauncherDirectDll(); + + bool Launch(const std::vector& argv, bool waitForExit) override; + bool Kill(bool wait) override; + int64_t GetMainProcessPID() const override { return static_cast(m_pid); } + ChildStatus ProcessActive() override; + bool SupportNonBlocking() override; + bool SupportNonBlocking(const std::string& path) override; + +private: + std::string GetDllPath(const std::string& libPath); + + void Process() override; + + std::atomic_bool m_startDone{false}; + std::vector m_argv; + DllAddon* m_pDll = nullptr; + pid_t m_pid = -1; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/launcher/LauncherPosix.cpp b/xbmc/addons/interface/launcher/LauncherPosix.cpp new file mode 100644 index 0000000000000..60a175ea32f67 --- /dev/null +++ b/xbmc/addons/interface/launcher/LauncherPosix.cpp @@ -0,0 +1,310 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:linux,freebsd,android,osx,darwin_embedded>---*/ + +#include "LauncherPosix.h" + +#include "../../utils/log.h" + +#include +#include + +#include +#include + +#if defined(TARGET_LINUX) +#include +#endif + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +// Set the calling thread's signal mask to new_sigmask and return +// the previous signal mask. +sigset_t SetSignalMask(const sigset_t& new_sigmask) +{ + sigset_t old_sigmask; +#if defined(OS_ANDROID) + // POSIX says pthread_sigmask() must be used in multi-threaded processes, + // but Android's pthread_sigmask() was broken until 4.1: + // https://code.google.com/p/android/issues/detail?id=15337 + // http://stackoverflow.com/questions/13777109/pthread-sigmask-on-android-not-working + RAW_CHECK(sigprocmask(SIG_SETMASK, &new_sigmask, &old_sigmask) == 0); +#else + RAW_CHECK(pthread_sigmask(SIG_SETMASK, &new_sigmask, &old_sigmask) == 0); +#endif + return old_sigmask; +} + +void ResetChildSignalHandlersToDefaults() +{ + // The previous signal handlers are likely to be meaningless in the child's + // context so we reset them to the defaults for now. http://crbug.com/44953 + // These signal handlers are set up at least in browser_main_posix.cc: + // BrowserMainPartsPosix::PreEarlyInitialization and stack_trace_posix.cc: + // EnableInProcessStackDumping. + signal(SIGHUP, SIG_DFL); + signal(SIGINT, SIG_DFL); + signal(SIGILL, SIG_DFL); + signal(SIGABRT, SIG_DFL); + signal(SIGFPE, SIG_DFL); + signal(SIGBUS, SIG_DFL); + signal(SIGSEGV, SIG_DFL); + signal(SIGSYS, SIG_DFL); + signal(SIGTERM, SIG_DFL); +} + +CLauncherPosix::CLauncherPosix(std::shared_ptr addon, const std::string& uuid) + : ILauncher(addon, uuid) +{ +} + +bool CLauncherPosix::Launch(const std::vector& argv, bool waitForExit) +{ + using namespace std::chrono; + + sigset_t full_sigset; + sigfillset(&full_sigset); + const sigset_t orig_sigmask = SetSignalMask(full_sigset); + + if (pipe(m_childToParent) < 0) + { + CLog::Log(LOGERROR, "CChildLauncherPosix::{}: Failed to create pipe for child process", __func__); + return false; + } + + int writeFD = m_childToParent[WRITE_FD]; + int readFD = m_childToParent[READ_FD]; + + const auto before_fork = high_resolution_clock::now(); + pid_t pid = fork(); + + // Always restore the original signal mask in the parent. + if (pid != 0) + { + const auto after_fork = high_resolution_clock::now(); + SetSignalMask(orig_sigmask); + + duration fork_time = duration_cast>(after_fork - before_fork); + CLog::Log(LOGDEBUG, "CChildLauncherPosix::{}: Child fork time {}", __func__, fork_time.count()); + } + + if (pid == -1) + { + CLog::Log(LOGERROR, "CChildLauncherPosix::{}: Failed to create child process", __func__); + return false; + } + + if (pid == 0) + { + ResetChildSignalHandlersToDefaults(); + SetSignalMask(orig_sigmask); + +#if defined(TARGET_LINUX) + if (prctl(PR_SET_PDEATHSIG, SIGKILL) != 0) + { + fprintf(stderr, "prctl(PR_SET_PDEATHSIG) failed\n"); + _exit(127); + } +#endif + + // crash_reporter writes output to stderr. Connect it to the status pipe fd. + if (dup2(writeFD, STDERR_FILENO) == -1) + { + fprintf(stderr, "Failed to init stderr handling\n"); + _exit(127); + } + + close(readFD); + + execvp(argv[0], argv.data()); + + _exit(0); + } + + close(writeFD); + + CLog::Log( + LOGINFO, + "CChildLauncherPosix::{}: Started child process for webbrowser addon (pid {}) in wait {}", + __func__, pid, waitForExit ? "yes" : "no"); + m_pid = pid; + + if (waitForExit) + { + int status = 0; + pid_t ret = HANDLE_EINTR(waitpid(pid, &status, 0)); + if (ret <= 0) + { + ProcessStatus(status); + } + } + + return true; +} + +bool CLauncherPosix::Kill(bool wait) +{ + pid_t pid = m_pid; + fprintf(stderr, "KILL\n"); + if (pid > 0) + { + if (m_lastStatus == ChildStatus::Running) + { + int cnt = 10; + while (cnt-- > 0) + { + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + if (ProcessActive() != ChildStatus::Running) + { + CLog::Log(LOGDEBUG, "CChildLauncherPosix::{}: Child correctly stopped itself (pid {})", + __func__, pid); + return true; + } + } + + CLog::Log(LOGDEBUG, "CChildLauncherPosix::{}: Forcing stop of child (pid {})", __func__, + pid); + + bool did_terminate = kill(pid, SIGTERM) == 0; + + if (wait && did_terminate) + { + cnt = 50; + pid_t ret_pid = 0; + while (ret_pid <= 0 && cnt-- > 0) + { + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + ret_pid = HANDLE_EINTR(waitpid(pid, nullptr, WNOHANG)); + } + if (ret_pid > 0) + return true; + + did_terminate = kill(pid, SIGKILL) == 0; + if (did_terminate) + { + ret_pid = HANDLE_EINTR(waitpid(pid, nullptr, 0)); + if (ret_pid > 0) + return true; + } + } + + if (!did_terminate) + { + CLog::Log(LOGERROR, "CChildLauncherPosix::{}: Unable to terminate process {}", __func__, + pid); + return false; + } + } + + if (m_childToParent[READ_FD] > 0) + { + close(m_childToParent[READ_FD]); + m_childToParent[READ_FD] = -1; + } + } + + return true; +} + +ChildStatus CLauncherPosix::ProcessActive() +{ + pid_t pid = m_pid; + if (pid > 0) + { + int status = 0; + pid_t ret = waitpid(pid, &status, WNOHANG | WUNTRACED | WCONTINUED); + if (ret == 0) + { + m_lastStatus = ChildStatus::Running; + } + else if (ret == -1) + { + if (m_childToParent[READ_FD] > 0) + { + constexpr int BUFFER_SIZE = 1024; + char buffer[BUFFER_SIZE + 1] = {0}; + m_stacktrace.clear(); + while (read(m_childToParent[READ_FD], buffer, BUFFER_SIZE) > 0) + { + m_stacktrace += buffer; + memset(buffer, 0, BUFFER_SIZE); + } + fprintf(stderr, "--------->>>>>>>>>>>>>> %s\n", m_stacktrace.c_str()); + close(m_childToParent[READ_FD]); + m_childToParent[READ_FD] = -1; + } + + CLog::Log(LOGERROR, "CChildLauncherPosix::{}: Asked sandbox process pid {} no more present", + __func__, pid); + if (m_lastStatus == ChildStatus::Running) + m_lastStatus = ChildStatus::StoppedByUnknown; + return m_lastStatus; + } + else + { + ProcessStatus(status); + } + } + + return m_lastStatus; +} + +void CLauncherPosix::ProcessStatus(int status) +{ + if (WIFEXITED(status)) + { + m_exitCode = WEXITSTATUS(status); + m_lastStatus = ChildStatus::ExitedNormal; + CLog::Log(LOGDEBUG, + "CChildLauncherPosix::{}: Sandbox process pid {}, stopped normal with exit code {}", + __func__, m_pid, m_exitCode); + } + else if (WIFSIGNALED(status)) + { + m_exitCode = WTERMSIG(status); + fprintf(stderr, "<<<<<<<<<<<<< %i %i %i %i %i %i\n", WSTOPSIG(status), WTERMSIG(status), + WCOREDUMP(status), WIFSIGNALED(status), WIFSTOPPED(status), WIFEXITED(status)); + if (m_exitCode == SIGSEGV) + { + m_lastStatus = ChildStatus::SeqmentionFault; + CLog::Log(LOGFATAL, "CChildLauncherPosix::{}: Sandbox process pid {} with seqmention fault", + __func__, m_pid, m_exitCode); + } + else + { + m_lastStatus = ChildStatus::StoppedBySignal; + CLog::Log(LOGFATAL, "CChildLauncherPosix::{}: Sandbox process pid {} signaled with {}", + __func__, m_pid, m_exitCode); + } + } + else if (WIFSTOPPED(status)) + { + m_exitCode = WSTOPSIG(status); + m_lastStatus = ChildStatus::StoppedBySignal; + CLog::Log(LOGFATAL, + "CChildLauncherPosix::{}: Sandbox process pid {} stopped from outside with {}", + __func__, m_pid, m_exitCode); + } + else + { + m_lastStatus = ChildStatus::StoppedByUnknown; + CLog::Log(LOGFATAL, + "CChildLauncherPosix::{}: Sandbox process pid {} stopped with unknown status {}", + __func__, m_pid, status); + } +} + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/launcher/LauncherPosix.h b/xbmc/addons/interface/launcher/LauncherPosix.h new file mode 100644 index 0000000000000..ddb4a8aebf603 --- /dev/null +++ b/xbmc/addons/interface/launcher/LauncherPosix.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:linux,freebsd,android,osx,darwin_embedded>---*/ + +#pragma once + +#include "ILauncher.h" + +#include + +#define HANDLE_EINTR(x) \ + ({ \ + decltype(x) eintr_wrapper_result; \ + do \ + { \ + eintr_wrapper_result = (x); \ + } while (eintr_wrapper_result == -1 && errno == EINTR); \ + eintr_wrapper_result; \ + }) + +#define RAW_CHECK(condition) \ + do \ + { \ + if (!(condition)) \ + CLog::Log(LOGERROR, "Check failed: " #condition); \ + } while (0) + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CLauncherPosix : public ILauncher +{ +public: + CLauncherPosix(std::shared_ptr addon, const std::string& uuid); + ~CLauncherPosix() = default; + + bool Launch(const std::vector& argv, bool waitForExit) override; + bool Kill(bool wait) override; + int64_t GetMainProcessPID() const override { return static_cast(m_pid); } + ChildStatus ProcessActive() override; + +private: + enum PIPE_FILE_DESCRIPTERS + { + READ_FD = 0, + WRITE_FD = 1 + }; + + void ProcessStatus(int status); + + std::atomic m_pid{-1}; + int m_childToParent[2]{-1}; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/CMakeLists.txt b/xbmc/addons/interface/processinfo/CMakeLists.txt new file mode 100644 index 0000000000000..a43abd41a2416 --- /dev/null +++ b/xbmc/addons/interface/processinfo/CMakeLists.txt @@ -0,0 +1,27 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + $<$:ProcessInfoAndroid.cpp> + $<$:ProcessInfoDarwinEmbedded.cpp> + $<$:ProcessInfoFreeBSD.cpp> + $<$:ProcessInfoLinux.cpp> + $<$:ProcessInfoOSX.cpp> + $<$:ProcessInfoWindows.cpp> + $<$:ProcessInfoWindowsStore.cpp> +) + +set(HEADERS + ProcessInfo.h + $<$:ProcessInfoAndroid.h> + $<$:ProcessInfoDarwinEmbedded.h> + $<$:ProcessInfoFreeBSD.h> + $<$:ProcessInfoLinux.h> + $<$:ProcessInfoOSX.h> + $<$:ProcessInfoWindows.h> + $<$:ProcessInfoWindowsStore.h> +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface_processinfo) +endif() diff --git a/xbmc/addons/interface/processinfo/ProcessInfo.h b/xbmc/addons/interface/processinfo/ProcessInfo.h new file mode 100644 index 0000000000000..d24cfcbf42217 --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfo.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include + +namespace ADDON +{ +class IAddon; +} + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct ProcessInfoData +{ + std::shared_ptr m_addon; + int64_t m_pid{-1}; + int m_usedThreadsAmount{-1}; + int m_usedCPUPercentage{0}; + uint64_t m_usedPhysicalMemoryAmount{0}; + uint64_t m_usedVirtualMemoryAmount{0}; + uint64_t m_usedSharedMemoryAmount{0}; +}; + +class CProcessInfo +{ +public: + CProcessInfo(std::shared_ptr addon, int64_t pid) : m_addon(addon), m_pid(pid) {} + virtual ~CProcessInfo() = default; + + virtual ProcessInfoData Calculate() = 0; + +protected: + std::shared_ptr m_addon; + int64_t m_pid; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoAndroid.cpp b/xbmc/addons/interface/processinfo/ProcessInfoAndroid.cpp new file mode 100644 index 0000000000000..b481492d91340 --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoAndroid.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:android>---*/ + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoAndroid.h b/xbmc/addons/interface/processinfo/ProcessInfoAndroid.h new file mode 100644 index 0000000000000..eaf9a5dd206f6 --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoAndroid.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:android>---*/ + +#pragma once + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoDarwinEmbedded.cpp b/xbmc/addons/interface/processinfo/ProcessInfoDarwinEmbedded.cpp new file mode 100644 index 0000000000000..0be8eccc1c322 --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoDarwinEmbedded.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:darwin_embedded>---*/ + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoDarwinEmbedded.h b/xbmc/addons/interface/processinfo/ProcessInfoDarwinEmbedded.h new file mode 100644 index 0000000000000..32cdcdfb5024d --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoDarwinEmbedded.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:darwin_embedded>---*/ + +#pragma once + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoFreeBSD.cpp b/xbmc/addons/interface/processinfo/ProcessInfoFreeBSD.cpp new file mode 100644 index 0000000000000..1e44a2160986d --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoFreeBSD.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:freebsd>---*/ + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoFreeBSD.h b/xbmc/addons/interface/processinfo/ProcessInfoFreeBSD.h new file mode 100644 index 0000000000000..cbda706313ad7 --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoFreeBSD.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:freebsd>---*/ + +#pragma once + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoLinux.cpp b/xbmc/addons/interface/processinfo/ProcessInfoLinux.cpp new file mode 100644 index 0000000000000..09cc8421eec2f --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoLinux.cpp @@ -0,0 +1,184 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:linux>---*/ + +#include "ProcessInfoLinux.h" + +#include "utils/StringUtils.h" +#include "utils/TimeUtils.h" + +#include +#include + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +#define m_lastTotalUser CProcessInfo::m_value1; +#define m_lastTotalUserLow CProcessInfo::m_value2; +#define m_lastTotalSys CProcessInfo::m_value3; +#define m_lastTotalIdle CProcessInfo::m_value4; + +CProcessInfoLinux::CProcessInfoLinux(std::shared_ptr addon, int64_t used_pid) + : CProcessInfo(addon, used_pid) +{ + m_currentInfo.m_addon = m_addon; + + std::ifstream procstat_stream("/proc/stat", std::ios_base::in); + std::string line; + std::getline(procstat_stream, line); + + uint64_t user; + uint64_t nice2; + uint64_t system; + uint64_t idle; + sscanf(line.c_str(), "%*s %lu %lu %lu %lu", &user, &nice2, &system, &idle); + m_lastTotalCPU = user + nice2 + system + idle; + + char buf[128]; + snprintf(buf, sizeof(buf), "/proc/%ld/stat", m_pid); + std::ifstream stat_stream(buf, std::ios_base::in); + + int64_t pid; + std::string comm; + char state[1]; + int ppid; + int pgrp; + int session; + int tty_nr; + int tpgid; + unsigned int flags; + uint32_t minflt; + uint32_t cminflt; + uint32_t majflt; + uint32_t cmajflt; + uint32_t utime; + uint32_t stime; + int32_t cutime; + int32_t cstime; + int32_t priority; + int32_t nice; + int32_t num_threads; + int32_t itrealvalue; + uint64_t starttime; + uint32_t vsize; + uint32_t rss; + + stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr >> tpgid >> flags >> + minflt >> cminflt >> majflt >> cmajflt >> utime >> stime >> cutime >> cstime >> priority >> + nice >> num_threads >> itrealvalue >> starttime >> vsize >> rss; + + stat_stream.close(); + + m_lastProcessCPU = utime + stime; + + std::ifstream cpuinfo_stream("/proc/cpuinfo", std::ios_base::in); + for (std::string line; std::getline(cpuinfo_stream, line);) + { + if (StringUtils::StartsWith(line, "processor")) + { + ++m_numProcessors; + } + } +} + +ProcessInfoData CProcessInfoLinux::Calculate() +{ + if (CTimeUtils::GetFrameTime() - m_lastInfoTime < UPDATE_INTERVAL) + return m_currentInfo; + + m_lastInfoTime = CTimeUtils::GetFrameTime(); + + char buf[128]; + snprintf(buf, sizeof(buf), "/proc/%ld/stat", m_pid); + std::ifstream stat_stream(buf, std::ios_base::in); + + int64_t pid; + std::string comm; + char state[1]; + int ppid; + int pgrp; + int session; + int tty_nr; + int tpgid; + unsigned int flags; + uint32_t minflt; + uint32_t cminflt; + uint32_t majflt; + uint32_t cmajflt; + uint64_t utime; + uint64_t stime; + uint64_t cutime; + uint64_t cstime; + int32_t priority; + int32_t nice; + int32_t num_threads; + int32_t itrealvalue; + uint64_t starttime; + uint32_t vsize; + uint32_t rss; + + stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr >> tpgid >> flags >> + minflt >> cminflt >> majflt >> cmajflt >> utime >> stime >> cutime >> cstime >> priority >> + nice >> num_threads >> itrealvalue >> starttime >> vsize >> rss; + + stat_stream.close(); + + m_currentInfo.m_pid = pid; + + snprintf(buf, sizeof(buf), "/proc/%ld/status", m_pid); + std::ifstream status_stream(buf, std::ios_base::in); + for (std::string line; std::getline(status_stream, line);) + { + StringUtils::RemoveDuplicatedSpacesAndTabs(line); + if (StringUtils::StartsWith(line, "RssShmem:")) + { + m_currentInfo.m_usedSharedMemoryAmount = atoll(line.c_str() + sizeof("RssShmem:")) * 1024; + } + else if (StringUtils::StartsWith(line, "VmSize:")) + { + m_currentInfo.m_usedVirtualMemoryAmount = atoll(line.c_str() + sizeof("VmSize:")) * 1024; + } + else if (StringUtils::StartsWith(line, "VmRSS:")) + { + m_currentInfo.m_usedPhysicalMemoryAmount = atoll(line.c_str() + sizeof("VmRSS:")) * 1024; + } + else if (StringUtils::StartsWith(line, "Threads:")) + { + m_currentInfo.m_usedThreadsAmount = atoll(line.c_str() + sizeof("Threads:")); + } + } + + std::ifstream procstat_stream("/proc/stat", std::ios_base::in); + std::string line; + std::getline(procstat_stream, line); + + uint64_t user; + uint64_t nice2; + uint64_t system; + uint64_t idle; + sscanf(line.c_str(), "%*s %lu %lu %lu %lu", &user, &nice2, &system, &idle); + uint64_t currentTotalCPU = user + nice2 + system + idle; + uint64_t currentProcessCPU = utime + stime; + + m_currentInfo.m_usedCPUPercentage = m_numProcessors * (currentProcessCPU - m_lastProcessCPU) * + 100 / (float)(currentTotalCPU - m_lastTotalCPU); + + m_lastTotalCPU = currentTotalCPU; + m_lastProcessCPU = currentProcessCPU; + + return m_currentInfo; +} + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoLinux.h b/xbmc/addons/interface/processinfo/ProcessInfoLinux.h new file mode 100644 index 0000000000000..c5e0d47267d1b --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoLinux.h @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:linux>---*/ + +#pragma once + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CProcessInfoLinux : public CProcessInfo +{ +public: + CProcessInfoLinux(std::shared_ptr addon, int64_t pid); + + ProcessInfoData Calculate() override; + +private: + static const int UPDATE_INTERVAL = 500; + mutable unsigned int m_lastInfoTime{static_cast(-UPDATE_INTERVAL)}; + + uint64_t m_lastTotalCPU; + uint64_t m_lastProcessCPU; + int m_numProcessors{0}; + ProcessInfoData m_currentInfo; +}; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoOSX.cpp b/xbmc/addons/interface/processinfo/ProcessInfoOSX.cpp new file mode 100644 index 0000000000000..c79f9ef7abff0 --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoOSX.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:osx>---*/ + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoOSX.h b/xbmc/addons/interface/processinfo/ProcessInfoOSX.h new file mode 100644 index 0000000000000..833d637bca920 --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoOSX.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:osx>---*/ + +#pragma once + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoWindows.cpp b/xbmc/addons/interface/processinfo/ProcessInfoWindows.cpp new file mode 100644 index 0000000000000..9985e76ab0b4a --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoWindows.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:windows>---*/ + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoWindows.h b/xbmc/addons/interface/processinfo/ProcessInfoWindows.h new file mode 100644 index 0000000000000..b83b3ca700350 --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoWindows.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:windows>---*/ + +#pragma once + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoWindowsStore.cpp b/xbmc/addons/interface/processinfo/ProcessInfoWindowsStore.cpp new file mode 100644 index 0000000000000..31a49181375e2 --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoWindowsStore.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:windowsstore>---*/ + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/processinfo/ProcessInfoWindowsStore.h b/xbmc/addons/interface/processinfo/ProcessInfoWindowsStore.h new file mode 100644 index 0000000000000..9112b3fc0869d --- /dev/null +++ b/xbmc/addons/interface/processinfo/ProcessInfoWindowsStore.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/*---AUTO_GEN_PARSE<$$CORE_SYSTEM_NAME:windowsstore>---*/ + +#pragma once + +#include "ProcessInfo.h" + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/renderer/CMakeLists.txt b/xbmc/addons/interface/renderer/CMakeLists.txt new file mode 100644 index 0000000000000..d4d302d9c3d63 --- /dev/null +++ b/xbmc/addons/interface/renderer/CMakeLists.txt @@ -0,0 +1,15 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + GLViewRenderer.cpp +) + +set(HEADERS + GLViewRenderer.h + IRenderHelper.h +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface_renderer) +endif() diff --git a/xbmc/addons/interface/renderer/GLViewRenderer.cpp b/xbmc/addons/interface/renderer/GLViewRenderer.cpp new file mode 100644 index 0000000000000..6e7a1e183f238 --- /dev/null +++ b/xbmc/addons/interface/renderer/GLViewRenderer.cpp @@ -0,0 +1,225 @@ +/* + * Copyright (C) 2020 Team Kodi (https://kodi.tv) + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSE.md for more information. + */ + +#include "GLViewRenderer.h" + +#include "ServiceBroker.h" +#include "addons/kodi-dev-kit/src/shared/SharedGL.h" +#include "filesystem/File.h" +#include "rendering/RenderSystem.h" +#include "utils/EGLUtils.h" +#include "utils/StringUtils.h" +#include "utils/log.h" +#include "../kodi-dev-kit/src/shared/SharedData.h" +#include "../kodi-dev-kit/src/shared/socket.h" + +using namespace KODI::ADDONS::INTERFACE; + +namespace +{ + +constexpr const float render_vertices[20] = { + -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, // top left + 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, // top right + 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, // bottom right + -1.0f, 1.0f, 0.0f, 0.0f, 1.0f // bottom left +}; + +constexpr const unsigned char render_indices[4] = {0, 1, 3, 2}; + +} // namespace + +CViewRendererOpenGL::CViewRendererOpenGL(const std::string& clientIdentifier) + : m_socketServerFile("/tmp/" + clientIdentifier + "-renderproc"), + m_socketClientFile("/tmp/" + clientIdentifier + "-renderview") +{ +} + +CViewRendererOpenGL::~CViewRendererOpenGL() +{ + Deinit(); +} + +bool CViewRendererOpenGL::Init() +{ + if (m_inited) + return true; + + std::string vertShader, fraqShader; + GetShaders(vertShader, fraqShader); + if (!LoadShaderFiles(vertShader, fraqShader) || !CompileAndLink()) + { + CLog::Log(LOGERROR, "Failed to create or compile shader"); + return false; + } + + m_eglDisplay = eglGetCurrentDisplay(); + if (m_eglDisplay == EGL_NO_DISPLAY) + { + CLog::Log(LOGERROR, "Not get EGL display"); + return false; + } + + if (!CEGLUtils::HasExtension(m_eglDisplay, "EGL_KHR_image_base")) + { + CLog::Log(LOGERROR, "Needed EGL extension \"EGL_KHR_image_base\" not available"); + return false; + } + + if (!CServiceBroker::GetRenderSystem()->IsExtSupported("GL_OES_EGL_image")) + { + CLog::Log(LOGERROR, "Needed EGL extension \"GL_OES_EGL_image\" not available"); + return false; + } + + eglCreateImageKHR = CEGLUtils::GetRequiredProcAddress("eglCreateImageKHR"); + eglDestroyImageKHR = CEGLUtils::GetRequiredProcAddress("eglDestroyImageKHR"); + glEGLImageTargetTexture2DOES = CEGLUtils::GetRequiredProcAddress("glEGLImageTargetTexture2DOES"); + + glEnable(GL_BLEND); + + // Unix Domain Socket: Receive file descriptor (texture_dmabuf_fd) and texture storage data (dmabuf) + int texture_dmabuf_fd; + struct texture_storage_metadata_t dmabuf; + + int sock = create_socket(m_socketClientFile.c_str()); + read_fd(sock, &texture_dmabuf_fd, &dmabuf, sizeof(dmabuf)); + close(sock); + + int i = 0; + EGLint attribute_list[64]; + + attribute_list[i++] = EGL_WIDTH; + attribute_list[i++] = dmabuf.width; + attribute_list[i++] = EGL_HEIGHT; + attribute_list[i++] = dmabuf.height; + attribute_list[i++] = EGL_LINUX_DRM_FOURCC_EXT; + attribute_list[i++] = dmabuf.fourcc; + + attribute_list[i++] = EGL_DMA_BUF_PLANE0_FD_EXT; + attribute_list[i++] = texture_dmabuf_fd; + attribute_list[i++] = EGL_DMA_BUF_PLANE0_PITCH_EXT; + attribute_list[i++] = dmabuf.stride; + attribute_list[i++] = EGL_DMA_BUF_PLANE0_OFFSET_EXT; + attribute_list[i++] = dmabuf.offset; +#ifdef EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT + if (dmabuf.modifiers) + { + attribute_list[i++] = EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT; + attribute_list[i++] = static_cast(dmabuf.modifiers & 0xFFFFFFFF); + attribute_list[i++] = EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT; + attribute_list[i++] = static_cast(dmabuf.modifiers >> 32); + } +#endif + attribute_list[i++] = EGL_NONE; + + m_image = eglCreateImageKHR(m_eglDisplay, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, nullptr, + attribute_list); + if (m_image == EGL_NO_IMAGE) + { + CLog::Log(LOGERROR, "Failed to get EGL image"); + return false; + } + + XFILE::CFile::Delete(m_socketServerFile); + XFILE::CFile::Delete(m_socketClientFile); + + // GL texture that will be shared + glGenTextures(1, &m_texture); + glBindTexture(GL_TEXTURE_2D, m_texture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + + glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, m_image); + eglDestroyImageKHR(m_eglDisplay, m_image); + + glBindTexture(GL_TEXTURE_2D, 0); + + close(texture_dmabuf_fd); + + glGenBuffers(1, &m_vertexVBO); + glGenBuffers(1, &m_indexVBO); + + m_inited = true; + return true; +} + +void CViewRendererOpenGL::Deinit() +{ + if (!m_inited) + return; + + m_inited = false; + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, 0); + glDeleteTextures(1, &m_texture); + m_texture = 0; + + glBindBuffer(GL_ARRAY_BUFFER, 0); + glDeleteBuffers(1, &m_vertexVBO); + m_vertexVBO = 0; + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + glDeleteBuffers(1, &m_indexVBO); + m_indexVBO = 0; +} + +void CViewRendererOpenGL::Begin() +{ + +} + +void CViewRendererOpenGL::End() +{ + if (!m_inited) + return; + + glBindBuffer(GL_ARRAY_BUFFER, m_vertexVBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(render_vertices), render_vertices, GL_STATIC_DRAW); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexVBO); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(render_indices), render_indices, GL_STATIC_DRAW); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0); + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float))); + + Enable(); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, m_texture); + glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, 0); + + Disable(); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + glBindBuffer(GL_ARRAY_BUFFER, 0); +} + +void CViewRendererOpenGL::OnCompiledAndLinked() +{ + m_aPosition = glGetAttribLocation(ProgramHandle(), "aPos"); + m_aCoord = glGetAttribLocation(ProgramHandle(), "aTexCoords"); +} + +bool CViewRendererOpenGL::OnEnabled() +{ + return true; +} + +void CViewRendererOpenGL::GetShaders(std::string& vert, std::string& frag) +{ +#if defined(HAS_GL) + vert = "gl_shader_vert_addon_backend.glsl"; + frag = "gl_shader_frag_addon_backend.glsl"; +#else + vert = "gles_shader_vert_addon_backend.glsl"; + frag = "gles_shader_frag_addon_backend.glsl"; +#endif +} diff --git a/xbmc/addons/interface/renderer/GLViewRenderer.h b/xbmc/addons/interface/renderer/GLViewRenderer.h new file mode 100644 index 0000000000000..d562030c83b1c --- /dev/null +++ b/xbmc/addons/interface/renderer/GLViewRenderer.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2020 Team Kodi (https://kodi.tv) + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSE.md for more information. + */ + +#pragma once + +#include "system_egl.h" +#include "IRenderHelper.h" +#include "guilib/Shader.h" + +#include + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CViewRendererOpenGL : public Shaders::CGLSLShaderProgram, public IRenderHelper +{ +public: + CViewRendererOpenGL(const std::string& clientIdentifier); + ~CViewRendererOpenGL(); + + bool Init() override; + void Deinit() override; + void Begin() override; + void End() override; + +protected: + void OnCompiledAndLinked() override; + bool OnEnabled() override; + +private: + void GetShaders(std::string& vert, std::string& frag); + + const std::string m_socketServerFile; + const std::string m_socketClientFile; + + EGLDisplay m_eglDisplay = EGL_NO_DISPLAY; + EGLImageKHR m_image = EGL_NO_IMAGE_KHR; + + GLuint m_vertexVBO = 0; + GLuint m_indexVBO = 0; + + GLint m_aPosition = -1; + GLint m_aCoord = -1; + GLuint m_texture = 0; + + PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR = nullptr; + PFNEGLDESTROYIMAGEKHRPROC eglDestroyImageKHR = nullptr; + PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES = nullptr; + + bool m_inited = false; +}; + +using CRenderHelper = CViewRendererOpenGL; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interface/renderer/IRenderHelper.h b/xbmc/addons/interface/renderer/IRenderHelper.h new file mode 100644 index 0000000000000..eebfac8379f87 --- /dev/null +++ b/xbmc/addons/interface/renderer/IRenderHelper.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct IRenderHelper +{ + virtual ~IRenderHelper() = default; + virtual bool Init() = 0; + virtual void Deinit() = 0; + virtual void Begin() = 0; + virtual void End() = 0; +}; /* class IRenderHelper */ + +struct CRenderHelperStub : public IRenderHelper +{ + CRenderHelperStub(const std::string& clientIdentifier) {} + bool Init() override { return true; } + void Deinit() override {} + void Begin() override {} + void End() override {} +}; /* class CRenderHelperStub */ + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +#if defined(TARGET_LINUX) +#include "GLViewRenderer.h" +#endif diff --git a/xbmc/addons/interface/tools/CMakeLists.txt b/xbmc/addons/interface/tools/CMakeLists.txt new file mode 100644 index 0000000000000..e88ea3486fd47 --- /dev/null +++ b/xbmc/addons/interface/tools/CMakeLists.txt @@ -0,0 +1,14 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + GUITranslator.cpp +) + +set(HEADERS + GUITranslator.h +) + +if(NOT ENABLE_STATIC_LIBS OR SOURCES) + core_add_library(addons_interface_tools) +endif() diff --git a/xbmc/addons/interfaces/gui/GUITranslator.cpp b/xbmc/addons/interface/tools/GUITranslator.cpp similarity index 99% rename from xbmc/addons/interfaces/gui/GUITranslator.cpp rename to xbmc/addons/interface/tools/GUITranslator.cpp index 2db26011ac9d9..058c0df6ff377 100644 --- a/xbmc/addons/interfaces/gui/GUITranslator.cpp +++ b/xbmc/addons/interface/tools/GUITranslator.cpp @@ -10,7 +10,7 @@ #include "input/actions/ActionIDs.h" -using namespace ADDON; +using namespace KODI::ADDONS::INTERFACE; ADDON_ACTION CAddonGUITranslator::TranslateActionIdToAddon(int kodiId) { diff --git a/xbmc/addons/interfaces/gui/GUITranslator.h b/xbmc/addons/interface/tools/GUITranslator.h similarity index 87% rename from xbmc/addons/interfaces/gui/GUITranslator.h rename to xbmc/addons/interface/tools/GUITranslator.h index 8bd6b5c1ef4a3..42dddede2f5fc 100644 --- a/xbmc/addons/interfaces/gui/GUITranslator.h +++ b/xbmc/addons/interface/tools/GUITranslator.h @@ -10,7 +10,11 @@ #include "addons/kodi-dev-kit/include/kodi/c-api/gui/input/action_ids.h" -namespace ADDON +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE { /*! @@ -38,4 +42,6 @@ class CAddonGUITranslator static int TranslateActionIdToKodi(ADDON_ACTION addonId); }; -} /* namespace ADDON */ +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ diff --git a/xbmc/addons/interfaces/AddonBase.cpp b/xbmc/addons/interfaces/AddonBase.cpp deleted file mode 100644 index e00130d74191d..0000000000000 --- a/xbmc/addons/interfaces/AddonBase.cpp +++ /dev/null @@ -1,657 +0,0 @@ -/* - * Copyright (C) 2005-2020 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "AddonBase.h" - -#include "Application.h" -#include "GUIUserMessages.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/gui/GUIDialogAddonSettings.h" -#include "addons/settings/AddonSettings.h" -#include "filesystem/Directory.h" -#include "filesystem/SpecialProtocol.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUIWindowManager.h" -#include "guilib/LocalizeStrings.h" -#include "utils/URIUtils.h" -#include "utils/log.h" - -// "C" interface addon callback handle classes -#include "AudioEngine.h" -#include "Filesystem.h" -#include "General.h" -#include "Network.h" -#include "gui/General.h" - -namespace ADDON -{ - -std::vector Interface_Base::s_registeredInterfaces; - -bool Interface_Base::InitInterface(CAddonDll* addon, - AddonGlobalInterface& addonInterface, - KODI_ADDON_INSTANCE_STRUCT* firstKodiInstance) -{ - addonInterface = {}; - - addonInterface.addonBase = nullptr; - addonInterface.globalSingleInstance = nullptr; - addonInterface.firstKodiInstance = firstKodiInstance; - - // Create function list from kodi to addon, generated with malloc to have - // compatible with other versions - addonInterface.toKodi = new AddonToKodiFuncTable_Addon(); - addonInterface.toKodi->kodiBase = addon; - addonInterface.toKodi->addon_log_msg = addon_log_msg; - addonInterface.toKodi->free_string = free_string; - addonInterface.toKodi->free_string_array = free_string_array; - - addonInterface.toKodi->kodi_addon = new AddonToKodiFuncTable_kodi_addon(); - addonInterface.toKodi->kodi_addon->get_addon_path = get_addon_path; - addonInterface.toKodi->kodi_addon->get_lib_path = get_lib_path; - addonInterface.toKodi->kodi_addon->get_user_path = get_user_path; - addonInterface.toKodi->kodi_addon->get_temp_path = get_temp_path; - addonInterface.toKodi->kodi_addon->get_localized_string = get_localized_string; - addonInterface.toKodi->kodi_addon->open_settings_dialog = open_settings_dialog; - addonInterface.toKodi->kodi_addon->is_setting_using_default = is_setting_using_default; - addonInterface.toKodi->kodi_addon->get_setting_bool = get_setting_bool; - addonInterface.toKodi->kodi_addon->get_setting_int = get_setting_int; - addonInterface.toKodi->kodi_addon->get_setting_float = get_setting_float; - addonInterface.toKodi->kodi_addon->get_setting_string = get_setting_string; - addonInterface.toKodi->kodi_addon->set_setting_bool = set_setting_bool; - addonInterface.toKodi->kodi_addon->set_setting_int = set_setting_int; - addonInterface.toKodi->kodi_addon->set_setting_float = set_setting_float; - addonInterface.toKodi->kodi_addon->set_setting_string = set_setting_string; - addonInterface.toKodi->kodi_addon->get_addon_info = get_addon_info; - addonInterface.toKodi->kodi_addon->get_type_version = get_type_version; - addonInterface.toKodi->kodi_addon->get_interface = get_interface; - - // Related parts becomes set from addon headers, make here to nullptr to allow - // checks for right set of them - addonInterface.toAddon = new KodiToAddonFuncTable_Addon(); - - // Init the other interfaces - Interface_General::Init(&addonInterface); - Interface_AudioEngine::Init(&addonInterface); - Interface_Filesystem::Init(&addonInterface); - Interface_Network::Init(&addonInterface); - Interface_GUIGeneral::Init(&addonInterface); - - return true; -} - -void Interface_Base::DeInitInterface(AddonGlobalInterface& addonInterface) -{ - Interface_GUIGeneral::DeInit(&addonInterface); - Interface_Network::DeInit(&addonInterface); - Interface_Filesystem::DeInit(&addonInterface); - Interface_AudioEngine::DeInit(&addonInterface); - Interface_General::DeInit(&addonInterface); - - if (addonInterface.toKodi) - delete addonInterface.toKodi->kodi_addon; - delete addonInterface.toKodi; - delete addonInterface.toAddon; - addonInterface = {}; -} - -void Interface_Base::RegisterInterface(ADDON_GET_INTERFACE_FN fn) -{ - s_registeredInterfaces.push_back(fn); -} - -bool Interface_Base::UpdateSettingInActiveDialog(CAddonDll* addon, - AddonInstanceId instanceId, - const char* id, - const std::string& value) -{ - if (!CServiceBroker::GetGUI()->GetWindowManager().IsWindowActive(WINDOW_DIALOG_ADDON_SETTINGS)) - return false; - - CGUIDialogAddonSettings* dialog = - CServiceBroker::GetGUI()->GetWindowManager().GetWindow( - WINDOW_DIALOG_ADDON_SETTINGS); - if (dialog->GetCurrentAddonID() != addon->ID()) - return false; - - CGUIMessage message(GUI_MSG_SETTING_UPDATED, 0, 0); - std::vector params; - params.emplace_back(id); - params.push_back(value); - message.SetStringParams(params); - message.SetParam1(instanceId); - CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(message, - WINDOW_DIALOG_ADDON_SETTINGS); - - return true; -} - -/*! - * @brief Addon to Kodi basic callbacks below - * - * The amount of functions here are hold so minimal as possible. Only parts - * where needed on nearly every add-on (e.g. addon_log_msg) are to add there. - * - * More specific parts like e.g. to open files should be added to a separate - * part. - */ -//@{ - -void Interface_Base::addon_log_msg(const KODI_ADDON_BACKEND_HDL hdl, - const int addonLogLevel, - const char* strMessage) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "addon_log_msg(...) called with empty kodi instance pointer"); - return; - } - - int logLevel = LOGNONE; - switch (addonLogLevel) - { - case ADDON_LOG_DEBUG: - logLevel = LOGDEBUG; - break; - case ADDON_LOG_INFO: - logLevel = LOGINFO; - break; - case ADDON_LOG_WARNING: - logLevel = LOGWARNING; - break; - case ADDON_LOG_ERROR: - logLevel = LOGERROR; - break; - case ADDON_LOG_FATAL: - logLevel = LOGFATAL; - break; - default: - logLevel = LOGDEBUG; - break; - } - - CLog::Log(logLevel, "AddOnLog: {}: {}", addon->ID(), strMessage); -} - -char* Interface_Base::get_type_version(const KODI_ADDON_BACKEND_HDL hdl, int type) -{ - return strdup(kodi::addon::GetTypeVersion(type)); -} - -char* Interface_Base::get_addon_path(const KODI_ADDON_BACKEND_HDL hdl) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "get_addon_path(...) called with empty kodi instance pointer"); - return nullptr; - } - - return strdup(CSpecialProtocol::TranslatePath(addon->Path()).c_str()); -} - -char* Interface_Base::get_lib_path(const KODI_ADDON_BACKEND_HDL hdl) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "get_lib_path(...) called with empty kodi instance pointer"); - return nullptr; - } - - return strdup(CSpecialProtocol::TranslatePath("special://xbmcbinaddons/" + addon->ID()).c_str()); -} - -char* Interface_Base::get_user_path(const KODI_ADDON_BACKEND_HDL hdl) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "get_user_path(...) called with empty kodi instance pointer"); - return nullptr; - } - - return strdup(CSpecialProtocol::TranslatePath(addon->Profile()).c_str()); -} - -char* Interface_Base::get_temp_path(const KODI_ADDON_BACKEND_HDL hdl) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "get_temp_path(...) called with empty kodi instance pointer"); - return nullptr; - } - - std::string tempPath = - URIUtils::AddFileToFolder(CServiceBroker::GetAddonMgr().GetTempAddonBasePath(), addon->ID()); - tempPath += "-temp"; - XFILE::CDirectory::Create(tempPath); - - return strdup(CSpecialProtocol::TranslatePath(tempPath).c_str()); -} - -char* Interface_Base::get_localized_string(const KODI_ADDON_BACKEND_HDL hdl, long label_id) -{ - CAddonDll* addon = static_cast(hdl); - if (!addon) - { - CLog::Log(LOGERROR, "get_localized_string(...) called with empty kodi instance pointer"); - return nullptr; - } - - if (g_application.m_bStop) - return nullptr; - - std::string label = g_localizeStrings.GetAddonString(addon->ID(), label_id); - if (label.empty()) - label = g_localizeStrings.Get(label_id); - char* buffer = strdup(label.c_str()); - return buffer; -} - -char* Interface_Base::get_addon_info(const KODI_ADDON_BACKEND_HDL hdl, const char* id) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr || id == nullptr) - { - CLog::Log(LOGERROR, "get_addon_info(...) called with empty pointer"); - return nullptr; - } - - std::string str; - if (StringUtils::CompareNoCase(id, "author") == 0) - str = addon->Author(); - else if (StringUtils::CompareNoCase(id, "changelog") == 0) - str = addon->ChangeLog(); - else if (StringUtils::CompareNoCase(id, "description") == 0) - str = addon->Description(); - else if (StringUtils::CompareNoCase(id, "disclaimer") == 0) - str = addon->Disclaimer(); - else if (StringUtils::CompareNoCase(id, "fanart") == 0) - str = addon->FanArt(); - else if (StringUtils::CompareNoCase(id, "icon") == 0) - str = addon->Icon(); - else if (StringUtils::CompareNoCase(id, "id") == 0) - str = addon->ID(); - else if (StringUtils::CompareNoCase(id, "name") == 0) - str = addon->Name(); - else if (StringUtils::CompareNoCase(id, "path") == 0) - str = addon->Path(); - else if (StringUtils::CompareNoCase(id, "profile") == 0) - str = addon->Profile(); - else if (StringUtils::CompareNoCase(id, "summary") == 0) - str = addon->Summary(); - else if (StringUtils::CompareNoCase(id, "type") == 0) - str = ADDON::CAddonInfo::TranslateType(addon->Type()); - else if (StringUtils::CompareNoCase(id, "version") == 0) - str = addon->Version().asString(); - else - { - CLog::Log(LOGERROR, "Interface_Base::{} - add-on '{}' requests invalid id '{}'", __func__, - addon->Name(), id); - return nullptr; - } - - char* buffer = strdup(str.c_str()); - return buffer; -} - -bool Interface_Base::open_settings_dialog(const KODI_ADDON_BACKEND_HDL hdl) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "open_settings_dialog(...) called with empty kodi instance pointer"); - return false; - } - - // show settings dialog - AddonPtr addonInfo; - if (!CServiceBroker::GetAddonMgr().GetAddon(addon->ID(), addonInfo, ADDON_UNKNOWN, - OnlyEnabled::CHOICE_YES)) - { - CLog::Log(LOGERROR, "Interface_Base::{} - Could not get addon information for '{}'", __func__, - addon->ID()); - return false; - } - - return CGUIDialogAddonSettings::ShowForAddon(addonInfo); -} - -bool Interface_Base::is_setting_using_default(const KODI_ADDON_BACKEND_HDL hdl, const char* id) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr || id == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid data (addon='{}', id='{}')", __func__, hdl, - static_cast(id)); - - return false; - } - - if (!addon->HasSettings()) - { - CLog::Log(LOGERROR, "Interface_Base::{} - couldn't get settings for add-on '{}'", __func__, - addon->Name()); - return false; - } - - auto setting = addon->GetSettings()->GetSetting(id); - if (setting == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - can't find setting '{}' in '{}'", __func__, id, - addon->Name()); - return false; - } - - return setting->IsDefault(); -} - -bool Interface_Base::get_setting_bool(const KODI_ADDON_BACKEND_HDL hdl, const char* id, bool* value) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr || id == nullptr || value == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid data (addon='{}', id='{}', value='{}')", - __func__, hdl, static_cast(id), static_cast(value)); - - return false; - } - - if (!addon->HasSettings()) - { - CLog::Log(LOGERROR, "Interface_Base::{} - couldn't get settings for add-on '{}'", __func__, - addon->Name()); - return false; - } - - auto setting = addon->GetSettings()->GetSetting(id); - if (setting == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - can't find setting '{}' in '{}'", __func__, id, - addon->Name()); - return false; - } - - if (setting->GetType() != SettingType::Boolean) - { - CLog::Log(LOGERROR, "Interface_Base::{} - setting '{}' is not a boolean in '{}'", __func__, id, - addon->Name()); - return false; - } - - *value = std::static_pointer_cast(setting)->GetValue(); - return true; -} - -bool Interface_Base::get_setting_int(const KODI_ADDON_BACKEND_HDL hdl, const char* id, int* value) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr || id == nullptr || value == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid data (addon='{}', id='{}', value='{}')", - __func__, hdl, static_cast(id), static_cast(value)); - - return false; - } - - if (!addon->HasSettings()) - { - CLog::Log(LOGERROR, "Interface_Base::{} - couldn't get settings for add-on '{}'", __func__, - addon->Name()); - return false; - } - - auto setting = addon->GetSettings()->GetSetting(id); - if (setting == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - can't find setting '{}' in '{}'", __func__, id, - addon->Name()); - return false; - } - - if (setting->GetType() != SettingType::Integer && setting->GetType() != SettingType::Number) - { - CLog::Log(LOGERROR, "Interface_Base::{} - setting '{}' is not a integer in '{}'", __func__, id, - addon->Name()); - return false; - } - - if (setting->GetType() == SettingType::Integer) - *value = std::static_pointer_cast(setting)->GetValue(); - else - *value = static_cast(std::static_pointer_cast(setting)->GetValue()); - return true; -} - -bool Interface_Base::get_setting_float(const KODI_ADDON_BACKEND_HDL hdl, - const char* id, - float* value) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr || id == nullptr || value == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid data (addon='{}', id='{}', value='{}')", - __func__, hdl, static_cast(id), static_cast(value)); - - return false; - } - - if (!addon->HasSettings()) - { - CLog::Log(LOGERROR, "Interface_Base::{} - couldn't get settings for add-on '{}'", __func__, - addon->Name()); - return false; - } - - auto setting = addon->GetSettings()->GetSetting(id); - if (setting == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - can't find setting '{}' in '{}'", __func__, id, - addon->Name()); - return false; - } - - if (setting->GetType() != SettingType::Number) - { - CLog::Log(LOGERROR, "Interface_Base::{} - setting '{}' is not a number in '{}'", __func__, id, - addon->Name()); - return false; - } - - *value = static_cast(std::static_pointer_cast(setting)->GetValue()); - return true; -} - -bool Interface_Base::get_setting_string(const KODI_ADDON_BACKEND_HDL hdl, - const char* id, - char** value) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr || id == nullptr || value == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid data (addon='{}', id='{}', value='{}')", - __func__, hdl, static_cast(id), static_cast(value)); - - return false; - } - - if (!addon->HasSettings()) - { - CLog::Log(LOGERROR, "Interface_Base::{} - couldn't get settings for add-on '{}'", __func__, - addon->Name()); - return false; - } - - auto setting = addon->GetSettings()->GetSetting(id); - if (setting == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - can't find setting '{}' in '{}'", __func__, id, - addon->Name()); - return false; - } - - if (setting->GetType() != SettingType::String) - { - CLog::Log(LOGERROR, "Interface_Base::{} - setting '{}' is not a string in '{}'", __func__, id, - addon->Name()); - return false; - } - - *value = strdup(std::static_pointer_cast(setting)->GetValue().c_str()); - return true; -} - -bool Interface_Base::set_setting_bool(const KODI_ADDON_BACKEND_HDL hdl, const char* id, bool value) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr || id == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid data (addon='{}', id='{}')", __func__, hdl, - static_cast(id)); - - return false; - } - - if (Interface_Base::UpdateSettingInActiveDialog(addon, ADDON_SETTINGS_ID, id, - value ? "true" : "false")) - return true; - - if (!addon->UpdateSettingBool(id, value)) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid setting type", __func__); - return false; - } - - addon->SaveSettings(); - - return true; -} - -bool Interface_Base::set_setting_int(const KODI_ADDON_BACKEND_HDL hdl, const char* id, int value) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr || id == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid data (addon='{}', id='{}')", __func__, hdl, - static_cast(id)); - - return false; - } - - if (Interface_Base::UpdateSettingInActiveDialog(addon, ADDON_SETTINGS_ID, id, - std::to_string(value))) - return true; - - if (!addon->UpdateSettingInt(id, value)) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid setting type", __func__); - return false; - } - - addon->SaveSettings(); - - return true; -} - -bool Interface_Base::set_setting_float(const KODI_ADDON_BACKEND_HDL hdl, - const char* id, - float value) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr || id == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid data (addon='{}', id='{}')", __func__, hdl, - static_cast(id)); - - return false; - } - - if (Interface_Base::UpdateSettingInActiveDialog(addon, ADDON_SETTINGS_ID, id, - StringUtils::Format("{:f}", value))) - return true; - - if (!addon->UpdateSettingNumber(id, static_cast(value))) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid setting type", __func__); - return false; - } - - addon->SaveSettings(); - - return true; -} - -bool Interface_Base::set_setting_string(const KODI_ADDON_BACKEND_HDL hdl, - const char* id, - const char* value) -{ - CAddonDll* addon = static_cast(hdl); - if (addon == nullptr || id == nullptr || value == nullptr) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid data (addon='{}', id='{}', value='{}')", - __func__, hdl, static_cast(id), static_cast(value)); - - return false; - } - - if (Interface_Base::UpdateSettingInActiveDialog(addon, ADDON_SETTINGS_ID, id, value)) - return true; - - if (!addon->UpdateSettingString(id, value)) - { - CLog::Log(LOGERROR, "Interface_Base::{} - invalid setting type", __func__); - return false; - } - - addon->SaveSettings(); - - return true; -} - -void Interface_Base::free_string(const KODI_ADDON_BACKEND_HDL hdl, char* str) -{ - if (str) - free(str); -} - -void Interface_Base::free_string_array(const KODI_ADDON_BACKEND_HDL hdl, - char** arr, - int numElements) -{ - if (arr) - { - for (int i = 0; i < numElements; ++i) - { - free(arr[i]); - } - free(arr); - } -} - -void* Interface_Base::get_interface(const KODI_ADDON_BACKEND_HDL hdl, - const char* name, - const char* version) -{ - if (!name || !version) - return nullptr; - - void* retval(nullptr); - - for (auto fn : s_registeredInterfaces) - if ((retval = fn(name, version))) - break; - - return retval; -} - -//@} - -} // namespace ADDON diff --git a/xbmc/addons/interfaces/AddonBase.h b/xbmc/addons/interfaces/AddonBase.h deleted file mode 100644 index a9e9a4b218e3e..0000000000000 --- a/xbmc/addons/interfaces/AddonBase.h +++ /dev/null @@ -1,87 +0,0 @@ -/* - * Copyright (C) 2005-2020 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/IAddon.h" -#include "addons/kodi-dev-kit/include/kodi/AddonBase.h" - -extern "C" -{ -namespace ADDON -{ - -typedef void* (*ADDON_GET_INTERFACE_FN)(const std::string& name, const std::string& version); - -class CAddonDll; - -/*! - * @brief Global general Add-on to Kodi callback functions - * - * To hold general functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/General.h" - */ -struct Interface_Base -{ - static bool InitInterface(CAddonDll* addon, - AddonGlobalInterface& addonInterface, - KODI_ADDON_INSTANCE_STRUCT* firstKodiInstance); - static void DeInitInterface(AddonGlobalInterface& addonInterface); - static void RegisterInterface(ADDON_GET_INTERFACE_FN fn); - static bool UpdateSettingInActiveDialog(CAddonDll* addon, - AddonInstanceId instanceId, - const char* id, - const std::string& value); - - static std::vector s_registeredInterfaces; - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void addon_log_msg(const KODI_ADDON_BACKEND_HDL hdl, - const int addonLogLevel, - const char* strMessage); - static char* get_type_version(const KODI_ADDON_BACKEND_HDL hdl, int type); - static char* get_addon_path(const KODI_ADDON_BACKEND_HDL hdl); - static char* get_lib_path(const KODI_ADDON_BACKEND_HDL hdl); - static char* get_user_path(const KODI_ADDON_BACKEND_HDL hdl); - static char* get_temp_path(const KODI_ADDON_BACKEND_HDL hdl); - static char* get_localized_string(const KODI_ADDON_BACKEND_HDL hdl, long label_id); - static char* get_addon_info(const KODI_ADDON_BACKEND_HDL hdl, const char* id); - static bool open_settings_dialog(const KODI_ADDON_BACKEND_HDL hdl); - static bool is_setting_using_default(const KODI_ADDON_BACKEND_HDL hdl, const char* id); - static bool get_setting_bool(const KODI_ADDON_BACKEND_HDL hdl, const char* id, bool* value); - static bool get_setting_int(const KODI_ADDON_BACKEND_HDL hdl, const char* id, int* value); - static bool get_setting_float(const KODI_ADDON_BACKEND_HDL hdl, const char* id, float* value); - static bool get_setting_string(const KODI_ADDON_BACKEND_HDL hdl, const char* id, char** value); - static bool set_setting_bool(const KODI_ADDON_BACKEND_HDL hdl, const char* id, bool value); - static bool set_setting_int(const KODI_ADDON_BACKEND_HDL hdl, const char* id, int value); - static bool set_setting_float(const KODI_ADDON_BACKEND_HDL hdl, const char* id, float value); - static bool set_setting_string(const KODI_ADDON_BACKEND_HDL hdl, - const char* id, - const char* value); - static void free_string(const KODI_ADDON_BACKEND_HDL hdl, char* str); - static void free_string_array(const KODI_ADDON_BACKEND_HDL hdl, char** arr, int numElements); - static void* get_interface(const KODI_ADDON_BACKEND_HDL hdl, - const char* name, - const char* version); - //@} -}; - -} /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/AudioEngine.cpp b/xbmc/addons/interfaces/AudioEngine.cpp deleted file mode 100644 index 0efcc07f3f091..0000000000000 --- a/xbmc/addons/interfaces/AudioEngine.cpp +++ /dev/null @@ -1,761 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "AudioEngine.h" - -#include "ServiceBroker.h" -#include "addons/kodi-dev-kit/include/kodi/AddonBase.h" -#include "cores/AudioEngine/Interfaces/AE.h" -#include "cores/AudioEngine/Interfaces/AEStream.h" -#include "cores/AudioEngine/Utils/AEStreamData.h" -#include "utils/log.h" - -using namespace kodi; // addon-dev-kit namespace -using namespace kodi::audioengine; // addon-dev-kit namespace - -namespace ADDON -{ - -void Interface_AudioEngine::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_audioengine = new AddonToKodiFuncTable_kodi_audioengine(); - - // write KODI audio DSP specific add-on function addresses to callback table - addonInterface->toKodi->kodi_audioengine->make_stream = audioengine_make_stream; - addonInterface->toKodi->kodi_audioengine->free_stream = audioengine_free_stream; - addonInterface->toKodi->kodi_audioengine->get_current_sink_format = get_current_sink_format; - - // AEStream add-on function callback table - addonInterface->toKodi->kodi_audioengine->aestream_get_space = aestream_get_space; - addonInterface->toKodi->kodi_audioengine->aestream_add_data = aestream_add_data; - addonInterface->toKodi->kodi_audioengine->aestream_get_delay = aestream_get_delay; - addonInterface->toKodi->kodi_audioengine->aestream_is_buffering = aestream_is_buffering; - addonInterface->toKodi->kodi_audioengine->aestream_get_cache_time = aestream_get_cache_time; - addonInterface->toKodi->kodi_audioengine->aestream_get_cache_total = aestream_get_cache_total; - addonInterface->toKodi->kodi_audioengine->aestream_pause = aestream_pause; - addonInterface->toKodi->kodi_audioengine->aestream_resume = aestream_resume; - addonInterface->toKodi->kodi_audioengine->aestream_drain = aestream_drain; - addonInterface->toKodi->kodi_audioengine->aestream_is_draining = aestream_is_draining; - addonInterface->toKodi->kodi_audioengine->aestream_is_drained = aestream_is_drained; - addonInterface->toKodi->kodi_audioengine->aestream_flush = aestream_flush; - addonInterface->toKodi->kodi_audioengine->aestream_get_volume = aestream_get_volume; - addonInterface->toKodi->kodi_audioengine->aestream_set_volume = aestream_set_volume; - addonInterface->toKodi->kodi_audioengine->aestream_get_amplification = aestream_get_amplification; - addonInterface->toKodi->kodi_audioengine->aestream_set_amplification = aestream_set_amplification; - addonInterface->toKodi->kodi_audioengine->aestream_get_frame_size = aestream_get_frame_size; - addonInterface->toKodi->kodi_audioengine->aestream_get_channel_count = aestream_get_channel_count; - addonInterface->toKodi->kodi_audioengine->aestream_get_sample_rate = aestream_get_sample_rate; - addonInterface->toKodi->kodi_audioengine->aestream_get_data_format = aestream_get_data_format; - addonInterface->toKodi->kodi_audioengine->aestream_get_resample_ratio = - aestream_get_resample_ratio; - addonInterface->toKodi->kodi_audioengine->aestream_set_resample_ratio = - aestream_set_resample_ratio; -} - -void Interface_AudioEngine::DeInit(AddonGlobalInterface* addonInterface) -{ - if (addonInterface->toKodi) /* <-- Safe check, needed so long old addon way is present */ - { - delete addonInterface->toKodi->kodi_audioengine; - addonInterface->toKodi->kodi_audioengine = nullptr; - } -} - -AEChannel Interface_AudioEngine::TranslateAEChannelToKodi(AudioEngineChannel channel) -{ - switch (channel) - { - case AUDIOENGINE_CH_RAW: - return AE_CH_RAW; - case AUDIOENGINE_CH_FL: - return AE_CH_FL; - case AUDIOENGINE_CH_FR: - return AE_CH_FR; - case AUDIOENGINE_CH_FC: - return AE_CH_FC; - case AUDIOENGINE_CH_LFE: - return AE_CH_LFE; - case AUDIOENGINE_CH_BL: - return AE_CH_BL; - case AUDIOENGINE_CH_BR: - return AE_CH_BR; - case AUDIOENGINE_CH_FLOC: - return AE_CH_FLOC; - case AUDIOENGINE_CH_FROC: - return AE_CH_FROC; - case AUDIOENGINE_CH_BC: - return AE_CH_BC; - case AUDIOENGINE_CH_SL: - return AE_CH_SL; - case AUDIOENGINE_CH_SR: - return AE_CH_SR; - case AUDIOENGINE_CH_TFL: - return AE_CH_TFL; - case AUDIOENGINE_CH_TFR: - return AE_CH_TFR; - case AUDIOENGINE_CH_TFC: - return AE_CH_TFC; - case AUDIOENGINE_CH_TC: - return AE_CH_TC; - case AUDIOENGINE_CH_TBL: - return AE_CH_TBL; - case AUDIOENGINE_CH_TBR: - return AE_CH_TBR; - case AUDIOENGINE_CH_TBC: - return AE_CH_TBC; - case AUDIOENGINE_CH_BLOC: - return AE_CH_BLOC; - case AUDIOENGINE_CH_BROC: - return AE_CH_BROC; - case AUDIOENGINE_CH_MAX: - return AE_CH_MAX; - case AUDIOENGINE_CH_NULL: - default: - return AE_CH_NULL; - } -} - -AudioEngineChannel Interface_AudioEngine::TranslateAEChannelToAddon(AEChannel channel) -{ - switch (channel) - { - case AE_CH_RAW: - return AUDIOENGINE_CH_RAW; - case AE_CH_FL: - return AUDIOENGINE_CH_FL; - case AE_CH_FR: - return AUDIOENGINE_CH_FR; - case AE_CH_FC: - return AUDIOENGINE_CH_FC; - case AE_CH_LFE: - return AUDIOENGINE_CH_LFE; - case AE_CH_BL: - return AUDIOENGINE_CH_BL; - case AE_CH_BR: - return AUDIOENGINE_CH_BR; - case AE_CH_FLOC: - return AUDIOENGINE_CH_FLOC; - case AE_CH_FROC: - return AUDIOENGINE_CH_FROC; - case AE_CH_BC: - return AUDIOENGINE_CH_BC; - case AE_CH_SL: - return AUDIOENGINE_CH_SL; - case AE_CH_SR: - return AUDIOENGINE_CH_SR; - case AE_CH_TFL: - return AUDIOENGINE_CH_TFL; - case AE_CH_TFR: - return AUDIOENGINE_CH_TFR; - case AE_CH_TFC: - return AUDIOENGINE_CH_TFC; - case AE_CH_TC: - return AUDIOENGINE_CH_TC; - case AE_CH_TBL: - return AUDIOENGINE_CH_TBL; - case AE_CH_TBR: - return AUDIOENGINE_CH_TBR; - case AE_CH_TBC: - return AUDIOENGINE_CH_TBC; - case AE_CH_BLOC: - return AUDIOENGINE_CH_BLOC; - case AE_CH_BROC: - return AUDIOENGINE_CH_BROC; - case AE_CH_MAX: - return AUDIOENGINE_CH_MAX; - case AE_CH_NULL: - default: - return AUDIOENGINE_CH_NULL; - } -} - -AEDataFormat Interface_AudioEngine::TranslateAEFormatToKodi(AudioEngineDataFormat format) -{ - switch (format) - { - case AUDIOENGINE_FMT_U8: - return AE_FMT_U8; - case AUDIOENGINE_FMT_S16BE: - return AE_FMT_S16BE; - case AUDIOENGINE_FMT_S16LE: - return AE_FMT_S16LE; - case AUDIOENGINE_FMT_S16NE: - return AE_FMT_S16NE; - case AUDIOENGINE_FMT_S32BE: - return AE_FMT_S32BE; - case AUDIOENGINE_FMT_S32LE: - return AE_FMT_S32LE; - case AUDIOENGINE_FMT_S32NE: - return AE_FMT_S32NE; - case AUDIOENGINE_FMT_S24BE4: - return AE_FMT_S24BE4; - case AUDIOENGINE_FMT_S24LE4: - return AE_FMT_S24LE4; - case AUDIOENGINE_FMT_S24NE4: - return AE_FMT_S24NE4; - case AUDIOENGINE_FMT_S24NE4MSB: - return AE_FMT_S24NE4MSB; - case AUDIOENGINE_FMT_S24BE3: - return AE_FMT_S24BE3; - case AUDIOENGINE_FMT_S24LE3: - return AE_FMT_S24LE3; - case AUDIOENGINE_FMT_S24NE3: - return AE_FMT_S24NE3; - case AUDIOENGINE_FMT_DOUBLE: - return AE_FMT_DOUBLE; - case AUDIOENGINE_FMT_FLOAT: - return AE_FMT_FLOAT; - case AUDIOENGINE_FMT_RAW: - return AE_FMT_RAW; - case AUDIOENGINE_FMT_U8P: - return AE_FMT_U8P; - case AUDIOENGINE_FMT_S16NEP: - return AE_FMT_S16NEP; - case AUDIOENGINE_FMT_S32NEP: - return AE_FMT_S32NEP; - case AUDIOENGINE_FMT_S24NE4P: - return AE_FMT_S24NE4P; - case AUDIOENGINE_FMT_S24NE4MSBP: - return AE_FMT_S24NE4MSBP; - case AUDIOENGINE_FMT_S24NE3P: - return AE_FMT_S24NE3P; - case AUDIOENGINE_FMT_DOUBLEP: - return AE_FMT_DOUBLEP; - case AUDIOENGINE_FMT_FLOATP: - return AE_FMT_FLOATP; - case AUDIOENGINE_FMT_MAX: - return AE_FMT_MAX; - case AUDIOENGINE_FMT_INVALID: - default: - return AE_FMT_INVALID; - } -} - -AudioEngineDataFormat Interface_AudioEngine::TranslateAEFormatToAddon(AEDataFormat format) -{ - switch (format) - { - case AE_FMT_U8: - return AUDIOENGINE_FMT_U8; - case AE_FMT_S16BE: - return AUDIOENGINE_FMT_S16BE; - case AE_FMT_S16LE: - return AUDIOENGINE_FMT_S16LE; - case AE_FMT_S16NE: - return AUDIOENGINE_FMT_S16NE; - case AE_FMT_S32BE: - return AUDIOENGINE_FMT_S32BE; - case AE_FMT_S32LE: - return AUDIOENGINE_FMT_S32LE; - case AE_FMT_S32NE: - return AUDIOENGINE_FMT_S32NE; - case AE_FMT_S24BE4: - return AUDIOENGINE_FMT_S24BE4; - case AE_FMT_S24LE4: - return AUDIOENGINE_FMT_S24LE4; - case AE_FMT_S24NE4: - return AUDIOENGINE_FMT_S24NE4; - case AE_FMT_S24NE4MSB: - return AUDIOENGINE_FMT_S24NE4MSB; - case AE_FMT_S24BE3: - return AUDIOENGINE_FMT_S24BE3; - case AE_FMT_S24LE3: - return AUDIOENGINE_FMT_S24LE3; - case AE_FMT_S24NE3: - return AUDIOENGINE_FMT_S24NE3; - case AE_FMT_DOUBLE: - return AUDIOENGINE_FMT_DOUBLE; - case AE_FMT_FLOAT: - return AUDIOENGINE_FMT_FLOAT; - case AE_FMT_RAW: - return AUDIOENGINE_FMT_RAW; - case AE_FMT_U8P: - return AUDIOENGINE_FMT_U8P; - case AE_FMT_S16NEP: - return AUDIOENGINE_FMT_S16NEP; - case AE_FMT_S32NEP: - return AUDIOENGINE_FMT_S32NEP; - case AE_FMT_S24NE4P: - return AUDIOENGINE_FMT_S24NE4P; - case AE_FMT_S24NE4MSBP: - return AUDIOENGINE_FMT_S24NE4MSBP; - case AE_FMT_S24NE3P: - return AUDIOENGINE_FMT_S24NE3P; - case AE_FMT_DOUBLEP: - return AUDIOENGINE_FMT_DOUBLEP; - case AE_FMT_FLOATP: - return AUDIOENGINE_FMT_FLOATP; - case AE_FMT_MAX: - return AUDIOENGINE_FMT_MAX; - case AE_FMT_INVALID: - default: - return AUDIOENGINE_FMT_INVALID; - } -} - -AEStreamHandle* Interface_AudioEngine::audioengine_make_stream(void* kodiBase, - AUDIO_ENGINE_FORMAT* streamFormat, - unsigned int options) -{ - if (!kodiBase || !streamFormat) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamFormat='{}')", - __FUNCTION__, kodiBase, static_cast(streamFormat)); - return nullptr; - } - - IAE* engine = CServiceBroker::GetActiveAE(); - if (!engine) - return nullptr; - - CAEChannelInfo layout; - for (unsigned int ch = 0; ch < AUDIOENGINE_CH_MAX; ++ch) - { - if (streamFormat->m_channels[ch] == AUDIOENGINE_CH_NULL) - break; - layout += TranslateAEChannelToKodi(streamFormat->m_channels[ch]); - } - - AEAudioFormat format; - format.m_channelLayout = layout; - format.m_dataFormat = TranslateAEFormatToKodi(streamFormat->m_dataFormat); - format.m_sampleRate = streamFormat->m_sampleRate; - - /* Translate addon options to kodi's options */ - int kodiOption = 0; - if (options & AUDIO_STREAM_FORCE_RESAMPLE) - kodiOption |= AESTREAM_FORCE_RESAMPLE; - if (options & AUDIO_STREAM_PAUSED) - kodiOption |= AESTREAM_PAUSED; - if (options & AUDIO_STREAM_AUTOSTART) - kodiOption |= AESTREAM_AUTOSTART; - - return engine->MakeStream(format, kodiOption).release(); -} - -void Interface_AudioEngine::audioengine_free_stream(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return; - } - - IAE* engine = CServiceBroker::GetActiveAE(); - if (engine) - engine->FreeStream(static_cast(streamHandle), true); -} - -bool Interface_AudioEngine::get_current_sink_format(void* kodiBase, AUDIO_ENGINE_FORMAT* format) -{ - if (!kodiBase || !format) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', format='{}')", - __FUNCTION__, kodiBase, static_cast(format)); - return false; - } - - IAE* engine = CServiceBroker::GetActiveAE(); - if (!engine) - return false; - - AEAudioFormat sinkFormat; - if (!engine->GetCurrentSinkFormat(sinkFormat)) - { - CLog::Log(LOGERROR, "Interface_AudioEngine::{} - failed to get current sink format from AE!", - __FUNCTION__); - return false; - } - - format->m_dataFormat = TranslateAEFormatToAddon(sinkFormat.m_dataFormat); - format->m_sampleRate = sinkFormat.m_sampleRate; - format->m_frames = sinkFormat.m_frames; - format->m_frameSize = sinkFormat.m_frameSize; - format->m_channelCount = sinkFormat.m_channelLayout.Count(); - for (unsigned int ch = 0; ch < format->m_channelCount && ch < AUDIOENGINE_CH_MAX; ++ch) - { - format->m_channels[ch] = TranslateAEChannelToAddon(sinkFormat.m_channelLayout[ch]); - } - - return true; -} - -unsigned int Interface_AudioEngine::aestream_get_space(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return 0; - } - - return static_cast(streamHandle)->GetSpace(); -} - -unsigned int Interface_AudioEngine::aestream_add_data(void* kodiBase, - AEStreamHandle* streamHandle, - uint8_t* const* data, - unsigned int offset, - unsigned int frames, - double pts, - bool hasDownmix, - double centerMixLevel) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return 0; - } - - if (!CServiceBroker::GetActiveAE()) - return 0; - - IAEStream::ExtData extData; - extData.pts = pts; - extData.hasDownmix = hasDownmix; - extData.centerMixLevel = centerMixLevel; - return static_cast(streamHandle)->AddData(data, offset, frames, &extData); -} - -double Interface_AudioEngine::aestream_get_delay(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return -1.0; - } - - if (!CServiceBroker::GetActiveAE()) - return -1.0; - - return static_cast(streamHandle)->GetDelay(); -} - -bool Interface_AudioEngine::aestream_is_buffering(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return false; - } - - if (!CServiceBroker::GetActiveAE()) - return false; - - return static_cast(streamHandle)->IsBuffering(); -} - -double Interface_AudioEngine::aestream_get_cache_time(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return -1.0; - } - - if (!CServiceBroker::GetActiveAE()) - return -1.0; - - return static_cast(streamHandle)->GetCacheTime(); -} - -double Interface_AudioEngine::aestream_get_cache_total(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return -1.0; - } - - if (!CServiceBroker::GetActiveAE()) - return -1.0; - - return static_cast(streamHandle)->GetCacheTotal(); -} - -void Interface_AudioEngine::aestream_pause(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return; - } - - if (!CServiceBroker::GetActiveAE()) - return; - - static_cast(streamHandle)->Pause(); -} - -void Interface_AudioEngine::aestream_resume(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return; - } - - static_cast(streamHandle)->Resume(); -} - -void Interface_AudioEngine::aestream_drain(void* kodiBase, AEStreamHandle* streamHandle, bool wait) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return; - } - - if (!CServiceBroker::GetActiveAE()) - return; - - static_cast(streamHandle)->Drain(wait); -} - -bool Interface_AudioEngine::aestream_is_draining(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return false; - } - - if (!CServiceBroker::GetActiveAE()) - return false; - - return static_cast(streamHandle)->IsDraining(); -} - -bool Interface_AudioEngine::aestream_is_drained(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return false; - } - - if (!CServiceBroker::GetActiveAE()) - return false; - - return static_cast(streamHandle)->IsDrained(); -} - -void Interface_AudioEngine::aestream_flush(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return; - } - - if (!CServiceBroker::GetActiveAE()) - return; - - static_cast(streamHandle)->Flush(); -} - -float Interface_AudioEngine::aestream_get_volume(void* kodiBase, AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return -1.0f; - } - - if (!CServiceBroker::GetActiveAE()) - return -1.0f; - - return static_cast(streamHandle)->GetVolume(); -} - -void Interface_AudioEngine::aestream_set_volume(void* kodiBase, - AEStreamHandle* streamHandle, - float volume) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return; - } - - if (!CServiceBroker::GetActiveAE()) - return; - - static_cast(streamHandle)->SetVolume(volume); -} - -float Interface_AudioEngine::aestream_get_amplification(void* kodiBase, - AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return -1.0f; - } - - if (!CServiceBroker::GetActiveAE()) - return -1.0f; - - return static_cast(streamHandle)->GetAmplification(); -} - -void Interface_AudioEngine::aestream_set_amplification(void* kodiBase, - AEStreamHandle* streamHandle, - float amplify) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return; - } - - if (!CServiceBroker::GetActiveAE()) - return; - - static_cast(streamHandle)->SetAmplification(amplify); -} - -unsigned int Interface_AudioEngine::aestream_get_frame_size(void* kodiBase, - AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return 0; - } - - if (!CServiceBroker::GetActiveAE()) - return 0; - - return static_cast(streamHandle)->GetFrameSize(); -} - -unsigned int Interface_AudioEngine::aestream_get_channel_count(void* kodiBase, - AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return 0; - } - - if (!CServiceBroker::GetActiveAE()) - return 0; - - return static_cast(streamHandle)->GetChannelCount(); -} - -unsigned int Interface_AudioEngine::aestream_get_sample_rate(void* kodiBase, - AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return 0; - } - - if (!CServiceBroker::GetActiveAE()) - return 0; - - return static_cast(streamHandle)->GetSampleRate(); -} - -AudioEngineDataFormat Interface_AudioEngine::aestream_get_data_format(void* kodiBase, - AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return AUDIOENGINE_FMT_INVALID; - } - - if (!CServiceBroker::GetActiveAE()) - return AUDIOENGINE_FMT_INVALID; - - return TranslateAEFormatToAddon(static_cast(streamHandle)->GetDataFormat()); -} - -double Interface_AudioEngine::aestream_get_resample_ratio(void* kodiBase, - AEStreamHandle* streamHandle) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return -1.0; - } - - if (!CServiceBroker::GetActiveAE()) - return -1.0; - - return static_cast(streamHandle)->GetResampleRatio(); -} - -void Interface_AudioEngine::aestream_set_resample_ratio(void* kodiBase, - AEStreamHandle* streamHandle, - double ratio) -{ - if (!kodiBase || !streamHandle) - { - CLog::Log(LOGERROR, - "Interface_AudioEngine::{} - invalid stream data (kodiBase='{}', streamHandle='{}')", - __FUNCTION__, kodiBase, static_cast(streamHandle)); - return; - } - - if (!CServiceBroker::GetActiveAE()) - return; - - static_cast(streamHandle)->SetResampleRatio(ratio); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/AudioEngine.h b/xbmc/addons/interfaces/AudioEngine.h deleted file mode 100644 index 3700931049f51..0000000000000 --- a/xbmc/addons/interfaces/AudioEngine.h +++ /dev/null @@ -1,212 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/AudioEngine.h" -#include "cores/AudioEngine/Utils/AEChannelData.h" - -extern "C" -{ -namespace ADDON -{ - -struct Interface_AudioEngine -{ - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /** - * @brief Translation functions to separate Kodi and addons - * - * This thought to make it more safe for cases as something changed inside - * Kodi, addons overseen and breaks API, further to have on addons a better - * documentation about this parts. - */ - //@{ - static AEChannel TranslateAEChannelToKodi(AudioEngineChannel channel); - static AudioEngineChannel TranslateAEChannelToAddon(AEChannel channel); - static AEDataFormat TranslateAEFormatToKodi(AudioEngineDataFormat format); - static AudioEngineDataFormat TranslateAEFormatToAddon(AEDataFormat format); - //@} - - /** - * Creates and returns a new handle to an IAEStream in the format specified, this function should never fail - * @param[in] streamFormat Format to use for stream - * @param[in] options A bit field of stream options (see: enum AEStreamOptions) - * @return a new Handle to an IAEStream that will accept data in the requested format - */ - static AEStreamHandle* audioengine_make_stream(void* kodiBase, - AUDIO_ENGINE_FORMAT* streamFormat, - unsigned int options); - - /** - * This method will remove the specified stream from the engine. - * For OSX/IOS this is essential to reconfigure the audio output. - * @param[in] streamHandle The stream to be altered - */ - static void audioengine_free_stream(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Get the current sink data format - * - * @param[in] sinkFormat sink data format. For more details see AUDIO_ENGINE_FORMAT. - * @return Returns true on success, else false. - */ - static bool get_current_sink_format(void* kodiBase, AUDIO_ENGINE_FORMAT* sinkFormat); - - /** - * Returns the amount of space available in the stream - * @return The number of bytes AddData will consume - */ - static unsigned int aestream_get_space(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Add planar or interleaved PCM data to the stream - * @param[in] data array of pointers to the planes - * @param[in] offset to frame in frames - * @param[in] frames number of frames - * @return The number of frames consumed - */ - static unsigned int aestream_add_data(void* kodiBase, - AEStreamHandle* streamHandle, - uint8_t* const* data, - unsigned int offset, - unsigned int frames, - double pts, - bool hasDownmix, - double centerMixLevel); - - /** - * Returns the time in seconds that it will take - * for the next added packet to be heard from the speakers. - * @return seconds - */ - static double aestream_get_delay(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Returns if the stream is buffering - * @return True if the stream is buffering - */ - static bool aestream_is_buffering(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Returns the time in seconds that it will take - * to underrun the cache if no sample is added. - * @return seconds - */ - static double aestream_get_cache_time(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Returns the total time in seconds of the cache - * @return seconds - */ - static double aestream_get_cache_total(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Pauses the stream playback - */ - static void aestream_pause(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Resumes the stream after pausing - */ - static void aestream_resume(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Start draining the stream - * @note Once called AddData will not consume more data. - */ - static void aestream_drain(void* kodiBase, AEStreamHandle* streamHandle, bool wait); - - /** - * Returns true if the is stream draining - */ - static bool aestream_is_draining(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Returns true if the is stream has finished draining - */ - static bool aestream_is_drained(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Flush all buffers dropping the audio data - */ - static void aestream_flush(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Return the stream's current volume level - * @return The volume level between 0.0 and 1.0 - */ - static float aestream_get_volume(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Set the stream's volume level - * @param volume The new volume level between 0.0 and 1.0 - */ - static void aestream_set_volume(void* kodiBase, AEStreamHandle* streamHandle, float volume); - - /** - * Gets the stream's volume amplification in linear units. - * @return The volume amplification factor between 1.0 and 1000.0 - */ - static float aestream_get_amplification(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Sets the stream's volume amplification in linear units. - * @param amplify The volume amplification factor between 1.0 and 1000.0 - */ - static void aestream_set_amplification(void* kodiBase, - AEStreamHandle* streamHandle, - float amplify); - - /** - * Returns the size of one audio frame in bytes (channelCount * resolution) - * @return The size in bytes of one frame - */ - static unsigned int aestream_get_frame_size(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Returns the number of channels the stream is configured to accept - * @return The channel count - */ - static unsigned int aestream_get_channel_count(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Returns the stream's sample rate, if the stream is using a dynamic sample - * rate, this value will NOT reflect any changes made by calls to SetResampleRatio() - * @return The stream's sample rate (eg, 48000) - */ - static unsigned int aestream_get_sample_rate(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Return the data format the stream has been configured with - * @return The stream's data format (eg, AE_FMT_S16LE) - */ - static AudioEngineDataFormat aestream_get_data_format(void* kodiBase, - AEStreamHandle* streamHandle); - - /** - * Return the resample ratio - * @note This will return an undefined value if the stream is not resampling - * @return the current resample ratio or undefined if the stream is not resampling - */ - static double aestream_get_resample_ratio(void* kodiBase, AEStreamHandle* streamHandle); - - /** - * Sets the resample ratio - * @note This function may return false if the stream is not resampling, if you wish to use this be sure to set the AESTREAM_FORCE_RESAMPLE option - * @param[in] ratio the new sample rate ratio, calculated by ((double)desiredRate / (double)GetSampleRate()) - */ - static void aestream_set_resample_ratio(void* kodiBase, - AEStreamHandle* streamHandle, - double ratio); -}; - -} /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/CMakeLists.txt b/xbmc/addons/interfaces/CMakeLists.txt deleted file mode 100644 index 8e58bb6cf9698..0000000000000 --- a/xbmc/addons/interfaces/CMakeLists.txt +++ /dev/null @@ -1,18 +0,0 @@ -set(SOURCES AddonBase.cpp - AudioEngine.cpp - General.cpp - Filesystem.cpp - Network.cpp) - -set(HEADERS AddonBase.h - AudioEngine.h - General.h - Filesystem.h - Network.h) - -if(CORE_SYSTEM_NAME STREQUAL android) - list(APPEND SOURCES platform/android/System.cpp) - list(APPEND HEADERS platform/android/System.h) -endif() - -core_add_library(addons_interfaces) diff --git a/xbmc/addons/interfaces/Filesystem.cpp b/xbmc/addons/interfaces/Filesystem.cpp deleted file mode 100644 index 80dee33016cdf..0000000000000 --- a/xbmc/addons/interfaces/Filesystem.cpp +++ /dev/null @@ -1,1179 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Filesystem.h" - -#include "Util.h" -#include "addons/binary-addons/AddonDll.h" -#include "filesystem/CurlFile.h" -#include "filesystem/Directory.h" -#include "filesystem/File.h" -#include "filesystem/SpecialProtocol.h" -#include "platform/Filesystem.h" -#include "utils/Crc32.h" -#include "utils/HttpHeader.h" -#include "utils/StringUtils.h" -#include "utils/URIUtils.h" -#include "utils/log.h" - -#include - -#if defined(TARGET_WINDOWS) -#ifndef S_IFLNK -#define S_IFLNK 0120000 -#endif -#ifndef S_ISBLK -#define S_ISBLK(m) (0) -#endif -#ifndef S_ISSOCK -#define S_ISSOCK(m) (0) -#endif -#ifndef S_ISLNK -#define S_ISLNK(m) ((m & S_IFLNK) != 0) -#endif -#ifndef S_ISCHR -#define S_ISCHR(m) ((m & _S_IFCHR) != 0) -#endif -#ifndef S_ISDIR -#define S_ISDIR(m) ((m & _S_IFDIR) != 0) -#endif -#ifndef S_ISFIFO -#define S_ISFIFO(m) ((m & _S_IFIFO) != 0) -#endif -#ifndef S_ISREG -#define S_ISREG(m) ((m & _S_IFREG) != 0) -#endif -#endif - -using namespace kodi; // addon-dev-kit namespace -using namespace XFILE; - -extern "C" -{ -namespace ADDON -{ - -void Interface_Filesystem::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_filesystem = new AddonToKodiFuncTable_kodi_filesystem(); - - addonInterface->toKodi->kodi_filesystem->can_open_directory = can_open_directory; - addonInterface->toKodi->kodi_filesystem->create_directory = create_directory; - addonInterface->toKodi->kodi_filesystem->directory_exists = directory_exists; - addonInterface->toKodi->kodi_filesystem->remove_directory = remove_directory; - addonInterface->toKodi->kodi_filesystem->remove_directory_recursive = remove_directory_recursive; - addonInterface->toKodi->kodi_filesystem->get_directory = get_directory; - addonInterface->toKodi->kodi_filesystem->free_directory = free_directory; - - addonInterface->toKodi->kodi_filesystem->file_exists = file_exists; - addonInterface->toKodi->kodi_filesystem->stat_file = stat_file; - addonInterface->toKodi->kodi_filesystem->delete_file = delete_file; - addonInterface->toKodi->kodi_filesystem->rename_file = rename_file; - addonInterface->toKodi->kodi_filesystem->copy_file = copy_file; - addonInterface->toKodi->kodi_filesystem->get_file_md5 = get_file_md5; - addonInterface->toKodi->kodi_filesystem->get_cache_thumb_name = get_cache_thumb_name; - addonInterface->toKodi->kodi_filesystem->make_legal_filename = make_legal_filename; - addonInterface->toKodi->kodi_filesystem->make_legal_path = make_legal_path; - addonInterface->toKodi->kodi_filesystem->translate_special_protocol = translate_special_protocol; - addonInterface->toKodi->kodi_filesystem->get_disk_space = get_disk_space; - addonInterface->toKodi->kodi_filesystem->is_internet_stream = is_internet_stream; - addonInterface->toKodi->kodi_filesystem->is_on_lan = is_on_lan; - addonInterface->toKodi->kodi_filesystem->is_remote = is_remote; - addonInterface->toKodi->kodi_filesystem->is_local = is_local; - addonInterface->toKodi->kodi_filesystem->is_url = is_url; - addonInterface->toKodi->kodi_filesystem->get_http_header = get_http_header; - addonInterface->toKodi->kodi_filesystem->get_mime_type = get_mime_type; - addonInterface->toKodi->kodi_filesystem->get_content_type = get_content_type; - addonInterface->toKodi->kodi_filesystem->get_cookies = get_cookies; - - addonInterface->toKodi->kodi_filesystem->http_header_create = http_header_create; - addonInterface->toKodi->kodi_filesystem->http_header_free = http_header_free; - - addonInterface->toKodi->kodi_filesystem->open_file = open_file; - addonInterface->toKodi->kodi_filesystem->open_file_for_write = open_file_for_write; - addonInterface->toKodi->kodi_filesystem->read_file = read_file; - addonInterface->toKodi->kodi_filesystem->read_file_string = read_file_string; - addonInterface->toKodi->kodi_filesystem->write_file = write_file; - addonInterface->toKodi->kodi_filesystem->flush_file = flush_file; - addonInterface->toKodi->kodi_filesystem->seek_file = seek_file; - addonInterface->toKodi->kodi_filesystem->truncate_file = truncate_file; - addonInterface->toKodi->kodi_filesystem->get_file_position = get_file_position; - addonInterface->toKodi->kodi_filesystem->get_file_length = get_file_length; - addonInterface->toKodi->kodi_filesystem->get_file_download_speed = get_file_download_speed; - addonInterface->toKodi->kodi_filesystem->close_file = close_file; - addonInterface->toKodi->kodi_filesystem->get_file_chunk_size = get_file_chunk_size; - addonInterface->toKodi->kodi_filesystem->io_control_get_seek_possible = - io_control_get_seek_possible; - addonInterface->toKodi->kodi_filesystem->io_control_get_cache_status = - io_control_get_cache_status; - addonInterface->toKodi->kodi_filesystem->io_control_set_cache_rate = io_control_set_cache_rate; - addonInterface->toKodi->kodi_filesystem->io_control_set_retry = io_control_set_retry; - addonInterface->toKodi->kodi_filesystem->get_property_values = get_property_values; - - addonInterface->toKodi->kodi_filesystem->curl_create = curl_create; - addonInterface->toKodi->kodi_filesystem->curl_add_option = curl_add_option; - addonInterface->toKodi->kodi_filesystem->curl_open = curl_open; -} - -void Interface_Filesystem::DeInit(AddonGlobalInterface* addonInterface) -{ - if (addonInterface->toKodi) /* <-- Safe check, needed so long old addon way is present */ - { - delete addonInterface->toKodi->kodi_filesystem; - addonInterface->toKodi->kodi_filesystem = nullptr; - } -} - -unsigned int Interface_Filesystem::TranslateFileReadBitsToKodi(unsigned int addonFlags) -{ - unsigned int kodiFlags = 0; - - if (addonFlags & ADDON_READ_TRUNCATED) - kodiFlags |= READ_TRUNCATED; - if (addonFlags & ADDON_READ_CHUNKED) - kodiFlags |= READ_CHUNKED; - if (addonFlags & ADDON_READ_CACHED) - kodiFlags |= READ_CACHED; - if (addonFlags & ADDON_READ_NO_CACHE) - kodiFlags |= READ_NO_CACHE; - if (addonFlags & ADDON_READ_BITRATE) - kodiFlags |= READ_BITRATE; - if (addonFlags & ADDON_READ_MULTI_STREAM) - kodiFlags |= READ_MULTI_STREAM; - if (addonFlags & ADDON_READ_AUDIO_VIDEO) - kodiFlags |= READ_AUDIO_VIDEO; - if (addonFlags & ADDON_READ_AFTER_WRITE) - kodiFlags |= READ_AFTER_WRITE; - if (addonFlags & READ_REOPEN) - kodiFlags |= READ_REOPEN; - - return kodiFlags; -} - -bool Interface_Filesystem::can_open_directory(void* kodiBase, const char* url) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || url == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', url='{}')", - __FUNCTION__, kodiBase, static_cast(url)); - return false; - } - - CFileItemList items; - return CDirectory::GetDirectory(url, items, "", DIR_FLAG_DEFAULTS); -} - -bool Interface_Filesystem::create_directory(void* kodiBase, const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', path='{}')", - __FUNCTION__, kodiBase, static_cast(path)); - return false; - } - - return CDirectory::Create(path); -} - -bool Interface_Filesystem::directory_exists(void* kodiBase, const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', path='{}')", - __FUNCTION__, kodiBase, static_cast(path)); - return false; - } - - return CDirectory::Exists(path); -} - -bool Interface_Filesystem::remove_directory(void* kodiBase, const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', path='{}')", - __FUNCTION__, kodiBase, static_cast(path)); - return false; - } - - // Empty directory - CFileItemList fileItems; - CDirectory::GetDirectory(path, fileItems, "", DIR_FLAG_DEFAULTS); - for (int i = 0; i < fileItems.Size(); ++i) - CFile::Delete(fileItems.Get(i)->GetPath()); - - return CDirectory::Remove(path); -} - -bool Interface_Filesystem::remove_directory_recursive(void* kodiBase, const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', path='{}')", - __FUNCTION__, kodiBase, static_cast(path)); - return false; - } - - return CDirectory::RemoveRecursive(path); -} - -static void CFileItemListToVFSDirEntries(VFSDirEntry* entries, const CFileItemList& items) -{ - for (unsigned int i = 0; i < static_cast(items.Size()); ++i) - { - entries[i].label = strdup(items[i]->GetLabel().c_str()); - entries[i].path = strdup(items[i]->GetPath().c_str()); - entries[i].size = items[i]->m_dwSize; - entries[i].folder = items[i]->m_bIsFolder; - items[i]->m_dateTime.GetAsTime(entries[i].date_time); - } -} - -bool Interface_Filesystem::get_directory(void* kodiBase, - const char* path, - const char* mask, - struct VFSDirEntry** items, - unsigned int* num_items) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr || mask == nullptr || items == nullptr || - num_items == nullptr) - { - CLog::Log(LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', path='{}', mask='{}', " - "items='{}', num_items='{}'", - __FUNCTION__, kodiBase, static_cast(path), - static_cast(mask), static_cast(items), - static_cast(num_items)); - return false; - } - - CFileItemList fileItems; - if (!CDirectory::GetDirectory(path, fileItems, mask, DIR_FLAG_NO_FILE_DIRS)) - return false; - - if (fileItems.Size() > 0) - { - *num_items = static_cast(fileItems.Size()); - *items = new VFSDirEntry[fileItems.Size()]; - CFileItemListToVFSDirEntries(*items, fileItems); - } - else - { - *num_items = 0; - *items = nullptr; - } - - return true; -} - -void Interface_Filesystem::free_directory(void* kodiBase, - struct VFSDirEntry* items, - unsigned int num_items) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || items == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', items='{}')", - __FUNCTION__, kodiBase, static_cast(items)); - return; - } - - for (unsigned int i = 0; i < num_items; ++i) - { - free(items[i].label); - free(items[i].path); - } - delete[] items; -} - -//------------------------------------------------------------------------------ - -bool Interface_Filesystem::file_exists(void* kodiBase, const char* filename, bool useCache) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || filename == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', filename='{}')", - __FUNCTION__, kodiBase, static_cast(filename)); - return false; - } - - return CFile::Exists(filename, useCache); -} - -bool Interface_Filesystem::stat_file(void* kodiBase, - const char* filename, - struct STAT_STRUCTURE* buffer) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || filename == nullptr || buffer == nullptr) - { - CLog::Log(LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', filename='{}', buffer='{}')", - __FUNCTION__, kodiBase, static_cast(filename), - static_cast(buffer)); - return false; - } - - struct __stat64 statBuffer; - if (CFile::Stat(filename, &statBuffer) != 0) - return false; - - buffer->deviceId = statBuffer.st_dev; - buffer->fileSerialNumber = statBuffer.st_ino; - buffer->size = statBuffer.st_size; - buffer->accessTime = statBuffer.st_atime; - buffer->modificationTime = statBuffer.st_mtime; - buffer->statusTime = statBuffer.st_ctime; - buffer->isDirectory = S_ISDIR(statBuffer.st_mode); - buffer->isSymLink = S_ISLNK(statBuffer.st_mode); - buffer->isBlock = S_ISBLK(statBuffer.st_mode); - buffer->isCharacter = S_ISCHR(statBuffer.st_mode); - buffer->isFifo = S_ISFIFO(statBuffer.st_mode); - buffer->isRegular = S_ISREG(statBuffer.st_mode); - buffer->isSocket = S_ISSOCK(statBuffer.st_mode); - - return true; -} - -bool Interface_Filesystem::delete_file(void* kodiBase, const char* filename) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || filename == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', filename='{}')", - __FUNCTION__, kodiBase, static_cast(filename)); - return false; - } - - return CFile::Delete(filename); -} - -bool Interface_Filesystem::rename_file(void* kodiBase, - const char* filename, - const char* newFileName) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || filename == nullptr || newFileName == nullptr) - { - CLog::Log( - LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', filename='{}', newFileName='{}')", - __FUNCTION__, kodiBase, static_cast(filename), - static_cast(newFileName)); - return false; - } - - return CFile::Rename(filename, newFileName); -} - -bool Interface_Filesystem::copy_file(void* kodiBase, const char* filename, const char* dest) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || filename == nullptr || dest == nullptr) - { - CLog::Log( - LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', filename='{}', dest='{}')", - __FUNCTION__, kodiBase, static_cast(filename), static_cast(dest)); - return false; - } - - return CFile::Copy(filename, dest); -} - -char* Interface_Filesystem::get_file_md5(void* kodiBase, const char* filename) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || filename == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', filename='{})", - __FUNCTION__, kodiBase, static_cast(filename)); - return nullptr; - } - - std::string string = CUtil::GetFileDigest(filename, KODI::UTILITY::CDigest::Type::MD5); - char* buffer = strdup(string.c_str()); - return buffer; -} - -char* Interface_Filesystem::get_cache_thumb_name(void* kodiBase, const char* filename) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || filename == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', filename='{})", - __FUNCTION__, kodiBase, static_cast(filename)); - return nullptr; - } - - const auto crc = Crc32::ComputeFromLowerCase(filename); - const auto hex = StringUtils::Format("{:08x}.tbn", crc); - char* buffer = strdup(hex.c_str()); - return buffer; -} - -char* Interface_Filesystem::make_legal_filename(void* kodiBase, const char* filename) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || filename == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', filename='{})", - __FUNCTION__, kodiBase, static_cast(filename)); - return nullptr; - } - - std::string string = CUtil::MakeLegalFileName(filename); - char* buffer = strdup(string.c_str()); - return buffer; -} - -char* Interface_Filesystem::make_legal_path(void* kodiBase, const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', path='{})", - __FUNCTION__, kodiBase, static_cast(path)); - return nullptr; - } - - std::string string = CUtil::MakeLegalPath(path); - char* buffer = strdup(string.c_str()); - return buffer; -} - -char* Interface_Filesystem::translate_special_protocol(void* kodiBase, const char* strSource) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || strSource == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', strSource='{})", - __FUNCTION__, kodiBase, static_cast(strSource)); - return nullptr; - } - - return strdup(CSpecialProtocol::TranslatePath(strSource).c_str()); -} - -bool Interface_Filesystem::get_disk_space( - void* kodiBase, const char* path, uint64_t* capacity, uint64_t* free, uint64_t* available) -{ - using namespace KODI::PLATFORM::FILESYSTEM; - - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr || capacity == nullptr || free == nullptr || - available == nullptr) - { - CLog::Log( - LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', path='{}, capacity='{}, free='{}, " - "available='{})", - __FUNCTION__, kodiBase, static_cast(path), static_cast(capacity), - static_cast(free), static_cast(available)); - return false; - } - - std::error_code ec; - auto freeSpace = space(CSpecialProtocol::TranslatePath(path), ec); - if (ec.value() != 0) - return false; - - *capacity = freeSpace.capacity; - *free = freeSpace.free; - *available = freeSpace.available; - return true; -} - -bool Interface_Filesystem::is_internet_stream(void* kodiBase, const char* path, bool strictCheck) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', path='{})", - __FUNCTION__, kodiBase, static_cast(path)); - return false; - } - - return URIUtils::IsInternetStream(path, strictCheck); -} - -bool Interface_Filesystem::is_on_lan(void* kodiBase, const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', path='{})", - __FUNCTION__, kodiBase, static_cast(path)); - return false; - } - - return URIUtils::IsOnLAN(path); -} - -bool Interface_Filesystem::is_remote(void* kodiBase, const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', path='{})", - __FUNCTION__, kodiBase, static_cast(path)); - return false; - } - - return URIUtils::IsRemote(path); -} - -bool Interface_Filesystem::is_local(void* kodiBase, const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', path='{})", - __FUNCTION__, kodiBase, static_cast(path)); - return false; - } - - return CURL(path).IsLocal(); -} - -bool Interface_Filesystem::is_url(void* kodiBase, const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || path == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', path='{})", - __FUNCTION__, kodiBase, static_cast(path)); - return false; - } - - return URIUtils::IsURL(path); -} - -bool Interface_Filesystem::get_mime_type(void* kodiBase, - const char* url, - char** content, - const char* useragent) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || url == nullptr || content == nullptr || useragent == nullptr) - { - CLog::Log(LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', url='{}', content='{}', " - "useragent='{}')", - __FUNCTION__, kodiBase, static_cast(url), - static_cast(content), static_cast(useragent)); - return false; - } - - std::string kodiContent; - bool ret = XFILE::CCurlFile::GetMimeType(CURL(url), kodiContent, useragent); - if (ret && !kodiContent.empty()) - { - *content = strdup(kodiContent.c_str()); - } - return ret; -} - -bool Interface_Filesystem::get_content_type(void* kodiBase, - const char* url, - char** content, - const char* useragent) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || url == nullptr || content == nullptr || useragent == nullptr) - { - CLog::Log(LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', url='{}', content='{}', " - "useragent='{}')", - __FUNCTION__, kodiBase, static_cast(url), - static_cast(content), static_cast(useragent)); - return false; - } - - std::string kodiContent; - bool ret = XFILE::CCurlFile::GetContentType(CURL(url), kodiContent, useragent); - if (ret && !kodiContent.empty()) - { - *content = strdup(kodiContent.c_str()); - } - return ret; -} - -bool Interface_Filesystem::get_cookies(void* kodiBase, const char* url, char** cookies) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || url == nullptr || cookies == nullptr) - { - CLog::Log( - LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', url='{}', cookies='{}')", - __FUNCTION__, kodiBase, static_cast(url), static_cast(cookies)); - return false; - } - - std::string kodiCookies; - bool ret = XFILE::CCurlFile::GetCookies(CURL(url), kodiCookies); - if (ret && !kodiCookies.empty()) - { - *cookies = strdup(kodiCookies.c_str()); - } - return ret; -} - -bool Interface_Filesystem::get_http_header(void* kodiBase, - const char* url, - struct KODI_HTTP_HEADER* headers) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || url == nullptr || headers == nullptr || headers->handle == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data pointer given", __func__); - return false; - } - - CHttpHeader* httpHeader = static_cast(headers->handle); - return XFILE::CCurlFile::GetHttpHeader(CURL(url), *httpHeader); -} - -//------------------------------------------------------------------------------ - -bool Interface_Filesystem::http_header_create(void* kodiBase, struct KODI_HTTP_HEADER* headers) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || headers == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', headers='{}')", - __FUNCTION__, kodiBase, static_cast(headers)); - return false; - } - - headers->handle = new CHttpHeader; - headers->get_value = http_header_get_value; - headers->get_values = http_header_get_values; - headers->get_header = http_header_get_header; - headers->get_mime_type = http_header_get_mime_type; - headers->get_charset = http_header_get_charset; - headers->get_proto_line = http_header_get_proto_line; - - return true; -} - -void Interface_Filesystem::http_header_free(void* kodiBase, struct KODI_HTTP_HEADER* headers) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || headers == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', headers='{}')", - __FUNCTION__, kodiBase, static_cast(headers)); - return; - } - - delete static_cast(headers->handle); - headers->handle = nullptr; -} - -char* Interface_Filesystem::http_header_get_value(void* kodiBase, void* handle, const char* param) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || handle == nullptr || param == nullptr) - { - CLog::Log(LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', handle='{}', param='{}')", - __FUNCTION__, kodiBase, handle, static_cast(param)); - return nullptr; - } - - std::string string = static_cast(handle)->GetValue(param); - - char* buffer = nullptr; - if (!string.empty()) - buffer = strdup(string.c_str()); - return buffer; -} - -char** Interface_Filesystem::http_header_get_values(void* kodiBase, - void* handle, - const char* param, - int* length) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || handle == nullptr || param == nullptr || length == nullptr) - { - CLog::Log(LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', handle='{}', param='{}', " - "length='{}')", - __FUNCTION__, kodiBase, handle, static_cast(param), - static_cast(length)); - return nullptr; - } - - - std::vector values = static_cast(handle)->GetValues(param); - *length = values.size(); - char** ret = static_cast(malloc(sizeof(char*) * values.size())); - for (int i = 0; i < *length; ++i) - { - ret[i] = strdup(values[i].c_str()); - } - return ret; -} - -char* Interface_Filesystem::http_header_get_header(void* kodiBase, void* handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || handle == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', handle='{}')", - __FUNCTION__, kodiBase, handle); - return nullptr; - } - - std::string string = static_cast(handle)->GetHeader(); - - char* buffer = nullptr; - if (!string.empty()) - buffer = strdup(string.c_str()); - return buffer; -} - -char* Interface_Filesystem::http_header_get_mime_type(void* kodiBase, void* handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || handle == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', handle='{}')", - __FUNCTION__, kodiBase, handle); - return nullptr; - } - - std::string string = static_cast(handle)->GetMimeType(); - - char* buffer = nullptr; - if (!string.empty()) - buffer = strdup(string.c_str()); - return buffer; -} - -char* Interface_Filesystem::http_header_get_charset(void* kodiBase, void* handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || handle == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', handle='{}')", - __FUNCTION__, kodiBase, handle); - return nullptr; - } - - std::string string = static_cast(handle)->GetCharset(); - - char* buffer = nullptr; - if (!string.empty()) - buffer = strdup(string.c_str()); - return buffer; -} - -char* Interface_Filesystem::http_header_get_proto_line(void* kodiBase, void* handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || handle == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', handle='{}')", - __FUNCTION__, kodiBase, handle); - return nullptr; - } - - std::string string = static_cast(handle)->GetProtoLine(); - - char* buffer = nullptr; - if (!string.empty()) - buffer = strdup(string.c_str()); - return buffer; -} - -//------------------------------------------------------------------------------ - -void* Interface_Filesystem::open_file(void* kodiBase, const char* filename, unsigned int flags) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || filename == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', filename='{}')", - __FUNCTION__, kodiBase, static_cast(filename)); - return nullptr; - } - - CFile* file = new CFile; - if (file->Open(filename, TranslateFileReadBitsToKodi(flags))) - return static_cast(file); - - delete file; - return nullptr; -} - -void* Interface_Filesystem::open_file_for_write(void* kodiBase, - const char* filename, - bool overwrite) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || filename == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', filename='{}')", - __FUNCTION__, kodiBase, static_cast(filename)); - return nullptr; - } - - CFile* file = new CFile; - if (file->OpenForWrite(filename, overwrite)) - return static_cast(file); - - delete file; - return nullptr; -} - -ssize_t Interface_Filesystem::read_file(void* kodiBase, void* file, void* ptr, size_t size) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr || ptr == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}', ptr='{}')", - __FUNCTION__, kodiBase, file, ptr); - return -1; - } - - return static_cast(file)->Read(ptr, size); -} - -bool Interface_Filesystem::read_file_string(void* kodiBase, - void* file, - char* szLine, - int lineLength) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr || szLine == nullptr) - { - CLog::Log(LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', file='{}', szLine=='{}')", - __FUNCTION__, kodiBase, file, static_cast(szLine)); - return false; - } - - return static_cast(file)->ReadString(szLine, lineLength); -} - -ssize_t Interface_Filesystem::write_file(void* kodiBase, void* file, const void* ptr, size_t size) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr || ptr == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}', ptr='{}')", - __FUNCTION__, kodiBase, file, ptr); - return -1; - } - - return static_cast(file)->Write(ptr, size); -} - -void Interface_Filesystem::flush_file(void* kodiBase, void* file) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}')", - __FUNCTION__, kodiBase, file); - return; - } - - static_cast(file)->Flush(); -} - -int64_t Interface_Filesystem::seek_file(void* kodiBase, void* file, int64_t position, int whence) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}')", - __FUNCTION__, kodiBase, file); - return -1; - } - - return static_cast(file)->Seek(position, whence); -} - -int Interface_Filesystem::truncate_file(void* kodiBase, void* file, int64_t size) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}')", - __FUNCTION__, kodiBase, file); - return -1; - } - - return static_cast(file)->Truncate(size); -} - -int64_t Interface_Filesystem::get_file_position(void* kodiBase, void* file) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}')", - __FUNCTION__, kodiBase, file); - return -1; - } - - return static_cast(file)->GetPosition(); -} - -int64_t Interface_Filesystem::get_file_length(void* kodiBase, void* file) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}')", - __FUNCTION__, kodiBase, file); - return -1; - } - - return static_cast(file)->GetLength(); -} - -double Interface_Filesystem::get_file_download_speed(void* kodiBase, void* file) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}')", - __FUNCTION__, kodiBase, file); - return 0.0; - } - - return static_cast(file)->GetDownloadSpeed(); -} - -void Interface_Filesystem::close_file(void* kodiBase, void* file) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}')", - __FUNCTION__, kodiBase, file); - return; - } - - static_cast(file)->Close(); - delete static_cast(file); -} - -int Interface_Filesystem::get_file_chunk_size(void* kodiBase, void* file) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_VFS::{} - invalid data (addon='{}', file='{}')", __FUNCTION__, - kodiBase, file); - return -1; - } - - return static_cast(file)->GetChunkSize(); -} - -bool Interface_Filesystem::io_control_get_seek_possible(void* kodiBase, void* file) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_VFS::{} - invalid data (addon='{}', file='{}')", __FUNCTION__, - kodiBase, file); - return false; - } - - return static_cast(file)->IoControl(EIoControl::IOCTRL_SEEK_POSSIBLE, nullptr) != 0 - ? true - : false; -} - -bool Interface_Filesystem::io_control_get_cache_status(void* kodiBase, - void* file, - struct VFS_CACHE_STATUS_DATA* status) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr || status == nullptr) - { - CLog::Log(LOGERROR, "Interface_VFS::{} - invalid data (addon='{}', file='{}, status='{}')", - __FUNCTION__, kodiBase, file, static_cast(status)); - return false; - } - - SCacheStatus data = {}; - int ret = static_cast(file)->IoControl(EIoControl::IOCTRL_CACHE_STATUS, &data); - if (ret >= 0) - { - status->forward = data.forward; - status->maxrate = data.maxrate; - status->currate = data.currate; - status->lowrate = data.lowrate; - return true; - } - return false; -} - -bool Interface_Filesystem::io_control_set_cache_rate(void* kodiBase, void* file, uint32_t rate) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_VFS::{} - invalid data (addon='{}', file='{}')", __FUNCTION__, - kodiBase, file); - return false; - } - - return static_cast(file)->IoControl(EIoControl::IOCTRL_CACHE_SETRATE, &rate) >= 0 ? true - : false; -} - -bool Interface_Filesystem::io_control_set_retry(void* kodiBase, void* file, bool retry) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_VFS::{} - invalid data (addon='{}', file='{}')", __FUNCTION__, - kodiBase, file); - return false; - } - - return static_cast(file)->IoControl(EIoControl::IOCTRL_SET_RETRY, &retry) >= 0 ? true - : false; -} - -char** Interface_Filesystem::get_property_values( - void* kodiBase, void* file, int type, const char* name, int* numValues) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr || name == nullptr || numValues == nullptr) - { - CLog::Log(LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', file='{}', name='{}', " - "numValues='{}')", - __FUNCTION__, kodiBase, file, static_cast(name), - static_cast(numValues)); - return nullptr; - } - - XFILE::FileProperty internalType; - switch (type) - { - case ADDON_FILE_PROPERTY_RESPONSE_PROTOCOL: - internalType = XFILE::FILE_PROPERTY_RESPONSE_PROTOCOL; - break; - case ADDON_FILE_PROPERTY_RESPONSE_HEADER: - internalType = XFILE::FILE_PROPERTY_RESPONSE_HEADER; - break; - case ADDON_FILE_PROPERTY_CONTENT_TYPE: - internalType = XFILE::FILE_PROPERTY_CONTENT_TYPE; - break; - case ADDON_FILE_PROPERTY_CONTENT_CHARSET: - internalType = XFILE::FILE_PROPERTY_CONTENT_CHARSET; - break; - case ADDON_FILE_PROPERTY_MIME_TYPE: - internalType = XFILE::FILE_PROPERTY_MIME_TYPE; - break; - case ADDON_FILE_PROPERTY_EFFECTIVE_URL: - internalType = XFILE::FILE_PROPERTY_EFFECTIVE_URL; - break; - default: - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}')", - __FUNCTION__, kodiBase, file); - return nullptr; - }; - std::vector values = - static_cast(file)->GetPropertyValues(internalType, name); - *numValues = values.size(); - char** ret = static_cast(malloc(sizeof(char*) * values.size())); - for (int i = 0; i < *numValues; ++i) - { - ret[i] = strdup(values[i].c_str()); - } - return ret; -} - -void* Interface_Filesystem::curl_create(void* kodiBase, const char* url) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || url == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', url='{}')", - __FUNCTION__, kodiBase, static_cast(url)); - return nullptr; - } - - CFile* file = new CFile; - if (file->CURLCreate(url)) - return static_cast(file); - - delete file; - return nullptr; -} - -bool Interface_Filesystem::curl_add_option( - void* kodiBase, void* file, int type, const char* name, const char* value) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr || name == nullptr || value == nullptr) - { - CLog::Log( - LOGERROR, - "Interface_Filesystem::{} - invalid data (addon='{}', file='{}', name='{}', value='{}')", - __FUNCTION__, kodiBase, file, static_cast(name), - static_cast(value)); - return false; - } - - XFILE::CURLOPTIONTYPE internalType; - switch (type) - { - case ADDON_CURL_OPTION_OPTION: - internalType = XFILE::CURL_OPTION_OPTION; - break; - case ADDON_CURL_OPTION_PROTOCOL: - internalType = XFILE::CURL_OPTION_PROTOCOL; - break; - case ADDON_CURL_OPTION_CREDENTIALS: - internalType = XFILE::CURL_OPTION_CREDENTIALS; - break; - case ADDON_CURL_OPTION_HEADER: - internalType = XFILE::CURL_OPTION_HEADER; - break; - default: - throw std::logic_error("Interface_Filesystem::curl_add_option - invalid curl option type"); - return false; - }; - - return static_cast(file)->CURLAddOption(internalType, name, value); -} - -bool Interface_Filesystem::curl_open(void* kodiBase, void* file, unsigned int flags) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || file == nullptr) - { - CLog::Log(LOGERROR, "Interface_Filesystem::{} - invalid data (addon='{}', file='{}')", - __FUNCTION__, kodiBase, file); - return false; - } - - return static_cast(file)->CURLOpen(TranslateFileReadBitsToKodi(flags)); -} - -} /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/Filesystem.h b/xbmc/addons/interfaces/Filesystem.h deleted file mode 100644 index 55e90ce95febd..0000000000000 --- a/xbmc/addons/interfaces/Filesystem.h +++ /dev/null @@ -1,131 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/Filesystem.h" - -extern "C" -{ - -struct VFSDirEntry; -struct AddonGlobalInterface; - -namespace ADDON -{ - -struct Interface_Filesystem -{ - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - static unsigned int TranslateFileReadBitsToKodi(unsigned int addonFlags); - - /*! - * @brief callback functions from add-on to kodi - * - * @note For add of new functions use the "_" style to identify direct a - * add-on callback function. Everything with CamelCase is only for the - * usage in Kodi only. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - ///@{ - static bool can_open_directory(void* kodiBase, const char* url); - static bool create_directory(void* kodiBase, const char* path); - static bool directory_exists(void* kodiBase, const char* path); - static bool remove_directory(void* kodiBase, const char* path); - static bool remove_directory_recursive(void* kodiBase, const char* path); - static bool get_directory(void* kodiBase, - const char* path, - const char* mask, - struct VFSDirEntry** items, - unsigned int* num_items); - static void free_directory(void* kodiBase, struct VFSDirEntry* items, unsigned int num_items); - - static bool file_exists(void* kodiBase, const char* filename, bool useCache); - static bool stat_file(void* kodiBase, const char* filename, struct STAT_STRUCTURE* buffer); - static bool delete_file(void* kodiBase, const char* filename); - static bool rename_file(void* kodiBase, const char* filename, const char* newFileName); - static bool copy_file(void* kodiBase, const char* filename, const char* dest); - static char* get_file_md5(void* kodiBase, const char* filename); - static char* get_cache_thumb_name(void* kodiBase, const char* filename); - static char* make_legal_filename(void* kodiBase, const char* filename); - static char* make_legal_path(void* kodiBase, const char* path); - static char* translate_special_protocol(void* kodiBase, const char* strSource); - static bool get_disk_space( - void* kodiBase, const char* path, uint64_t* capacity, uint64_t* free, uint64_t* available); - static bool is_internet_stream(void* kodiBase, const char* path, bool strictCheck); - static bool is_on_lan(void* kodiBase, const char* path); - static bool is_remote(void* kodiBase, const char* path); - static bool is_local(void* kodiBase, const char* path); - static bool is_url(void* kodiBase, const char* path); - - static bool get_http_header(void* kodiBase, const char* url, struct KODI_HTTP_HEADER* headers); - static bool get_mime_type(void* kodiBase, const char* url, char** content, const char* useragent); - static bool get_content_type(void* kodiBase, - const char* url, - char** content, - const char* useragent); - static bool get_cookies(void* kodiBase, const char* url, char** cookies); - - /*! - * @brief Callback functions addon class kodi::vfs::CFile - */ - ///@{ - static bool http_header_create(void* kodiBase, struct KODI_HTTP_HEADER* headers); - static void http_header_free(void* kodiBase, struct KODI_HTTP_HEADER* headers); - - static char* http_header_get_value(void* kodiBase, void* handle, const char* param); - static char** http_header_get_values(void* kodiBase, - void* handle, - const char* param, - int* length); - static char* http_header_get_header(void* kodiBase, void* handle); - static char* http_header_get_mime_type(void* kodiBase, void* handle); - static char* http_header_get_charset(void* kodiBase, void* handle); - static char* http_header_get_proto_line(void* kodiBase, void* handle); - ///@} - - /*! - * @brief Callback functions addon class kodi::vfs::CFile - */ - ///@{ - static void* open_file(void* kodiBase, const char* filename, unsigned int flags); - static void* open_file_for_write(void* kodiBase, const char* filename, bool overwrite); - static ssize_t read_file(void* kodiBase, void* file, void* ptr, size_t size); - static bool read_file_string(void* kodiBase, void* file, char* szLine, int lineLength); - static ssize_t write_file(void* kodiBase, void* file, const void* ptr, size_t size); - static void flush_file(void* kodiBase, void* file); - static int64_t seek_file(void* kodiBase, void* file, int64_t position, int whence); - static int truncate_file(void* kodiBase, void* file, int64_t size); - static int64_t get_file_position(void* kodiBase, void* file); - static int64_t get_file_length(void* kodiBase, void* file); - static double get_file_download_speed(void* kodiBase, void* file); - static void close_file(void* kodiBase, void* file); - static int get_file_chunk_size(void* kodiBase, void* file); - static bool io_control_get_seek_possible(void* kodiBase, void* file); - static bool io_control_get_cache_status(void* kodiBase, - void* file, - struct VFS_CACHE_STATUS_DATA* status); - static bool io_control_set_cache_rate(void* kodiBase, void* file, uint32_t rate); - static bool io_control_set_retry(void* kodiBase, void* file, bool retry); - static char** get_property_values( - void* kodiBase, void* file, int type, const char* name, int* numValues); - - static void* curl_create(void* kodiBase, const char* url); - static bool curl_add_option( - void* kodiBase, void* file, int type, const char* name, const char* value); - static bool curl_open(void* kodiBase, void* file, unsigned int flags); - ///@} - ///@} -}; - -} /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/General.cpp b/xbmc/addons/interfaces/General.cpp deleted file mode 100644 index 418463463fbec..0000000000000 --- a/xbmc/addons/interfaces/General.cpp +++ /dev/null @@ -1,464 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "General.h" - -#include "Application.h" -#include "CompileInfo.h" -#include "LangInfo.h" -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/gui/GUIDialogAddonSettings.h" -#include "addons/kodi-dev-kit/include/kodi/General.h" -#include "dialogs/GUIDialogKaiToast.h" -#include "input/KeyboardLayout.h" -#include "input/KeyboardLayoutManager.h" -#include "settings/Settings.h" -#include "settings/SettingsComponent.h" -#include "utils/CharsetConverter.h" -#include "utils/Digest.h" -#include "utils/LangCodeExpander.h" -#include "utils/MemUtils.h" -#include "utils/StringUtils.h" -#include "utils/log.h" - -#include - -using namespace kodi; // addon-dev-kit namespace -using KODI::UTILITY::CDigest; - -namespace ADDON -{ - -void Interface_General::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi = static_cast(malloc(sizeof(AddonToKodiFuncTable_kodi))); - - addonInterface->toKodi->kodi->unknown_to_utf8 = unknown_to_utf8; - addonInterface->toKodi->kodi->get_language = get_language; - addonInterface->toKodi->kodi->queue_notification = queue_notification; - addonInterface->toKodi->kodi->get_md5 = get_md5; - addonInterface->toKodi->kodi->get_region = get_region; - addonInterface->toKodi->kodi->get_free_mem = get_free_mem; - addonInterface->toKodi->kodi->get_global_idle_time = get_global_idle_time; - addonInterface->toKodi->kodi->is_addon_avilable = is_addon_avilable; - addonInterface->toKodi->kodi->kodi_version = kodi_version; - addonInterface->toKodi->kodi->get_current_skin_id = get_current_skin_id; - addonInterface->toKodi->kodi->get_keyboard_layout = get_keyboard_layout; - addonInterface->toKodi->kodi->change_keyboard_layout = change_keyboard_layout; -} - -void Interface_General::DeInit(AddonGlobalInterface* addonInterface) -{ - if (addonInterface->toKodi && /* <-- needed as long as the old addon way is used */ - addonInterface->toKodi->kodi) - { - free(addonInterface->toKodi->kodi); - addonInterface->toKodi->kodi = nullptr; - } -} - -char* Interface_General::unknown_to_utf8(void* kodiBase, const char* source, bool* ret, bool failOnBadChar) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon || !source || !ret) - { - CLog::Log(LOGERROR, "Interface_General::{} - invalid data (addon='{}', source='{}', ret='{}')", - __FUNCTION__, kodiBase, static_cast(source), static_cast(ret)); - return nullptr; - } - - std::string string; - *ret = g_charsetConverter.unknownToUTF8(source, string, failOnBadChar); - char* buffer = strdup(string.c_str()); - return buffer; -} - -char* Interface_General::get_language(void* kodiBase, int format, bool region) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_General::{} - invalid data (addon='{}')", __FUNCTION__, - kodiBase); - return nullptr; - } - - std::string string = g_langInfo.GetEnglishLanguageName(); - switch (format) - { - case LANG_FMT_ISO_639_1: - { - std::string langCode; - g_LangCodeExpander.ConvertToISO6391(string, langCode); - string = langCode; - if (region) - { - std::string region2Code; - g_LangCodeExpander.ConvertToISO6391(g_langInfo.GetRegionLocale(), region2Code); - if (!region2Code.empty()) - string += "-" + region2Code; - } - break; - } - case LANG_FMT_ISO_639_2: - { - std::string langCode; - g_LangCodeExpander.ConvertToISO6392B(string, langCode); - string = langCode; - if (region) - { - std::string region3Code; - g_LangCodeExpander.ConvertToISO6392B(g_langInfo.GetRegionLocale(), region3Code); - if (!region3Code.empty()) - string += "-" + region3Code; - } - break; - } - case LANG_FMT_ENGLISH_NAME: - default: - { - if (region) - string += "-" + g_langInfo.GetCurrentRegion(); - break; - } - } - - char* buffer = strdup(string.c_str()); - return buffer; -} - -bool Interface_General::queue_notification(void* kodiBase, int type, const char* header, - const char* message, const char* imageFile, - unsigned int displayTime, bool withSound, - unsigned int messageTime) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || message == nullptr) - { - CLog::Log(LOGERROR, "Interface_General::{} - invalid data (addon='{}', message='{}')", - __FUNCTION__, kodiBase, static_cast(message)); - return false; - } - - std::string usedHeader; - if (header && strlen(header) > 0) - usedHeader = header; - else - usedHeader = addon->Name(); - - QueueMsg qtype = static_cast(type); - - if (qtype != QUEUE_OWN_STYLE) - { - CGUIDialogKaiToast::eMessageType usedType; - switch (qtype) - { - case QueueMsg::QUEUE_WARNING: - usedType = CGUIDialogKaiToast::Warning; - withSound = true; - CLog::Log(LOGDEBUG, "Interface_General::{} - {} - Warning Message: '{}'", __FUNCTION__, - addon->Name(), message); - break; - case QueueMsg::QUEUE_ERROR: - usedType = CGUIDialogKaiToast::Error; - withSound = true; - CLog::Log(LOGDEBUG, "Interface_General::{} - {} - Error Message : '{}'", __FUNCTION__, - addon->Name(), message); - break; - case QueueMsg::QUEUE_INFO: - default: - usedType = CGUIDialogKaiToast::Info; - withSound = false; - CLog::Log(LOGDEBUG, "Interface_General::{} - {} - Info Message : '{}'", __FUNCTION__, - addon->Name(), message); - break; - } - - if (imageFile && strlen(imageFile) > 0) - { - CLog::Log(LOGERROR, - "Interface_General::{} - To use given image file '{}' must be type value set to " - "'QUEUE_OWN_STYLE'", - __FUNCTION__, imageFile); - } - - CGUIDialogKaiToast::QueueNotification(usedType, usedHeader, message, 3000, withSound); - } - else - { - CGUIDialogKaiToast::QueueNotification(imageFile, usedHeader, message, displayTime, withSound, messageTime); - } - return true; -} - -void Interface_General::get_md5(void* kodiBase, const char* text, char* md5) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || text == nullptr) - { - CLog::Log(LOGERROR, "Interface_General::{} - invalid data (addon='{}', text='{}')", - __FUNCTION__, kodiBase, static_cast(text)); - return; - } - - std::string md5Int = CDigest::Calculate(CDigest::Type::MD5, std::string(text)); - strncpy(md5, md5Int.c_str(), 40); -} - -char* Interface_General::get_region(void* kodiBase, const char* id) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || id == nullptr) - { - CLog::Log(LOGERROR, "Interface_General::{} - invalid data (addon='{}', id='{}')", __FUNCTION__, - kodiBase, static_cast(id)); - return nullptr; - } - - std::string result; - if (StringUtils::CompareNoCase(id, "datelong") == 0) - { - result = g_langInfo.GetDateFormat(true); - StringUtils::Replace(result, "DDDD", "%A"); - StringUtils::Replace(result, "MMMM", "%B"); - StringUtils::Replace(result, "D", "%d"); - StringUtils::Replace(result, "YYYY", "%Y"); - } - else if (StringUtils::CompareNoCase(id, "dateshort") == 0) - { - result = g_langInfo.GetDateFormat(false); - StringUtils::Replace(result, "MM", "%m"); - StringUtils::Replace(result, "DD", "%d"); -#ifdef TARGET_WINDOWS - StringUtils::Replace(result, "M", "%#m"); - StringUtils::Replace(result, "D", "%#d"); -#else - StringUtils::Replace(result, "M", "%-m"); - StringUtils::Replace(result, "D", "%-d"); -#endif - StringUtils::Replace(result, "YYYY", "%Y"); - } - else if (StringUtils::CompareNoCase(id, "tempunit") == 0) - result = g_langInfo.GetTemperatureUnitString(); - else if (StringUtils::CompareNoCase(id, "speedunit") == 0) - result = g_langInfo.GetSpeedUnitString(); - else if (StringUtils::CompareNoCase(id, "time") == 0) - { - result = g_langInfo.GetTimeFormat(); - StringUtils::Replace(result, "H", "%H"); - StringUtils::Replace(result, "h", "%I"); - StringUtils::Replace(result, "mm", "%M"); - StringUtils::Replace(result, "ss", "%S"); - StringUtils::Replace(result, "xx", "%p"); - } - else if (StringUtils::CompareNoCase(id, "meridiem") == 0) - result = StringUtils::Format("{}/{}", g_langInfo.GetMeridiemSymbol(MeridiemSymbolAM), - g_langInfo.GetMeridiemSymbol(MeridiemSymbolPM)); - else - { - CLog::Log(LOGERROR, "Interface_General::{} - add-on '{}' requests invalid id '{}'", - __FUNCTION__, addon->Name(), id); - return nullptr; - } - - char* buffer = strdup(result.c_str()); - return buffer; -} - -void Interface_General::get_free_mem(void* kodiBase, long* free, long* total, bool as_bytes) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || free == nullptr || total == nullptr) - { - CLog::Log(LOGERROR, "Interface_General::{} - invalid data (addon='{}', free='{}', total='{}')", - __FUNCTION__, kodiBase, static_cast(free), static_cast(total)); - return; - } - - KODI::MEMORY::MemoryStatus stat; - KODI::MEMORY::GetMemoryStatus(&stat); - *free = static_cast(stat.availPhys); - *total = static_cast(stat.totalPhys); - if (!as_bytes) - { - *free = *free / ( 1024 * 1024 ); - *total = *total / ( 1024 * 1024 ); - } -} - -int Interface_General::get_global_idle_time(void* kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "Interface_General::{} - invalid data (addon='{}')", __FUNCTION__, - kodiBase); - return -1; - } - - return g_application.GlobalIdleTime(); -} - -bool Interface_General::is_addon_avilable(void* kodiBase, - const char* id, - char** version, - bool* enabled) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || id == nullptr || version == nullptr || enabled == nullptr) - { - CLog::Log( - LOGERROR, - "Interface_General::{} - invalid data (addon='{}', id='{}', version='{}', enabled='{}')", - __FUNCTION__, kodiBase, static_cast(id), static_cast(version), - static_cast(enabled)); - return false; - } - - AddonPtr addonInfo; - if (!CServiceBroker::GetAddonMgr().GetAddon(id, addonInfo, ADDON_UNKNOWN, OnlyEnabled::CHOICE_NO)) - return false; - - *version = strdup(addonInfo->Version().asString().c_str()); - *enabled = !CServiceBroker::GetAddonMgr().IsAddonDisabled(id); - return true; -} - -void Interface_General::kodi_version(void* kodiBase, char** compile_name, int* major, int* minor, char** revision, char** tag, char** tagversion) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || compile_name == nullptr || major == nullptr || minor == nullptr || - revision == nullptr || tag == nullptr || tagversion == nullptr) - { - CLog::Log(LOGERROR, - "Interface_General::{} - invalid data (addon='{}', compile_name='{}', major='{}', " - "minor='{}', revision='{}', tag='{}', tagversion='{}')", - __FUNCTION__, kodiBase, static_cast(compile_name), static_cast(major), - static_cast(minor), static_cast(revision), static_cast(tag), - static_cast(tagversion)); - return; - } - - *compile_name = strdup(CCompileInfo::GetAppName()); - *major = CCompileInfo::GetMajor(); - *minor = CCompileInfo::GetMinor(); - *revision = strdup(CCompileInfo::GetSCMID()); - std::string tagStr = CCompileInfo::GetSuffix(); - if (StringUtils::StartsWithNoCase(tagStr, "alpha")) - { - *tag = strdup("alpha"); - *tagversion = strdup(StringUtils::Mid(tagStr, 5).c_str()); - } - else if (StringUtils::StartsWithNoCase(tagStr, "beta")) - { - *tag = strdup("beta"); - *tagversion = strdup(StringUtils::Mid(tagStr, 4).c_str()); - } - else if (StringUtils::StartsWithNoCase(tagStr, "rc")) - { - *tag = strdup("releasecandidate"); - *tagversion = strdup(StringUtils::Mid(tagStr, 2).c_str()); - } - else if (tagStr.empty()) - *tag = strdup("stable"); - else - *tag = strdup("prealpha"); -} - -char* Interface_General::get_current_skin_id(void* kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "Interface_General::{} - invalid data (addon='{}')", __FUNCTION__, - kodiBase); - return nullptr; - } - - return strdup(CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOOKANDFEEL_SKIN).c_str()); -} - -bool Interface_General::get_keyboard_layout(void* kodiBase, char** layout_name, int modifier_key, AddonKeyboardKeyTable* c_layout) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || c_layout == nullptr || layout_name == nullptr) - { - CLog::Log(LOGERROR, - "Interface_General::{} - invalid data (addon='{}', c_layout='{}', layout_name='{}')", - __FUNCTION__, kodiBase, static_cast(c_layout), - static_cast(layout_name)); - return false; - } - - std::string activeLayout = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_ACTIVEKEYBOARDLAYOUT); - - CKeyboardLayout layout; - if (!CServiceBroker::GetKeyboardLayoutManager()->GetLayout(activeLayout, layout)) - return false; - - *layout_name = strdup(layout.GetName().c_str()); - - unsigned int modifiers = CKeyboardLayout::ModifierKeyNone; - if (modifier_key & STD_KB_MODIFIER_KEY_SHIFT) - modifiers |= CKeyboardLayout::ModifierKeyShift; - if (modifier_key & STD_KB_MODIFIER_KEY_SYMBOL) - modifiers |= CKeyboardLayout::ModifierKeySymbol; - - for (unsigned int row = 0; row < STD_KB_BUTTONS_MAX_ROWS; row++) - { - for (unsigned int column = 0; column < STD_KB_BUTTONS_PER_ROW; column++) - { - std::string label = layout.GetCharAt(row, column, modifiers); - c_layout->keys[row][column] = strdup(label.c_str()); - } - } - - return true; -} - -bool Interface_General::change_keyboard_layout(void* kodiBase, char** layout_name) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || layout_name == nullptr) - { - CLog::Log(LOGERROR, "Interface_General::{} - invalid data (addon='{}', layout_name='{}')", - __FUNCTION__, kodiBase, static_cast(layout_name)); - return false; - } - - std::vector layouts; - unsigned int currentLayout = 0; - - const KeyboardLayouts& keyboardLayouts = CServiceBroker::GetKeyboardLayoutManager()->GetLayouts(); - const std::shared_ptr settings = CServiceBroker::GetSettingsComponent()->GetSettings(); - std::vector layoutNames = settings->GetList(CSettings::SETTING_LOCALE_KEYBOARDLAYOUTS); - std::string activeLayout = settings->GetString(CSettings::SETTING_LOCALE_ACTIVEKEYBOARDLAYOUT); - - for (const auto& layoutName : layoutNames) - { - const auto keyboardLayout = keyboardLayouts.find(layoutName.asString()); - if (keyboardLayout != keyboardLayouts.end()) - { - layouts.emplace_back(keyboardLayout->second); - if (layoutName.asString() == activeLayout) - currentLayout = layouts.size() - 1; - } - } - - currentLayout++; - if (currentLayout >= layouts.size()) - currentLayout = 0; - CKeyboardLayout layout = layouts.empty() ? CKeyboardLayout() : layouts[currentLayout]; - CServiceBroker::GetSettingsComponent()->GetSettings()->SetString(CSettings::SETTING_LOCALE_ACTIVEKEYBOARDLAYOUT, layout.GetName()); - - *layout_name = strdup(layout.GetName().c_str()); - return true; -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/General.h b/xbmc/addons/interfaces/General.h deleted file mode 100644 index 6dde35618b72e..0000000000000 --- a/xbmc/addons/interfaces/General.h +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -extern "C" -{ - -struct AddonGlobalInterface; -struct AddonKeyboardKeyTable; - -namespace ADDON -{ - -/*! - * @brief Global general Add-on to Kodi callback functions - * - * To hold general functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/General.h" - */ -struct Interface_General -{ - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static char* unknown_to_utf8(void* kodiBase, const char* source, bool* ret, bool failOnBadChar); - static char* get_language(void* kodiBase, int format, bool region); - static bool queue_notification(void* kodiBase, - int type, - const char* header, - const char* message, - const char* imageFile, - unsigned int displayTime, - bool withSound, - unsigned int messageTime); - static void get_md5(void* kodiBase, const char* text, char* md5); - static char* get_region(void* kodiBase, const char* id); - static void get_free_mem(void* kodiInstance, long* free, long* total, bool as_bytes); - static int get_global_idle_time(void* kodiBase); - static bool is_addon_avilable(void* kodiBase, const char* id, char** version, bool* enabled); - static void kodi_version(void* kodiBase, - char** compile_name, - int* major, - int* minor, - char** revision, - char** tag, - char** tagversion); - static char* get_current_skin_id(void* kodiBase); - static bool change_keyboard_layout(void* kodiBase, char** layout_name); - static bool get_keyboard_layout(void* kodiBase, - char** layout_name, - int modifier_key, - AddonKeyboardKeyTable* c_layout); - //@} -}; - -} /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/Network.cpp b/xbmc/addons/interfaces/Network.cpp deleted file mode 100644 index 63151f3b78c82..0000000000000 --- a/xbmc/addons/interfaces/Network.cpp +++ /dev/null @@ -1,181 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Network.h" - -#include "ServiceBroker.h" -#include "URL.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/Network.h" -#include "network/DNSNameCache.h" -#include "network/Network.h" -#include "utils/SystemInfo.h" -#include "utils/URIUtils.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_Network::Init(AddonGlobalInterface *addonInterface) -{ - addonInterface->toKodi->kodi_network = new AddonToKodiFuncTable_kodi_network(); - - addonInterface->toKodi->kodi_network->wake_on_lan = wake_on_lan; - addonInterface->toKodi->kodi_network->get_ip_address = get_ip_address; - addonInterface->toKodi->kodi_network->get_hostname = get_hostname; - addonInterface->toKodi->kodi_network->get_user_agent = get_user_agent; - addonInterface->toKodi->kodi_network->is_local_host = is_local_host; - addonInterface->toKodi->kodi_network->is_host_on_lan = is_host_on_lan; - addonInterface->toKodi->kodi_network->dns_lookup = dns_lookup; - addonInterface->toKodi->kodi_network->url_encode = url_encode; -} - -void Interface_Network::DeInit(AddonGlobalInterface* addonInterface) -{ - if (addonInterface->toKodi) /* <-- needed as long as the old addon way is used */ - { - delete addonInterface->toKodi->kodi_network; - addonInterface->toKodi->kodi_network = nullptr; - } -} - -bool Interface_Network::wake_on_lan(void* kodiBase, const char* mac) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || mac == nullptr) - { - CLog::Log(LOGERROR, "Interface_Network::{} - invalid data (addon='{}', mac='{}')", __FUNCTION__, - kodiBase, static_cast(mac)); - return false; - } - - return CServiceBroker::GetNetwork().WakeOnLan(mac); -} - -char* Interface_Network::get_ip_address(void* kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "Interface_Network::{} - invalid data (addon='{}')", __FUNCTION__, - kodiBase); - return nullptr; - } - - std::string titleIP; - CNetworkInterface* iface = CServiceBroker::GetNetwork().GetFirstConnectedInterface(); - if (iface) - titleIP = iface->GetCurrentIPAddress(); - else - titleIP = "127.0.0.1"; - - char* buffer = nullptr; - if (!titleIP.empty()) - buffer = strdup(titleIP.c_str()); - return buffer; -} - -char* Interface_Network::get_hostname(void* kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "Interface_Network::{} - invalid data (addon='{}')", __FUNCTION__, - kodiBase); - return nullptr; - } - - std::string hostname; - if (!CServiceBroker::GetNetwork().GetHostName(hostname)) - return nullptr; - - char* buffer = nullptr; - if (!hostname.empty()) - buffer = strdup(hostname.c_str()); - return buffer; -} - -char* Interface_Network::get_user_agent(void* kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr) - { - CLog::Log(LOGERROR, "Interface_Network::{} - invalid data (addon='{}')", __FUNCTION__, - kodiBase); - return nullptr; - } - - std::string string = CSysInfo::GetUserAgent(); - char* buffer = nullptr; - if (!string.empty()) - buffer = strdup(string.c_str()); - return buffer; -} - -bool Interface_Network::is_local_host(void* kodiBase, const char* hostname) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || hostname == nullptr) - { - CLog::Log(LOGERROR, "Interface_Network::{} - invalid data (addon='{}', hostname='{}')", - __FUNCTION__, kodiBase, static_cast(hostname)); - return false; - } - - return CServiceBroker::GetNetwork().IsLocalHost(hostname); -} - -bool Interface_Network::is_host_on_lan(void* kodiBase, const char* hostname, bool offLineCheck) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || hostname == nullptr) - { - CLog::Log(LOGERROR, "Interface_Network::{} - invalid data (addon='{}', hostname='{}')", - __FUNCTION__, kodiBase, static_cast(hostname)); - return false; - } - - return URIUtils::IsHostOnLAN(hostname, offLineCheck); -} - -char* Interface_Network::dns_lookup(void* kodiBase, const char* url, bool* ret) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || url == nullptr || ret == nullptr) - { - CLog::Log(LOGERROR, "Interface_Network::{} - invalid data (addon='{}', url='{}', ret='{}')", - __FUNCTION__, kodiBase, static_cast(url), static_cast(ret)); - return nullptr; - } - - std::string string; - *ret = CDNSNameCache::Lookup(url, string); - char* buffer = nullptr; - if (!string.empty()) - buffer = strdup(string.c_str()); - return buffer; -} - -char* Interface_Network::url_encode(void* kodiBase, const char* url) -{ - CAddonDll* addon = static_cast(kodiBase); - if (addon == nullptr || url == nullptr) - { - CLog::Log(LOGERROR, "Interface_Network::{} - invalid data (addon='{}', url='{}')", __FUNCTION__, - kodiBase, static_cast(url)); - return nullptr; - } - - std::string string = CURL::Encode(url); - char* buffer = nullptr; - if (!string.empty()) - buffer = strdup(string.c_str()); - return buffer; -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/Network.h b/xbmc/addons/interfaces/Network.h deleted file mode 100644 index b704fb1579c78..0000000000000 --- a/xbmc/addons/interfaces/Network.h +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -struct AddonGlobalInterface; - -extern "C" -{ -namespace ADDON -{ - -/*! - * @brief Global general Add-on to Kodi callback functions - * - * To hold network functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/Network.h" - */ -struct Interface_Network -{ - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static bool wake_on_lan(void* kodiBase, const char* mac); - static char* get_ip_address(void* kodiBase); - static char* get_hostname(void* kodiBase); - static char* get_user_agent(void* kodiBase); - static bool is_local_host(void* kodiBase, const char* hostname); - static bool is_host_on_lan(void* kodiBase, const char* hostname, bool offLineCheck); - static char* dns_lookup(void* kodiBase, const char* url, bool* ret); - static char* url_encode(void* kodiBase, const char* url); - //@} -}; - -} /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/CMakeLists.txt b/xbmc/addons/interfaces/gui/CMakeLists.txt deleted file mode 100644 index 3508b82fa1e62..0000000000000 --- a/xbmc/addons/interfaces/gui/CMakeLists.txt +++ /dev/null @@ -1,11 +0,0 @@ -set(SOURCES GUITranslator.cpp - General.cpp - ListItem.cpp - Window.cpp) - -set(HEADERS GUITranslator.h - General.h - ListItem.h - Window.h) - -core_add_library(addons_interfaces_gui) diff --git a/xbmc/addons/interfaces/gui/General.cpp b/xbmc/addons/interfaces/gui/General.cpp deleted file mode 100644 index 8070969391169..0000000000000 --- a/xbmc/addons/interfaces/gui/General.cpp +++ /dev/null @@ -1,217 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "General.h" - -#include "ListItem.h" -#include "ServiceBroker.h" -#include "Window.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/General.h" -#include "controls/Button.h" -#include "controls/Edit.h" -#include "controls/FadeLabel.h" -#include "controls/Image.h" -#include "controls/Label.h" -#include "controls/Progress.h" -#include "controls/RadioButton.h" -#include "controls/Rendering.h" -#include "controls/SettingsSlider.h" -#include "controls/Slider.h" -#include "controls/Spin.h" -#include "controls/TextBox.h" -#include "dialogs/ContextMenu.h" -#include "dialogs/ExtendedProgressBar.h" -#include "dialogs/FileBrowser.h" -#include "dialogs/Keyboard.h" -#include "dialogs/Numeric.h" -#include "dialogs/OK.h" -#include "dialogs/Progress.h" -#include "dialogs/Select.h" -#include "dialogs/TextViewer.h" -#include "dialogs/YesNo.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -#include - -namespace ADDON -{ -int Interface_GUIGeneral::m_iAddonGUILockRef = 0; - -void Interface_GUIGeneral::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui = new AddonToKodiFuncTable_kodi_gui(); - - Interface_GUIControlButton::Init(addonInterface); - Interface_GUIControlEdit::Init(addonInterface); - Interface_GUIControlFadeLabel::Init(addonInterface); - Interface_GUIControlImage::Init(addonInterface); - Interface_GUIControlLabel::Init(addonInterface); - Interface_GUIControlProgress::Init(addonInterface); - Interface_GUIControlRadioButton::Init(addonInterface); - Interface_GUIControlAddonRendering::Init(addonInterface); - Interface_GUIControlSettingsSlider::Init(addonInterface); - Interface_GUIControlSlider::Init(addonInterface); - Interface_GUIControlSpin::Init(addonInterface); - Interface_GUIControlTextBox::Init(addonInterface); - Interface_GUIDialogContextMenu::Init(addonInterface); - Interface_GUIDialogExtendedProgress::Init(addonInterface); - Interface_GUIDialogFileBrowser::Init(addonInterface); - Interface_GUIDialogKeyboard::Init(addonInterface); - Interface_GUIDialogNumeric::Init(addonInterface); - Interface_GUIDialogOK::Init(addonInterface); - Interface_GUIDialogProgress::Init(addonInterface); - Interface_GUIDialogSelect::Init(addonInterface); - Interface_GUIDialogTextViewer::Init(addonInterface); - Interface_GUIDialogYesNo::Init(addonInterface); - Interface_GUIListItem::Init(addonInterface); - Interface_GUIWindow::Init(addonInterface); - - addonInterface->toKodi->kodi_gui->general = new AddonToKodiFuncTable_kodi_gui_general(); - - addonInterface->toKodi->kodi_gui->general->lock = lock; - addonInterface->toKodi->kodi_gui->general->unlock = unlock; - addonInterface->toKodi->kodi_gui->general->get_screen_height = get_screen_height; - addonInterface->toKodi->kodi_gui->general->get_screen_width = get_screen_width; - addonInterface->toKodi->kodi_gui->general->get_video_resolution = get_video_resolution; - addonInterface->toKodi->kodi_gui->general->get_current_window_dialog_id = - get_current_window_dialog_id; - addonInterface->toKodi->kodi_gui->general->get_current_window_id = get_current_window_id; - addonInterface->toKodi->kodi_gui->general->get_hw_context = get_hw_context; -} - -void Interface_GUIGeneral::DeInit(AddonGlobalInterface* addonInterface) -{ - if (addonInterface->toKodi && /* <-- needed as long as the old addon way is used */ - addonInterface->toKodi->kodi_gui) - { - Interface_GUIControlButton::DeInit(addonInterface); - Interface_GUIControlEdit::DeInit(addonInterface); - Interface_GUIControlFadeLabel::DeInit(addonInterface); - Interface_GUIControlImage::DeInit(addonInterface); - Interface_GUIControlLabel::DeInit(addonInterface); - Interface_GUIControlProgress::DeInit(addonInterface); - Interface_GUIControlRadioButton::DeInit(addonInterface); - Interface_GUIControlAddonRendering::DeInit(addonInterface); - Interface_GUIControlSettingsSlider::DeInit(addonInterface); - Interface_GUIControlSlider::DeInit(addonInterface); - Interface_GUIControlSpin::DeInit(addonInterface); - Interface_GUIControlTextBox::DeInit(addonInterface); - Interface_GUIDialogContextMenu::DeInit(addonInterface); - Interface_GUIDialogExtendedProgress::DeInit(addonInterface); - Interface_GUIDialogFileBrowser::DeInit(addonInterface); - Interface_GUIDialogKeyboard::DeInit(addonInterface); - Interface_GUIDialogNumeric::DeInit(addonInterface); - Interface_GUIDialogOK::DeInit(addonInterface); - Interface_GUIDialogProgress::DeInit(addonInterface); - Interface_GUIDialogSelect::DeInit(addonInterface); - Interface_GUIDialogTextViewer::DeInit(addonInterface); - Interface_GUIDialogYesNo::DeInit(addonInterface); - Interface_GUIListItem::DeInit(addonInterface); - Interface_GUIWindow::DeInit(addonInterface); - - delete addonInterface->toKodi->kodi_gui->general; - delete addonInterface->toKodi->kodi_gui; - addonInterface->toKodi->kodi_gui = nullptr; - } -} - -//@{ -void Interface_GUIGeneral::lock() -{ - if (m_iAddonGUILockRef == 0) - CServiceBroker::GetWinSystem()->GetGfxContext().lock(); - ++m_iAddonGUILockRef; -} - -void Interface_GUIGeneral::unlock() -{ - if (m_iAddonGUILockRef > 0) - { - --m_iAddonGUILockRef; - if (m_iAddonGUILockRef == 0) - CServiceBroker::GetWinSystem()->GetGfxContext().unlock(); - } -} -//@} - -//@{ -int Interface_GUIGeneral::get_screen_height(KODI_HANDLE kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__); - return -1; - } - - return CServiceBroker::GetWinSystem()->GetGfxContext().GetHeight(); -} - -int Interface_GUIGeneral::get_screen_width(KODI_HANDLE kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__); - return -1; - } - - return CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth(); -} - -int Interface_GUIGeneral::get_video_resolution(KODI_HANDLE kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__); - return -1; - } - - return (int)CServiceBroker::GetWinSystem()->GetGfxContext().GetVideoResolution(); -} -//@} - -//@{ -int Interface_GUIGeneral::get_current_window_dialog_id(KODI_HANDLE kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__); - return -1; - } - - std::unique_lock gl(CServiceBroker::GetWinSystem()->GetGfxContext()); - return CServiceBroker::GetGUI()->GetWindowManager().GetTopmostModalDialog(); -} - -int Interface_GUIGeneral::get_current_window_id(KODI_HANDLE kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "kodi::gui::{} - invalid data", __func__); - return -1; - } - - std::unique_lock gl(CServiceBroker::GetWinSystem()->GetGfxContext()); - return CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(); -} - -ADDON_HARDWARE_CONTEXT Interface_GUIGeneral::get_hw_context(KODI_HANDLE kodiBase) -{ - return CServiceBroker::GetWinSystem()->GetHWContext(); -} - -//@} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/General.h b/xbmc/addons/interfaces/gui/General.h deleted file mode 100644 index 4ef9328c38bf2..0000000000000 --- a/xbmc/addons/interfaces/gui/General.h +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/general.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/General.h" - */ - struct Interface_GUIGeneral - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note For add of new functions use the "_" style to identify direct a - * add-on callback function. Everything with CamelCase is only for the - * usage in Kodi only. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void lock(); - static void unlock(); - - static int get_screen_height(KODI_HANDLE kodiBase); - static int get_screen_width(KODI_HANDLE kodiBase); - static int get_video_resolution(KODI_HANDLE kodiBase); - static int get_current_window_dialog_id(KODI_HANDLE kodiBase); - static int get_current_window_id(KODI_HANDLE kodiBase); - static ADDON_HARDWARE_CONTEXT get_hw_context(KODI_HANDLE kodiBase); - //@} - - private: - static int m_iAddonGUILockRef; - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/ListItem.cpp b/xbmc/addons/interfaces/gui/ListItem.cpp deleted file mode 100644 index c91e451f489fe..0000000000000 --- a/xbmc/addons/interfaces/gui/ListItem.cpp +++ /dev/null @@ -1,428 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "ListItem.h" - -#include "FileItem.h" -#include "General.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/ListItem.h" -#include "utils/StringUtils.h" -#include "utils/Variant.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIListItem::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->listItem = new AddonToKodiFuncTable_kodi_gui_listItem(); - - addonInterface->toKodi->kodi_gui->listItem->create = create; - addonInterface->toKodi->kodi_gui->listItem->destroy = destroy; - addonInterface->toKodi->kodi_gui->listItem->get_label = get_label; - addonInterface->toKodi->kodi_gui->listItem->set_label = set_label; - addonInterface->toKodi->kodi_gui->listItem->get_label2 = get_label2; - addonInterface->toKodi->kodi_gui->listItem->set_label2 = set_label2; - addonInterface->toKodi->kodi_gui->listItem->get_art = get_art; - addonInterface->toKodi->kodi_gui->listItem->set_art = set_art; - addonInterface->toKodi->kodi_gui->listItem->get_path = get_path; - addonInterface->toKodi->kodi_gui->listItem->set_path = set_path; - addonInterface->toKodi->kodi_gui->listItem->get_property = get_property; - addonInterface->toKodi->kodi_gui->listItem->set_property = set_property; - addonInterface->toKodi->kodi_gui->listItem->select = select; - addonInterface->toKodi->kodi_gui->listItem->is_selected = is_selected; -} - -void Interface_GUIListItem::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->listItem; -} - -KODI_GUI_LISTITEM_HANDLE Interface_GUIListItem::create(KODI_HANDLE kodiBase, - const char* label, - const char* label2, - const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "ADDON::Interface_GUIListItem::{} - invalid data", __func__); - return nullptr; - } - - CFileItemPtr* item = new CFileItemPtr(new CFileItem()); - if (label) - item->get()->SetLabel(label); - if (label2) - item->get()->SetLabel2(label2); - if (path) - item->get()->SetPath(path); - - return item; -} - -void Interface_GUIListItem::destroy(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "ADDON::Interface_GUIListItem::{} - invalid data", __func__); - return; - } - - CFileItemPtr* item = static_cast(handle); - if (item) - delete item; -} - -char* Interface_GUIListItem::get_label(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return nullptr; - } - - char* ret; - Interface_GUIGeneral::lock(); - ret = strdup(item->get()->GetLabel().c_str()); - Interface_GUIGeneral::unlock(); - return ret; -} - -void Interface_GUIListItem::set_label(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* label) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}', " - "label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - addon ? addon->ID() : "unknown"); - return; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return; - } - - Interface_GUIGeneral::lock(); - item->get()->SetLabel(label); - Interface_GUIGeneral::unlock(); -} - -char* Interface_GUIListItem::get_label2(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return nullptr; - } - - char* ret; - Interface_GUIGeneral::lock(); - ret = strdup(item->get()->GetLabel2().c_str()); - Interface_GUIGeneral::unlock(); - return ret; -} - -void Interface_GUIListItem::set_label2(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* label) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}', " - "label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - addon ? addon->ID() : "unknown"); - return; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return; - } - - Interface_GUIGeneral::lock(); - item->get()->SetLabel2(label); - Interface_GUIGeneral::unlock(); -} - -char* Interface_GUIListItem::get_art(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* type) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item || !type) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', type='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(type), - addon ? addon->ID() : "unknown"); - return nullptr; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return nullptr; - } - - char* ret; - Interface_GUIGeneral::lock(); - ret = strdup(item->get()->GetArt(type).c_str()); - Interface_GUIGeneral::unlock(); - return ret; -} - -void Interface_GUIListItem::set_art(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* type, - const char* label) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item || !type || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}', type= " - "'{}', label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(type), - static_cast(label), addon ? addon->ID() : "unknown"); - return; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return; - } - - Interface_GUIGeneral::lock(); - item->get()->SetArt(type, label); - Interface_GUIGeneral::unlock(); -} - -char* Interface_GUIListItem::get_path(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return nullptr; - } - - char* ret; - Interface_GUIGeneral::lock(); - ret = strdup(item->get()->GetPath().c_str()); - Interface_GUIGeneral::unlock(); - return ret; -} - - -void Interface_GUIListItem::set_path(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* path) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item || !path) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', path='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(path), - addon ? addon->ID() : "unknown"); - return; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return; - } - - Interface_GUIGeneral::lock(); - item->get()->SetPath(path); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIListItem::set_property(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* key, - const char* value) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item || !key || !value) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}', value='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - static_cast(value), addon ? addon->ID() : "unknown"); - return; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - item->get()->SetProperty(lowerKey, CVariant(value)); - Interface_GUIGeneral::unlock(); -} - -char* Interface_GUIListItem::get_property(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* key) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item || !key) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - addon ? addon->ID() : "unknown"); - return nullptr; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return nullptr; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - char* ret = strdup(item->get()->GetProperty(lowerKey).asString().c_str()); - Interface_GUIGeneral::unlock(); - - return ret; -} - -void Interface_GUIListItem::select(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - bool select) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return; - } - - Interface_GUIGeneral::lock(); - item->get()->Select(select); - Interface_GUIGeneral::unlock(); -} - -bool Interface_GUIListItem::is_selected(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CFileItemPtr* item = static_cast(handle); - if (!addon || !item) - { - CLog::Log(LOGERROR, - "Interface_GUIListItem::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return false; - } - - if (item->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIListItem::{} - empty list item called on addon '{}'", - __func__, addon->ID()); - return false; - } - - Interface_GUIGeneral::lock(); - bool ret = item->get()->IsSelected(); - Interface_GUIGeneral::unlock(); - - return ret; -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/ListItem.h b/xbmc/addons/interfaces/gui/ListItem.h deleted file mode 100644 index 70e5c6a95e878..0000000000000 --- a/xbmc/addons/interfaces/gui/ListItem.h +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/list_item.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/ListItem.h" - */ - struct Interface_GUIListItem - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static KODI_GUI_LISTITEM_HANDLE create(KODI_HANDLE kodiBase, - const char* label, - const char* label2, - const char* path); - static void destroy(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle); - static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle); - static void set_label(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* label); - static char* get_label2(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle); - static void set_label2(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* label); - static char* get_art(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* type); - static void set_art(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* type, - const char* image); - static char* get_path(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle); - static void set_path(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* path); - static char* get_property(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* key); - static void set_property(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* key, - const char* value); - static void select(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, bool select); - static bool is_selected(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/Window.cpp b/xbmc/addons/interfaces/gui/Window.cpp deleted file mode 100644 index 8617d8d469866..0000000000000 --- a/xbmc/addons/interfaces/gui/Window.cpp +++ /dev/null @@ -1,1496 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "addons/kodi-dev-kit/include/kodi/gui/Window.h" - -#include "Application.h" -#include "FileItem.h" -#include "GUITranslator.h" -#include "General.h" -#include "ServiceBroker.h" -#include "Window.h" -#include "addons/Skin.h" -#include "addons/binary-addons/AddonDll.h" -#include "controls/Rendering.h" -#include "filesystem/File.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUIRenderingControl.h" -#include "guilib/GUIWindowManager.h" -#include "guilib/TextureManager.h" -#include "input/Key.h" -#include "messaging/ApplicationMessenger.h" -#include "utils/StringUtils.h" -#include "utils/URIUtils.h" -#include "utils/Variant.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIWindow::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->window = new AddonToKodiFuncTable_kodi_gui_window(); - - /* Window creation functions */ - addonInterface->toKodi->kodi_gui->window->create = create; - addonInterface->toKodi->kodi_gui->window->destroy = destroy; - addonInterface->toKodi->kodi_gui->window->set_callbacks = set_callbacks; - addonInterface->toKodi->kodi_gui->window->show = show; - addonInterface->toKodi->kodi_gui->window->close = close; - addonInterface->toKodi->kodi_gui->window->do_modal = do_modal; - - /* Window control functions */ - addonInterface->toKodi->kodi_gui->window->set_focus_id = set_focus_id; - addonInterface->toKodi->kodi_gui->window->get_focus_id = get_focus_id; - addonInterface->toKodi->kodi_gui->window->set_control_label = set_control_label; - addonInterface->toKodi->kodi_gui->window->set_control_visible = set_control_visible; - addonInterface->toKodi->kodi_gui->window->set_control_selected = set_control_selected; - - /* Window property functions */ - addonInterface->toKodi->kodi_gui->window->set_property = set_property; - addonInterface->toKodi->kodi_gui->window->set_property_int = set_property_int; - addonInterface->toKodi->kodi_gui->window->set_property_bool = set_property_bool; - addonInterface->toKodi->kodi_gui->window->set_property_double = set_property_double; - addonInterface->toKodi->kodi_gui->window->get_property = get_property; - addonInterface->toKodi->kodi_gui->window->get_property_int = get_property_int; - addonInterface->toKodi->kodi_gui->window->get_property_bool = get_property_bool; - addonInterface->toKodi->kodi_gui->window->get_property_double = get_property_double; - addonInterface->toKodi->kodi_gui->window->clear_properties = clear_properties; - addonInterface->toKodi->kodi_gui->window->clear_property = clear_property; - - /* List item functions */ - addonInterface->toKodi->kodi_gui->window->clear_item_list = clear_item_list; - addonInterface->toKodi->kodi_gui->window->add_list_item = add_list_item; - addonInterface->toKodi->kodi_gui->window->remove_list_item_from_position = - remove_list_item_from_position; - addonInterface->toKodi->kodi_gui->window->remove_list_item = remove_list_item; - addonInterface->toKodi->kodi_gui->window->get_list_item = get_list_item; - addonInterface->toKodi->kodi_gui->window->set_current_list_position = set_current_list_position; - addonInterface->toKodi->kodi_gui->window->get_current_list_position = get_current_list_position; - addonInterface->toKodi->kodi_gui->window->get_list_size = get_list_size; - addonInterface->toKodi->kodi_gui->window->set_container_property = set_container_property; - addonInterface->toKodi->kodi_gui->window->set_container_content = set_container_content; - addonInterface->toKodi->kodi_gui->window->get_current_container_id = get_current_container_id; - - /* Various functions */ - addonInterface->toKodi->kodi_gui->window->mark_dirty_region = mark_dirty_region; - - /* GUI control access functions */ - addonInterface->toKodi->kodi_gui->window->get_control_button = get_control_button; - addonInterface->toKodi->kodi_gui->window->get_control_edit = get_control_edit; - addonInterface->toKodi->kodi_gui->window->get_control_fade_label = get_control_fade_label; - addonInterface->toKodi->kodi_gui->window->get_control_image = get_control_image; - addonInterface->toKodi->kodi_gui->window->get_control_label = get_control_label; - addonInterface->toKodi->kodi_gui->window->get_control_progress = get_control_progress; - addonInterface->toKodi->kodi_gui->window->get_control_radio_button = get_control_radio_button; - addonInterface->toKodi->kodi_gui->window->get_control_render_addon = get_control_render_addon; - addonInterface->toKodi->kodi_gui->window->get_control_settings_slider = - get_control_settings_slider; - addonInterface->toKodi->kodi_gui->window->get_control_slider = get_control_slider; - addonInterface->toKodi->kodi_gui->window->get_control_spin = get_control_spin; - addonInterface->toKodi->kodi_gui->window->get_control_text_box = get_control_text_box; -} - -void Interface_GUIWindow::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->window; -} - -/*! - * Window creation functions - */ -//@{ -KODI_GUI_WINDOW_HANDLE Interface_GUIWindow::create(KODI_HANDLE kodiBase, - const char* xml_filename, - const char* default_skin, - bool as_dialog, - bool is_media) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon || !xml_filename || !default_skin) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (xml_filename='{}', " - "default_skin='{}') on addon '{}'", - __func__, static_cast(xml_filename), - static_cast(default_skin), addon ? addon->ID() : "unknown"); - return nullptr; - } - - if (as_dialog && is_media) - { - CLog::Log(LOGWARNING, - "Interface_GUIWindow::{}: {}/{} - addon tries to create dialog as media window who " - "not allowed, contact Developer '{}' of this addon", - __func__, CAddonInfo::TranslateType(addon->Type()), addon->Name(), addon->Author()); - } - - RESOLUTION_INFO res; - std::string strSkinPath = g_SkinInfo->GetSkinPath(xml_filename, &res); - - if (!XFILE::CFile::Exists(strSkinPath)) - { - std::string str("none"); - ADDON::AddonInfoPtr addonInfo = std::make_shared(str, ADDON::ADDON_SKIN); - - // Check for the matching folder for the skin in the fallback skins folder - std::string fallbackPath = URIUtils::AddFileToFolder(addon->Path(), "resources", "skins"); - std::string basePath = URIUtils::AddFileToFolder(fallbackPath, g_SkinInfo->ID()); - - strSkinPath = g_SkinInfo->GetSkinPath(xml_filename, &res, basePath); - - // Check for the matching folder for the skin in the fallback skins folder (if it exists) - if (XFILE::CFile::Exists(basePath)) - { - addonInfo->SetPath(basePath); - const std::shared_ptr skinInfo = - std::make_shared(addonInfo, res); - skinInfo->Start(); - strSkinPath = skinInfo->GetSkinPath(xml_filename, &res); - } - - if (!XFILE::CFile::Exists(strSkinPath)) - { - // Finally fallback to the DefaultSkin as it didn't exist in either the Kodi Skin folder or the fallback skin folder - addonInfo->SetPath(URIUtils::AddFileToFolder(fallbackPath, default_skin)); - const std::shared_ptr skinInfo = - std::make_shared(addonInfo, res); - - skinInfo->Start(); - strSkinPath = skinInfo->GetSkinPath(xml_filename, &res); - if (!XFILE::CFile::Exists(strSkinPath)) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{}: {}/{} - XML File '{}' for Window is missing, contact " - "Developer '{}' of this addon", - __func__, CAddonInfo::TranslateType(addon->Type()), addon->Name(), strSkinPath, - addon->Author()); - return nullptr; - } - } - } - - int id = GetNextAvailableWindowId(); - if (id < 0) - return nullptr; - - CGUIWindow* window; - if (!as_dialog) - window = new CGUIAddonWindow(id, strSkinPath, addon, is_media); - else - window = new CGUIAddonWindowDialog(id, strSkinPath, addon); - - Interface_GUIGeneral::lock(); - CServiceBroker::GetGUI()->GetWindowManager().Add(window); - Interface_GUIGeneral::unlock(); - - if (!CServiceBroker::GetGUI()->GetWindowManager().GetWindow(id)) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - Requested window id '{}' does not exist for addon '{}'", - __func__, id, addon->ID()); - delete window; - return nullptr; - } - window->SetCoordsRes(res); - return window; -} - -void Interface_GUIWindow::destroy(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - CGUIWindow* pWindow = - CServiceBroker::GetGUI()->GetWindowManager().GetWindow(pAddonWindow->GetID()); - if (pWindow) - { - // first change to an existing window - if (CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == pAddonWindow->GetID() && - !g_application.m_bStop) - { - if (CServiceBroker::GetGUI()->GetWindowManager().GetWindow(pAddonWindow->m_oldWindowId)) - CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->m_oldWindowId); - else // old window does not exist anymore, switch to home - CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_HOME); - } - // Free any window properties - pAddonWindow->ClearProperties(); - // free the window's resources and unload it (free all guicontrols) - pAddonWindow->FreeResources(true); - - CServiceBroker::GetGUI()->GetWindowManager().Remove(pAddonWindow->GetID()); - } - delete pAddonWindow; - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::set_callbacks( - KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - KODI_GUI_CLIENT_HANDLE clienthandle, - bool (*CBOnInit)(KODI_GUI_CLIENT_HANDLE), - bool (*CBOnFocus)(KODI_GUI_CLIENT_HANDLE, int), - bool (*CBOnClick)(KODI_GUI_CLIENT_HANDLE, int), - bool (*CBOnAction)(KODI_GUI_CLIENT_HANDLE, ADDON_ACTION), - void (*CBGetContextButtons)(KODI_GUI_CLIENT_HANDLE, int, gui_context_menu_pair*, unsigned int*), - bool (*CBOnContextButton)(KODI_GUI_CLIENT_HANDLE, int, unsigned int)) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !clienthandle) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (handle='{}', clienthandle='{}') " - "on addon '{}'", - __func__, handle, clienthandle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - pAddonWindow->m_clientHandle = clienthandle; - pAddonWindow->CBOnInit = CBOnInit; - pAddonWindow->CBOnClick = CBOnClick; - pAddonWindow->CBOnFocus = CBOnFocus; - pAddonWindow->CBOnAction = CBOnAction; - pAddonWindow->CBGetContextButtons = CBGetContextButtons; - pAddonWindow->CBOnContextButton = CBOnContextButton; - Interface_GUIGeneral::unlock(); -} - -bool Interface_GUIWindow::show(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon ? addon->ID() : "unknown"); - return false; - } - - if (pAddonWindow->m_oldWindowId != pAddonWindow->m_windowId && - pAddonWindow->m_windowId != CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow()) - pAddonWindow->m_oldWindowId = CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(); - - Interface_GUIGeneral::lock(); - if (pAddonWindow->IsDialog()) - dynamic_cast(pAddonWindow)->Show(true, false); - else - CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->GetID()); - Interface_GUIGeneral::unlock(); - - return true; -} - -bool Interface_GUIWindow::close(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon ? addon->ID() : "unknown"); - return false; - } - - pAddonWindow->PulseActionEvent(); - - Interface_GUIGeneral::lock(); - - // if it's a dialog, we have to close it a bit different - if (pAddonWindow->IsDialog()) - dynamic_cast(pAddonWindow)->Show(false); - else - CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->m_oldWindowId); - pAddonWindow->m_oldWindowId = 0; - - Interface_GUIGeneral::unlock(); - - return true; -} - -bool Interface_GUIWindow::do_modal(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon ? addon->ID() : "unknown"); - return false; - } - - if (pAddonWindow->GetID() == CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow()) - return true; - - if (pAddonWindow->m_oldWindowId != pAddonWindow->m_windowId && - pAddonWindow->m_windowId != CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow()) - pAddonWindow->m_oldWindowId = CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow(); - - Interface_GUIGeneral::lock(); - if (pAddonWindow->IsDialog()) - dynamic_cast(pAddonWindow)->Show(true, true); - else - CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(pAddonWindow->GetID()); - Interface_GUIGeneral::unlock(); - - return true; -} -//@} - -/*! - * Window control functions - */ -//@{ -bool Interface_GUIWindow::set_focus_id(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return false; - } - - if (!pAddonWindow->GetControl(control_id)) - { - CLog::Log(LOGERROR, "Interface_GUIWindow - {}: {} - Control does not exist in window", __func__, - addon->Name()); - return false; - } - - Interface_GUIGeneral::lock(); - CGUIMessage msg(GUI_MSG_SETFOCUS, pAddonWindow->m_windowId, control_id); - pAddonWindow->OnMessage(msg); - Interface_GUIGeneral::unlock(); - - return true; -} - -int Interface_GUIWindow::get_focus_id(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return -1; - } - - Interface_GUIGeneral::lock(); - int control_id = pAddonWindow->GetFocusedControlID(); - Interface_GUIGeneral::unlock(); - - if (control_id == -1) - CLog::Log(LOGERROR, "Interface_GUIWindow - {}: {} - No control in this window has focus", - __func__, addon->Name()); - - return control_id; -} - -void Interface_GUIWindow::set_control_label(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - const char* label) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - CGUIMessage msg(GUI_MSG_LABEL_SET, pAddonWindow->m_windowId, control_id); - msg.SetLabel(label); - pAddonWindow->OnMessage(msg); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::set_control_visible(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - CGUIMessage msg(visible ? GUI_MSG_VISIBLE : GUI_MSG_HIDDEN, pAddonWindow->m_windowId, control_id); - pAddonWindow->OnMessage(msg); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::set_control_selected(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - bool selected) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - CGUIMessage msg(selected ? GUI_MSG_SET_SELECTED : GUI_MSG_SET_DESELECTED, - pAddonWindow->m_windowId, control_id); - pAddonWindow->OnMessage(msg); - Interface_GUIGeneral::unlock(); -} -//@} - -/*! - * Window property functions - */ -//@{ -void Interface_GUIWindow::set_property(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - const char* value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !key || !value) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}', value='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - static_cast(value), addon ? addon->ID() : "unknown"); - return; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - pAddonWindow->SetProperty(lowerKey, value); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::set_property_int(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - int value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !key) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - addon ? addon->ID() : "unknown"); - return; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - pAddonWindow->SetProperty(lowerKey, value); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::set_property_bool(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - bool value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !key) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - addon ? addon->ID() : "unknown"); - return; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - pAddonWindow->SetProperty(lowerKey, value); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::set_property_double(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - double value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !key) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - addon ? addon->ID() : "unknown"); - return; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - pAddonWindow->SetProperty(lowerKey, value); - Interface_GUIGeneral::unlock(); -} - -char* Interface_GUIWindow::get_property(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !key) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - addon ? addon->ID() : "unknown"); - return nullptr; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - std::string value = pAddonWindow->GetProperty(lowerKey).asString(); - Interface_GUIGeneral::unlock(); - - return strdup(value.c_str()); -} - -int Interface_GUIWindow::get_property_int(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !key) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - addon ? addon->ID() : "unknown"); - return -1; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - int value = static_cast(pAddonWindow->GetProperty(lowerKey).asInteger()); - Interface_GUIGeneral::unlock(); - - return value; -} - -bool Interface_GUIWindow::get_property_bool(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !key) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - addon ? addon->ID() : "unknown"); - return false; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - bool value = pAddonWindow->GetProperty(lowerKey).asBoolean(); - Interface_GUIGeneral::unlock(); - - return value; -} - -double Interface_GUIWindow::get_property_double(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !key) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - addon ? addon->ID() : "unknown"); - return 0.0; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - double value = pAddonWindow->GetProperty(lowerKey).asDouble(); - Interface_GUIGeneral::unlock(); - - return value; -} - -void Interface_GUIWindow::clear_properties(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - pAddonWindow->ClearProperties(); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::clear_property(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !key) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - addon ? addon->ID() : "unknown"); - return; - } - - std::string lowerKey = key; - StringUtils::ToLower(lowerKey); - - Interface_GUIGeneral::lock(); - pAddonWindow->SetProperty(lowerKey, ""); - Interface_GUIGeneral::unlock(); -} -//@} - -/*! - * List item functions - */ -//@{ -void Interface_GUIWindow::clear_item_list(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - pAddonWindow->ClearList(); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::add_list_item(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - KODI_GUI_LISTITEM_HANDLE item, - int list_position) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !item) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "item='{}') on addon '{}'", - __func__, kodiBase, handle, item, addon ? addon->ID() : "unknown"); - return; - } - - CFileItemPtr* pItem(static_cast(item)); - if (pItem->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIWindow::{} - empty list item called on addon '{}'", __func__, - addon->ID()); - return; - } - - Interface_GUIGeneral::lock(); - pAddonWindow->AddItem(pItem, list_position); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::remove_list_item_from_position(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int list_position) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - pAddonWindow->RemoveItem(list_position); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::remove_list_item(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - KODI_GUI_LISTITEM_HANDLE item) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !item) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "item='{}') on addon '{}'", - __func__, kodiBase, handle, item, addon ? addon->ID() : "unknown"); - return; - } - - CFileItemPtr* pItem(static_cast(item)); - if (pItem->get() == nullptr) - { - CLog::Log(LOGERROR, "Interface_GUIWindow::{} - empty list item called on addon '{}'", __func__, - addon->ID()); - return; - } - - Interface_GUIGeneral::lock(); - pAddonWindow->RemoveItem(pItem); - Interface_GUIGeneral::unlock(); -} - -KODI_GUI_LISTITEM_HANDLE Interface_GUIWindow::get_list_item(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int list_position) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - Interface_GUIGeneral::lock(); - CFileItemPtr* pItem(pAddonWindow->GetListItem(list_position)); - if (pItem == nullptr || pItem->get() == nullptr) - { - CLog::Log(LOGERROR, "ADDON::Interface_GUIWindow - {}: {} - Index out of range", __func__, - addon->Name()); - - if (pItem) - { - delete pItem; - pItem = nullptr; - } - } - Interface_GUIGeneral::unlock(); - - return pItem; -} - -void Interface_GUIWindow::set_current_list_position(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int list_position) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - pAddonWindow->SetCurrentListPosition(list_position); - Interface_GUIGeneral::unlock(); -} - -int Interface_GUIWindow::get_current_list_position(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return -1; - } - - Interface_GUIGeneral::lock(); - int listPos = pAddonWindow->GetCurrentListPosition(); - Interface_GUIGeneral::unlock(); - - return listPos; -} - -int Interface_GUIWindow::get_list_size(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return -1; - } - - Interface_GUIGeneral::lock(); - int listSize = pAddonWindow->GetListSize(); - Interface_GUIGeneral::unlock(); - - return listSize; -} - -void Interface_GUIWindow::set_container_property(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - const char* value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !key || !value) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "key='{}', value='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(key), - static_cast(value), addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - pAddonWindow->SetContainerProperty(key, value); - Interface_GUIGeneral::unlock(); -} - -void Interface_GUIWindow::set_container_content(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow || !value) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}', " - "value='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(value), - addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - pAddonWindow->SetContainerContent(value); - Interface_GUIGeneral::unlock(); -} - -int Interface_GUIWindow::get_current_container_id(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return -1; - } - - Interface_GUIGeneral::lock(); - int id = pAddonWindow->GetCurrentContainerControlId(); - Interface_GUIGeneral::unlock(); - - return id; -} -//@} - -/*! - * Various functions - */ -//@{ -void Interface_GUIWindow::mark_dirty_region(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - pAddonWindow->MarkDirtyRegion(); - Interface_GUIGeneral::unlock(); -} -//@} - -/*! - * GUI control access functions - */ -//@{ -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_button(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_BUTTON, - "button"); -} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_edit(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_EDIT, "edit"); -} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_fade_label(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_FADELABEL, - "fade label"); -} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_image(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_IMAGE, "image"); -} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_label(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_LABEL, "label"); -} -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_progress(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_PROGRESS, - "progress"); -} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_radio_button(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_RADIO, - "radio button"); -} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_render_addon(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - CGUIControl* pGUIControl = static_cast(GetControl( - kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_RENDERADDON, "renderaddon")); - if (!pGUIControl) - return nullptr; - - CGUIAddonRenderingControl* pRenderControl = - new CGUIAddonRenderingControl(dynamic_cast(pGUIControl)); - return pRenderControl; -} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_settings_slider( - KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_SETTINGS_SLIDER, - "settings slider"); -} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_slider(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_SLIDER, - "slider"); -} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_spin(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_SPINEX, "spin"); -} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::get_control_text_box(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id) -{ - return GetControl(kodiBase, handle, control_id, __func__, CGUIControl::GUICONTROL_TEXTBOX, - "textbox"); -} -//@} - -KODI_GUI_CONTROL_HANDLE Interface_GUIWindow::GetControl(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - const char* function, - CGUIControl::GUICONTROLTYPES type, - const std::string& typeName) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonWindow* pAddonWindow = static_cast(handle); - if (!addon || !pAddonWindow) - { - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - invalid handler data (kodiBase='{}', handle='{}') on " - "addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - return pAddonWindow->GetAddonControl(control_id, type, typeName); -} - -int Interface_GUIWindow::GetNextAvailableWindowId() -{ - Interface_GUIGeneral::lock(); - - // if window WINDOW_ADDON_END is in use it means addon can't create more windows - if (CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_ADDON_END)) - { - Interface_GUIGeneral::unlock(); - CLog::Log(LOGERROR, - "Interface_GUIWindow::{} - Maximum number of windows for binary addons reached", - __func__); - return -1; - } - - // window id's WINDOW_ADDON_START - WINDOW_ADDON_END are reserved for addons - // get first window id that is not in use - int id = WINDOW_ADDON_START; - while (id < WINDOW_ADDON_END && - CServiceBroker::GetGUI()->GetWindowManager().GetWindow(id) != nullptr) - id++; - - Interface_GUIGeneral::unlock(); - return id; -} - -CGUIAddonWindow::CGUIAddonWindow(int id, const std::string& strXML, CAddonDll* addon, bool isMedia) - : CGUIMediaWindow(id, strXML.c_str()), - m_clientHandle{nullptr}, - CBOnInit{nullptr}, - CBOnFocus{nullptr}, - CBOnClick{nullptr}, - CBOnAction{nullptr}, - CBGetContextButtons{nullptr}, - CBOnContextButton{nullptr}, - m_windowId(id), - m_oldWindowId(0), - m_actionEvent(true), - m_addon(addon), - m_isMedia(isMedia) -{ - m_loadType = LOAD_ON_GUI_INIT; -} - -CGUIControl* CGUIAddonWindow::GetAddonControl(int controlId, - CGUIControl::GUICONTROLTYPES type, - const std::string& typeName) -{ - // Load window resources, if not already done, to have related xml content - // present and to let control find it - if (!m_windowLoaded) - { - if (!Initialize()) - { - CLog::Log(LOGERROR, - "CGUIAddonGUI_Window::{}: {} - Window initialize failed by control id '{}' request " - "for '{}'", - __func__, m_addon->Name(), controlId, typeName); - return nullptr; - } - } - - CGUIControl* pGUIControl = GetControl(controlId); - if (!pGUIControl) - { - CLog::Log(LOGERROR, - "CGUIAddonGUI_Window::{}: {} - Requested GUI control Id '{}' for '{}' not present!", - __func__, m_addon->Name(), controlId, typeName); - return nullptr; - } - else if (pGUIControl->GetControlType() != type) - { - CLog::Log(LOGERROR, - "CGUIAddonGUI_Window::{}: {} - Requested GUI control Id '{}' not the type '{}'!", - __func__, m_addon->Name(), controlId, typeName); - return nullptr; - } - - return pGUIControl; -} - -bool CGUIAddonWindow::OnAction(const CAction& action) -{ - // Let addon decide whether it wants to handle action first - if (CBOnAction && - CBOnAction(m_clientHandle, CAddonGUITranslator::TranslateActionIdToAddon(action.GetID()))) - return true; - - return CGUIWindow::OnAction(action); -} - -bool CGUIAddonWindow::OnMessage(CGUIMessage& message) -{ - switch (message.GetMessage()) - { - case GUI_MSG_WINDOW_DEINIT: - { - return CGUIMediaWindow::OnMessage(message); - } - break; - - case GUI_MSG_WINDOW_INIT: - { - CGUIMediaWindow::OnMessage(message); - - if (CBOnInit) - CBOnInit(m_clientHandle); - return true; - } - break; - - case GUI_MSG_FOCUSED: - { - if (m_viewControl.HasControl(message.GetControlId()) && - m_viewControl.GetCurrentControl() != message.GetControlId()) - { - m_viewControl.SetFocused(); - return true; - } - // check if our focused control is one of our category buttons - int iControl = message.GetControlId(); - if (CBOnFocus) - CBOnFocus(m_clientHandle, iControl); - } - break; - - case GUI_MSG_NOTIFY_ALL: - { - // most messages from GUI_MSG_NOTIFY_ALL break container content, whitelist working ones. - if (message.GetParam1() == GUI_MSG_PAGE_CHANGE || - message.GetParam1() == GUI_MSG_WINDOW_RESIZE) - return CGUIMediaWindow::OnMessage(message); - return true; - } - - case GUI_MSG_CLICKED: - { - int iControl = message.GetSenderId(); - if (iControl && iControl != this->GetID()) - { - CGUIControl* controlClicked = this->GetControl(iControl); - - // The old python way used to check list AND SELECITEM method or if its a button, checkmark. - // Its done this way for now to allow other controls without a python version like togglebutton to still raise a onAction event - if (controlClicked) // Will get problems if we the id is not on the window and we try to do GetControlType on it. So check to make sure it exists - { - if ((controlClicked->IsContainer() && (message.GetParam1() == ACTION_SELECT_ITEM || - message.GetParam1() == ACTION_MOUSE_LEFT_CLICK)) || - !controlClicked->IsContainer()) - { - if (CBOnClick) - return CBOnClick(m_clientHandle, iControl); - } - else if (controlClicked->IsContainer() && - (message.GetParam1() == ACTION_MOUSE_RIGHT_CLICK || - message.GetParam1() == ACTION_CONTEXT_MENU)) - { - if (CBOnAction) - { - // Check addon want to handle right click for a context menu, if - // not used from addon becomes "GetContextButtons(...)" called. - if (CBOnAction(m_clientHandle, ADDON_ACTION_CONTEXT_MENU)) - return true; - } - } - } - } - } - break; - } - - return CGUIMediaWindow::OnMessage(message); -} - -void CGUIAddonWindow::AllocResources(bool forceLoad /*= false */) -{ - std::string tmpDir = URIUtils::GetDirectory(GetProperty("xmlfile").asString()); - std::string fallbackMediaPath; - URIUtils::GetParentPath(tmpDir, fallbackMediaPath); - URIUtils::RemoveSlashAtEnd(fallbackMediaPath); - m_mediaDir = fallbackMediaPath; - - CServiceBroker::GetGUI()->GetTextureManager().AddTexturePath(m_mediaDir); - CGUIMediaWindow::AllocResources(forceLoad); - CServiceBroker::GetGUI()->GetTextureManager().RemoveTexturePath(m_mediaDir); -} - -void CGUIAddonWindow::Render() -{ - CServiceBroker::GetGUI()->GetTextureManager().AddTexturePath(m_mediaDir); - CGUIMediaWindow::Render(); - CServiceBroker::GetGUI()->GetTextureManager().RemoveTexturePath(m_mediaDir); -} - -void CGUIAddonWindow::AddItem(CFileItemPtr* fileItem, int itemPosition) -{ - if (itemPosition == -1 || itemPosition > m_vecItems->Size()) - { - m_vecItems->Add(*fileItem); - } - else if (itemPosition < -1 && !(itemPosition - 1 < m_vecItems->Size())) - { - m_vecItems->AddFront(*fileItem, 0); - } - else - { - m_vecItems->AddFront(*fileItem, itemPosition); - } - m_viewControl.SetItems(*m_vecItems); - UpdateButtons(); -} - -void CGUIAddonWindow::RemoveItem(int itemPosition) -{ - m_vecItems->Remove(itemPosition); - m_viewControl.SetItems(*m_vecItems); - UpdateButtons(); -} - -void CGUIAddonWindow::RemoveItem(CFileItemPtr* fileItem) -{ - m_vecItems->Remove(fileItem->get()); - m_viewControl.SetItems(*m_vecItems); - UpdateButtons(); -} - -int CGUIAddonWindow::GetCurrentListPosition() -{ - return m_viewControl.GetSelectedItem(); -} - -void CGUIAddonWindow::SetCurrentListPosition(int item) -{ - m_viewControl.SetSelectedItem(item); -} - -int CGUIAddonWindow::GetListSize() -{ - return m_vecItems->Size(); -} - -CFileItemPtr* CGUIAddonWindow::GetListItem(int position) -{ - if (position < 0 || position >= m_vecItems->Size()) - return nullptr; - return new CFileItemPtr(m_vecItems->Get(position)); -} - -void CGUIAddonWindow::ClearList() -{ - ClearFileItems(); - - m_viewControl.SetItems(*m_vecItems); - UpdateButtons(); -} - -void CGUIAddonWindow::SetContainerProperty(const std::string& key, const std::string& value) -{ - m_vecItems->SetProperty(key, value); -} - -void CGUIAddonWindow::SetContainerContent(const std::string& value) -{ - m_vecItems->SetContent(value); -} - -int CGUIAddonWindow::GetCurrentContainerControlId() -{ - return m_viewControl.GetCurrentControl(); -} - -void CGUIAddonWindow::GetContextButtons(int itemNumber, CContextButtons& buttons) -{ - gui_context_menu_pair c_buttons[ADDON_MAX_CONTEXT_ENTRIES] = {}; - unsigned int size = ADDON_MAX_CONTEXT_ENTRIES; - if (CBGetContextButtons) - { - CBGetContextButtons(m_clientHandle, itemNumber, c_buttons, &size); - for (unsigned int i = 0; i < size; ++i) - buttons.push_back(std::pair(c_buttons[i].id, c_buttons[i].name)); - } -} - -bool CGUIAddonWindow::OnContextButton(int itemNumber, CONTEXT_BUTTON button) -{ - if (CBOnContextButton) - return CBOnContextButton(m_clientHandle, itemNumber, static_cast(button)); - return false; -} - -void CGUIAddonWindow::WaitForActionEvent(unsigned int timeout) -{ - m_actionEvent.Wait(std::chrono::milliseconds(timeout)); - m_actionEvent.Reset(); -} - -void CGUIAddonWindow::PulseActionEvent() -{ - m_actionEvent.Set(); -} - -void CGUIAddonWindow::SetupShares() -{ - UpdateButtons(); -} - - -CGUIAddonWindowDialog::CGUIAddonWindowDialog(int id, const std::string& strXML, CAddonDll* addon) - : CGUIAddonWindow(id, strXML, addon, false), m_bRunning(false) -{ -} - -void CGUIAddonWindowDialog::Show(bool show /* = true */, bool modal /* = true*/) -{ - if (modal) - { - unsigned int count = CServiceBroker::GetWinSystem()->GetGfxContext().exit(); - CServiceBroker::GetAppMessenger()->SendMsg(TMSG_GUI_ADDON_DIALOG, 0, show ? 1 : 0, - static_cast(this)); - CServiceBroker::GetWinSystem()->GetGfxContext().restore(count); - } - else - CServiceBroker::GetAppMessenger()->PostMsg(TMSG_GUI_ADDON_DIALOG, 0, show ? 1 : 0, - static_cast(this)); -} - -void CGUIAddonWindowDialog::Show_Internal(bool show /* = true */) -{ - if (show) - { - m_bRunning = true; - CServiceBroker::GetGUI()->GetWindowManager().RegisterDialog(this); - - // activate this window... - CGUIMessage msg(GUI_MSG_WINDOW_INIT, 0, 0, WINDOW_INVALID, GetID()); - OnMessage(msg); - - // this dialog is derived from GUIMediaWindow - // make sure it is rendered last - m_renderOrder = RENDER_ORDER_DIALOG; - while (m_bRunning) - { - if (!ProcessRenderLoop(false)) - break; - } - } - else // hide - { - m_bRunning = false; - - CGUIMessage msg(GUI_MSG_WINDOW_DEINIT, 0, 0); - OnMessage(msg); - - CServiceBroker::GetGUI()->GetWindowManager().RemoveDialog(GetID()); - } -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/Window.h b/xbmc/addons/interfaces/gui/Window.h deleted file mode 100644 index dad0737cb7478..0000000000000 --- a/xbmc/addons/interfaces/gui/Window.h +++ /dev/null @@ -1,278 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/window.h" -#include "threads/Event.h" -#include "windows/GUIMediaWindow.h" - -extern "C" -{ - - struct AddonGlobalInterface; - struct gui_context_menu_pair; - - namespace ADDON - { - class CAddonDll; - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/Window.h" - */ - struct Interface_GUIWindow - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - /* Window creation functions */ - static KODI_GUI_WINDOW_HANDLE create(KODI_HANDLE kodiBase, - const char* xml_filename, - const char* default_skin, - bool as_dialog, - bool is_media); - static void destroy(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - static void set_callbacks(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - KODI_GUI_CLIENT_HANDLE clienthandle, - bool (*CBInit)(KODI_GUI_CLIENT_HANDLE), - bool (*CBFocus)(KODI_GUI_CLIENT_HANDLE, int), - bool (*CBClick)(KODI_GUI_CLIENT_HANDLE, int), - bool (*CBOnAction)(KODI_GUI_CLIENT_HANDLE, ADDON_ACTION), - void (*CBGetContextButtons)(KODI_GUI_CLIENT_HANDLE, - int, - gui_context_menu_pair*, - unsigned int*), - bool (*CBOnContextButton)(KODI_GUI_CLIENT_HANDLE, int, unsigned int)); - static bool show(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - static bool close(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - static bool do_modal(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - - /* Window control functions */ - static bool set_focus_id(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - static int get_focus_id(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - static void set_control_label(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - const char* label); - static void set_control_visible(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - bool visible); - static void set_control_selected(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - bool selected); - - /* Window property functions */ - static void set_property(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - const char* value); - static void set_property_int(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - int value); - static void set_property_bool(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - bool value); - static void set_property_double(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - double value); - static char* get_property(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, const char* key); - static int get_property_int(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key); - static bool get_property_bool(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key); - static double get_property_double(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key); - static void clear_properties(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - static void clear_property(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key); - - /* List item functions */ - static void clear_item_list(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - static void add_list_item(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - KODI_GUI_LISTITEM_HANDLE item, - int list_position); - static void remove_list_item_from_position(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int list_position); - static void remove_list_item(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - KODI_GUI_LISTITEM_HANDLE item); - static KODI_GUI_LISTITEM_HANDLE get_list_item(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int list_position); - static void set_current_list_position(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int list_position); - static int get_current_list_position(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - static int get_list_size(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - static void set_container_property(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - const char* value); - static void set_container_content(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* value); - static int get_current_container_id(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - - /* Various functions */ - static void mark_dirty_region(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - - /* GUI control access functions */ - static KODI_GUI_CONTROL_HANDLE get_control_button(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_edit(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_fade_label(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_image(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_label(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_radio_button(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_progress(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_render_addon(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_settings_slider(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_slider(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_spin(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - static KODI_GUI_CONTROL_HANDLE get_control_text_box(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id); - //@} - - private: - static KODI_GUI_CONTROL_HANDLE GetControl(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - const char* function, - CGUIControl::GUICONTROLTYPES type, - const std::string& typeName); - static int GetNextAvailableWindowId(); - }; - - class CGUIAddonWindow : public CGUIMediaWindow - { - friend struct Interface_GUIWindow; - - public: - CGUIAddonWindow(int id, const std::string& strXML, ADDON::CAddonDll* addon, bool isMedia); - ~CGUIAddonWindow() override = default; - - bool OnMessage(CGUIMessage& message) override; - bool OnAction(const CAction& action) override; - void AllocResources(bool forceLoad = false) override; - void Render() override; - bool IsMediaWindow() const override { return m_isMedia; } - - /* Addon to Kodi call functions */ - void PulseActionEvent(); - void AddItem(CFileItemPtr* fileItem, int itemPosition); - void RemoveItem(int itemPosition); - void RemoveItem(CFileItemPtr* fileItem); - void ClearList(); - CFileItemPtr* GetListItem(int position); - int GetListSize(); - int GetCurrentListPosition(); - void SetCurrentListPosition(int item); - void SetContainerProperty(const std::string& key, const std::string& value); - void SetContainerContent(const std::string& value); - int GetCurrentContainerControlId(); - CGUIControl* GetAddonControl(int controlId, - CGUIControl::GUICONTROLTYPES type, - const std::string& typeName); - - protected: - void GetContextButtons(int itemNumber, CContextButtons& buttons) override; - bool OnContextButton(int itemNumber, CONTEXT_BUTTON button) override; - void SetupShares() override; - - /* kodi to addon callback function addresses */ - KODI_GUI_CLIENT_HANDLE m_clientHandle; - bool (*CBOnInit)(KODI_GUI_CLIENT_HANDLE cbhdl); - bool (*CBOnFocus)(KODI_GUI_CLIENT_HANDLE cbhdl, int controlId); - bool (*CBOnClick)(KODI_GUI_CLIENT_HANDLE cbhdl, int controlId); - bool (*CBOnAction)(KODI_GUI_CLIENT_HANDLE cbhdl, ADDON_ACTION actionId); - void (*CBGetContextButtons)(KODI_GUI_CLIENT_HANDLE cbhdl, - int itemNumber, - gui_context_menu_pair* buttons, - unsigned int* size); - bool (*CBOnContextButton)(KODI_GUI_CLIENT_HANDLE cbhdl, int itemNumber, unsigned int button); - - const int m_windowId; - int m_oldWindowId; - - private: - void WaitForActionEvent(unsigned int timeout); - - CEvent m_actionEvent; - ADDON::CAddonDll* m_addon; - std::string m_mediaDir; - bool m_isMedia; - }; - - class CGUIAddonWindowDialog : public CGUIAddonWindow - { - public: - CGUIAddonWindowDialog(int id, const std::string& strXML, ADDON::CAddonDll* addon); - - bool IsDialogRunning() const override { return m_bRunning; } - bool IsDialog() const override { return true; } - bool IsModalDialog() const override { return true; } - - void Show(bool show = true, bool modal = true); - void Show_Internal(bool show = true); - - private: - bool m_bRunning; - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/Button.cpp b/xbmc/addons/interfaces/gui/controls/Button.cpp deleted file mode 100644 index 24a99946b04fe..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Button.cpp +++ /dev/null @@ -1,146 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Button.h" - -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/Button.h" -#include "guilib/GUIButtonControl.h" -#include "utils/StringUtils.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlButton::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_button = - new AddonToKodiFuncTable_kodi_gui_control_button(); - - addonInterface->toKodi->kodi_gui->control_button->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_button->set_enabled = set_enabled; - - addonInterface->toKodi->kodi_gui->control_button->set_label = set_label; - addonInterface->toKodi->kodi_gui->control_button->get_label = get_label; - - addonInterface->toKodi->kodi_gui->control_button->set_label2 = set_label2; - addonInterface->toKodi->kodi_gui->control_button->get_label2 = get_label2; -} - -void Interface_GUIControlButton::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_button; -} - -void Interface_GUIControlButton::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIButtonControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlButton::set_enabled(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool enabled) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIButtonControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetEnabled(enabled); -} - -void Interface_GUIControlButton::set_label(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIButtonControl* control = static_cast(handle); - if (!addon || !control || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}', " - "label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - addon ? addon->ID() : "unknown"); - return; - } - - control->SetLabel(label); -} - -char* Interface_GUIControlButton::get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIButtonControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - return strdup(control->GetLabel().c_str()); -} - -void Interface_GUIControlButton::set_label2(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIButtonControl* control = static_cast(handle); - if (!addon || !control || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}', " - "label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - addon ? addon->ID() : "unknown"); - return; - } - - control->SetLabel2(label); -} - -char* Interface_GUIControlButton::get_label2(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIButtonControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlButton::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - return strdup(control->GetLabel2().c_str()); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/Button.h b/xbmc/addons/interfaces/gui/controls/Button.h deleted file mode 100644 index 221ae4ea6641a..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Button.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/button.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Button.h" - */ - struct Interface_GUIControlButton - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - - static void set_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label); - static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - static void set_label2(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label); - static char* get_label2(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/CMakeLists.txt b/xbmc/addons/interfaces/gui/controls/CMakeLists.txt deleted file mode 100644 index 0a708c662ee91..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/CMakeLists.txt +++ /dev/null @@ -1,27 +0,0 @@ -set(SOURCES Button.cpp - Edit.cpp - FadeLabel.cpp - Image.cpp - Label.cpp - Progress.cpp - RadioButton.cpp - Rendering.cpp - SettingsSlider.cpp - Slider.cpp - Spin.cpp - TextBox.cpp) - -set(HEADERS Button.h - Edit.h - FadeLabel.h - Image.h - Label.h - Progress.h - RadioButton.h - Rendering.h - SettingsSlider.h - Slider.h - Spin.h - TextBox.h) - -core_add_library(addons_interfaces_gui_controls) diff --git a/xbmc/addons/interfaces/gui/controls/Edit.cpp b/xbmc/addons/interfaces/gui/controls/Edit.cpp deleted file mode 100644 index b537279764602..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Edit.cpp +++ /dev/null @@ -1,239 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Edit.h" - -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/Edit.h" -#include "guilib/GUIEditControl.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlEdit::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_edit = new AddonToKodiFuncTable_kodi_gui_control_edit(); - - addonInterface->toKodi->kodi_gui->control_edit->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_edit->set_enabled = set_enabled; - addonInterface->toKodi->kodi_gui->control_edit->set_input_type = set_input_type; - addonInterface->toKodi->kodi_gui->control_edit->set_label = set_label; - addonInterface->toKodi->kodi_gui->control_edit->get_label = get_label; - addonInterface->toKodi->kodi_gui->control_edit->set_text = set_text; - addonInterface->toKodi->kodi_gui->control_edit->get_text = get_text; - addonInterface->toKodi->kodi_gui->control_edit->set_cursor_position = set_cursor_position; - addonInterface->toKodi->kodi_gui->control_edit->get_cursor_position = get_cursor_position; -} - -void Interface_GUIControlEdit::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_edit; -} - -void Interface_GUIControlEdit::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIEditControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlEdit::set_enabled(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool enable) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIEditControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetEnabled(enable); -} - -void Interface_GUIControlEdit::set_input_type(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int type, - const char* heading) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIEditControl* control = static_cast(handle); - if (!addon || !control || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}', " - "heading='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(heading), - addon ? addon->ID() : "unknown"); - return; - } - - CGUIEditControl::INPUT_TYPE kodiType; - switch (static_cast(type)) - { - case ADDON_INPUT_TYPE_TEXT: - kodiType = CGUIEditControl::INPUT_TYPE_TEXT; - break; - case ADDON_INPUT_TYPE_NUMBER: - kodiType = CGUIEditControl::INPUT_TYPE_NUMBER; - break; - case ADDON_INPUT_TYPE_SECONDS: - kodiType = CGUIEditControl::INPUT_TYPE_SECONDS; - break; - case ADDON_INPUT_TYPE_TIME: - kodiType = CGUIEditControl::INPUT_TYPE_TIME; - break; - case ADDON_INPUT_TYPE_DATE: - kodiType = CGUIEditControl::INPUT_TYPE_DATE; - break; - case ADDON_INPUT_TYPE_IPADDRESS: - kodiType = CGUIEditControl::INPUT_TYPE_IPADDRESS; - break; - case ADDON_INPUT_TYPE_PASSWORD: - kodiType = CGUIEditControl::INPUT_TYPE_PASSWORD; - break; - case ADDON_INPUT_TYPE_PASSWORD_MD5: - kodiType = CGUIEditControl::INPUT_TYPE_PASSWORD_MD5; - break; - case ADDON_INPUT_TYPE_SEARCH: - kodiType = CGUIEditControl::INPUT_TYPE_SEARCH; - break; - case ADDON_INPUT_TYPE_FILTER: - kodiType = CGUIEditControl::INPUT_TYPE_FILTER; - break; - case ADDON_INPUT_TYPE_READONLY: - default: - kodiType = CGUIEditControl::INPUT_TYPE_PASSWORD_NUMBER_VERIFY_NEW; - } - - control->SetInputType(kodiType, heading); -} - -void Interface_GUIControlEdit::set_label(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIEditControl* control = static_cast(handle); - if (!addon || !control || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}', " - "label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - addon ? addon->ID() : "unknown"); - return; - } - - control->SetLabel(label); -} - -char* Interface_GUIControlEdit::get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIEditControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - return strdup(control->GetLabel().c_str()); -} - -void Interface_GUIControlEdit::set_text(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* text) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIEditControl* control = static_cast(handle); - if (!addon || !control || !text) - { - CLog::Log(LOGERROR, - "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}', " - "text='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(text), - addon ? addon->ID() : "unknown"); - return; - } - - control->SetLabel2(text); -} - -char* Interface_GUIControlEdit::get_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIEditControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - return strdup(control->GetLabel2().c_str()); -} - -void Interface_GUIControlEdit::set_cursor_position(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - unsigned int position) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIEditControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetCursorPosition(position); -} - -unsigned int Interface_GUIControlEdit::get_cursor_position(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIEditControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlEdit::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return 0; - } - - return control->GetCursorPosition(); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/Edit.h b/xbmc/addons/interfaces/gui/controls/Edit.h deleted file mode 100644 index 9dda1e2046681..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Edit.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/edit.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Edit.h" - */ - struct Interface_GUIControlEdit - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - - static void set_input_type(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int type, - const char* heading); - - static void set_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label); - static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - - static void set_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text); - static char* get_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - - static void set_cursor_position(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - unsigned int position); - static unsigned int get_cursor_position(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/FadeLabel.cpp b/xbmc/addons/interfaces/gui/controls/FadeLabel.cpp deleted file mode 100644 index 13c560442ce3b..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/FadeLabel.cpp +++ /dev/null @@ -1,130 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "FadeLabel.h" - -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/FadeLabel.h" -#include "guilib/GUIFadeLabelControl.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlFadeLabel::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_fade_label = - new AddonToKodiFuncTable_kodi_gui_control_fade_label(); - - addonInterface->toKodi->kodi_gui->control_fade_label->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_fade_label->add_label = add_label; - addonInterface->toKodi->kodi_gui->control_fade_label->get_label = get_label; - addonInterface->toKodi->kodi_gui->control_fade_label->set_scrolling = set_scrolling; - addonInterface->toKodi->kodi_gui->control_fade_label->reset = reset; -} - -void Interface_GUIControlFadeLabel::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_fade_label; -} - -void Interface_GUIControlFadeLabel::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIFadeLabelControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlFadeLabel::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlFadeLabel::add_label(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIFadeLabelControl* control = static_cast(handle); - if (!addon || !control || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIControlFadeLabel::{} - invalid handler data (kodiBase='{}', " - "handle='{}', label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - addon ? addon->ID() : "unknown"); - return; - } - - CGUIMessage msg(GUI_MSG_LABEL_ADD, control->GetParentID(), control->GetID()); - msg.SetLabel(label); - control->OnMessage(msg); -} - -char* Interface_GUIControlFadeLabel::get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIFadeLabelControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlFadeLabel::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - CGUIMessage msg(GUI_MSG_ITEM_SELECTED, control->GetParentID(), control->GetID()); - control->OnMessage(msg); - std::string text = msg.GetLabel(); - return strdup(text.c_str()); -} - -void Interface_GUIControlFadeLabel::set_scrolling(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool scroll) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIFadeLabelControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlFadeLabel::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetScrolling(scroll); -} - -void Interface_GUIControlFadeLabel::reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIFadeLabelControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlFadeLabel::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID()); - control->OnMessage(msg); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/FadeLabel.h b/xbmc/addons/interfaces/gui/controls/FadeLabel.h deleted file mode 100644 index 2c3cd6803735c..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/FadeLabel.h +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/fade_label.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/FadeLabel.h" - */ - struct Interface_GUIControlFadeLabel - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - static void set_selected(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool selected); - - static void add_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label); - static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - static void set_scrolling(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool scroll); - static void reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/Image.cpp b/xbmc/addons/interfaces/gui/controls/Image.cpp deleted file mode 100644 index 88f368c628a98..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Image.cpp +++ /dev/null @@ -1,92 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Image.h" - -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/Image.h" -#include "guilib/GUIImage.h" -#include "utils/log.h" - -using namespace KODI; - -namespace ADDON -{ - -void Interface_GUIControlImage::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_image = - new AddonToKodiFuncTable_kodi_gui_control_image(); - - addonInterface->toKodi->kodi_gui->control_image->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_image->set_filename = set_filename; - addonInterface->toKodi->kodi_gui->control_image->set_color_diffuse = set_color_diffuse; -} - -void Interface_GUIControlImage::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_image; -} - -void Interface_GUIControlImage::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIImage* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlImage::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlImage::set_filename(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* filename, - bool use_cache) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIImage* control = static_cast(handle); - if (!addon || !control || !filename) - { - CLog::Log(LOGERROR, - "Interface_GUIControlImage::{} - invalid handler data (kodiBase='{}', handle='{}', " - "filename='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(filename), - addon ? addon->ID() : "unknown"); - return; - } - - control->SetFileName(filename, false, use_cache); -} - -void Interface_GUIControlImage::set_color_diffuse(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - uint32_t colorDiffuse) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIImage* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlImage::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetColorDiffuse(GUILIB::GUIINFO::CGUIInfoColor(colorDiffuse)); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/Image.h b/xbmc/addons/interfaces/gui/controls/Image.h deleted file mode 100644 index b12becea3056d..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Image.h +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/image.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Image.h" - */ - struct Interface_GUIControlImage - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - static void set_filename(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* filename, - bool use_cache); - static void set_color_diffuse(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - uint32_t color_diffuse); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/Label.cpp b/xbmc/addons/interfaces/gui/controls/Label.cpp deleted file mode 100644 index 3922e3f81506e..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Label.cpp +++ /dev/null @@ -1,92 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Label.h" - -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/Label.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUILabelControl.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlLabel::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_label = - new AddonToKodiFuncTable_kodi_gui_control_label(); - - addonInterface->toKodi->kodi_gui->control_label->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_label->set_label = set_label; - addonInterface->toKodi->kodi_gui->control_label->get_label = get_label; -} - -void Interface_GUIControlLabel::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_label; -} - -void Interface_GUIControlLabel::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUILabelControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlLabel::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlLabel::set_label(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUILabelControl* control = static_cast(handle); - if (!addon || !control || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIControlLabel::{} - invalid handler data (kodiBase='{}', handle='{}', " - "label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - addon ? addon->ID() : "unknown"); - return; - } - - CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID()); - msg.SetLabel(label); - CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); -} - -char* Interface_GUIControlLabel::get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUILabelControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlLabel::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - return strdup(control->GetDescription().c_str()); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/Label.h b/xbmc/addons/interfaces/gui/controls/Label.h deleted file mode 100644 index 020c3d5d3ec90..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Label.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/label.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Label.h" - */ - struct Interface_GUIControlLabel - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - - static void set_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label); - static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/Progress.cpp b/xbmc/addons/interfaces/gui/controls/Progress.cpp deleted file mode 100644 index 639d079d4e813..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Progress.cpp +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Progress.h" - -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/Progress.h" -#include "guilib/GUIProgressControl.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlProgress::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_progress = - new AddonToKodiFuncTable_kodi_gui_control_progress(); - - addonInterface->toKodi->kodi_gui->control_progress->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_progress->set_percentage = set_percentage; - addonInterface->toKodi->kodi_gui->control_progress->get_percentage = get_percentage; -} - -void Interface_GUIControlProgress::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_progress; -} - -void Interface_GUIControlProgress::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIProgressControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlProgress::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlProgress::set_percentage(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float percent) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIProgressControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlProgress::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetPercentage(percent); -} - -float Interface_GUIControlProgress::get_percentage(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIProgressControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlProgress::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return 0.0f; - } - - return control->GetPercentage(); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/Progress.h b/xbmc/addons/interfaces/gui/controls/Progress.h deleted file mode 100644 index c3368fa105fc6..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Progress.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/progress.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Progress.h" - */ - struct Interface_GUIControlProgress - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - - static void set_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float percent); - static float get_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/RadioButton.cpp b/xbmc/addons/interfaces/gui/controls/RadioButton.cpp deleted file mode 100644 index 9d3b82619b368..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/RadioButton.cpp +++ /dev/null @@ -1,146 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "RadioButton.h" - -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/RadioButton.h" -#include "guilib/GUIRadioButtonControl.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlRadioButton::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_radio_button = - new AddonToKodiFuncTable_kodi_gui_control_radio_button(); - - addonInterface->toKodi->kodi_gui->control_radio_button->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_radio_button->set_enabled = set_enabled; - - addonInterface->toKodi->kodi_gui->control_radio_button->set_label = set_label; - addonInterface->toKodi->kodi_gui->control_radio_button->get_label = get_label; - - addonInterface->toKodi->kodi_gui->control_radio_button->set_selected = set_selected; - addonInterface->toKodi->kodi_gui->control_radio_button->is_selected = is_selected; -} - -void Interface_GUIControlRadioButton::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_radio_button; -} - -void Interface_GUIControlRadioButton::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIRadioButtonControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlRadioButton::set_enabled(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool enabled) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIRadioButtonControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetEnabled(enabled); -} - -void Interface_GUIControlRadioButton::set_label(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIRadioButtonControl* control = static_cast(handle); - if (!addon || !control || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', " - "handle='{}', label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - addon ? addon->ID() : "unknown"); - return; - } - - control->SetLabel(label); -} - -char* Interface_GUIControlRadioButton::get_label(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIRadioButtonControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - return strdup(control->GetLabel().c_str()); -} - -void Interface_GUIControlRadioButton::set_selected(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool selected) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIRadioButtonControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetSelected(selected); -} - -bool Interface_GUIControlRadioButton::is_selected(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIRadioButtonControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlRadioButton::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return false; - } - - return control->IsSelected(); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/RadioButton.h b/xbmc/addons/interfaces/gui/controls/RadioButton.h deleted file mode 100644 index dd7ed4e9e3aa9..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/RadioButton.h +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/radio_button.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/RadioButton.h" - */ - struct Interface_GUIControlRadioButton - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - - static void set_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label); - static char* get_label(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - - static void set_selected(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool selected); - static bool is_selected(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/Rendering.cpp b/xbmc/addons/interfaces/gui/controls/Rendering.cpp deleted file mode 100644 index a26a27f9c3aeb..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Rendering.cpp +++ /dev/null @@ -1,148 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Rendering.h" - -#include "addons/binary-addons/AddonDll.h" -#include "addons/interfaces/gui/General.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/Rendering.h" -#include "guilib/GUIRenderingControl.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlAddonRendering::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_rendering = - new AddonToKodiFuncTable_kodi_gui_control_rendering(); - - addonInterface->toKodi->kodi_gui->control_rendering->set_callbacks = set_callbacks; - addonInterface->toKodi->kodi_gui->control_rendering->destroy = destroy; -} - -void Interface_GUIControlAddonRendering::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_rendering; -} - -void Interface_GUIControlAddonRendering::set_callbacks( - KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - KODI_GUI_CLIENT_HANDLE clienthandle, - bool (*createCB)(KODI_GUI_CLIENT_HANDLE, int, int, int, int, ADDON_HARDWARE_CONTEXT), - void (*renderCB)(KODI_GUI_CLIENT_HANDLE), - void (*stopCB)(KODI_GUI_CLIENT_HANDLE), - bool (*dirtyCB)(KODI_GUI_CLIENT_HANDLE)) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonRenderingControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlAddonRendering::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - control->m_clientHandle = clienthandle; - control->CBCreate = createCB; - control->CBRender = renderCB; - control->CBStop = stopCB; - control->CBDirty = dirtyCB; - control->m_addon = addon; - Interface_GUIGeneral::unlock(); - - control->m_control->InitCallback(control); -} - -void Interface_GUIControlAddonRendering::destroy(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUIAddonRenderingControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlAddonRendering::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - Interface_GUIGeneral::lock(); - static_cast(handle)->Delete(); - Interface_GUIGeneral::unlock(); -} - - -CGUIAddonRenderingControl::CGUIAddonRenderingControl(CGUIRenderingControl* control) - : CBCreate{nullptr}, - CBRender{nullptr}, - CBStop{nullptr}, - CBDirty{nullptr}, - m_clientHandle{nullptr}, - m_addon{nullptr}, - m_control{control}, - m_refCount{1} -{ -} - -bool CGUIAddonRenderingControl::Create(int x, int y, int w, int h, void* device) -{ - if (CBCreate) - { - if (CBCreate(m_clientHandle, x, y, w, h, device)) - { - ++m_refCount; - return true; - } - } - return false; -} - -void CGUIAddonRenderingControl::Render() -{ - if (CBRender) - { - CBRender(m_clientHandle); - } -} - -void CGUIAddonRenderingControl::Stop() -{ - if (CBStop) - { - CBStop(m_clientHandle); - } - - --m_refCount; - if (m_refCount <= 0) - delete this; -} - -void CGUIAddonRenderingControl::Delete() -{ - --m_refCount; - if (m_refCount <= 0) - delete this; -} - -bool CGUIAddonRenderingControl::IsDirty() -{ - bool ret = true; - if (CBDirty) - { - ret = CBDirty(m_clientHandle); - } - return ret; -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/Rendering.h b/xbmc/addons/interfaces/gui/controls/Rendering.h deleted file mode 100644 index dbd82d86023b2..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Rendering.h +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/rendering.h" -#include "guilib/IRenderingCallback.h" - -class CGUIRenderingControl; - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - class CAddonDll; - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Rendering.h" - */ - struct Interface_GUIControlAddonRendering - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_callbacks( - KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - KODI_GUI_CLIENT_HANDLE clienthandle, - bool (*createCB)(KODI_GUI_CLIENT_HANDLE, int, int, int, int, ADDON_HARDWARE_CONTEXT), - void (*renderCB)(KODI_GUI_CLIENT_HANDLE), - void (*stopCB)(KODI_GUI_CLIENT_HANDLE), - bool (*dirtyCB)(KODI_GUI_CLIENT_HANDLE)); - static void destroy(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - //@} - }; - - class CGUIAddonRenderingControl : public IRenderingCallback - { - friend struct Interface_GUIControlAddonRendering; - - public: - explicit CGUIAddonRenderingControl(CGUIRenderingControl* pControl); - ~CGUIAddonRenderingControl() override = default; - - bool Create(int x, int y, int w, int h, void* device) override; - void Render() override; - void Stop() override; - bool IsDirty() override; - virtual void Delete(); - - protected: - bool (*CBCreate)(KODI_GUI_CLIENT_HANDLE cbhdl, int x, int y, int w, int h, void* device); - void (*CBRender)(KODI_GUI_CLIENT_HANDLE cbhdl); - void (*CBStop)(KODI_GUI_CLIENT_HANDLE cbhdl); - bool (*CBDirty)(KODI_GUI_CLIENT_HANDLE cbhdl); - - KODI_GUI_CLIENT_HANDLE m_clientHandle; - CAddonDll* m_addon; - CGUIRenderingControl* m_control; - int m_refCount; - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/SettingsSlider.cpp b/xbmc/addons/interfaces/gui/controls/SettingsSlider.cpp deleted file mode 100644 index c847a642dd94b..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/SettingsSlider.cpp +++ /dev/null @@ -1,311 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "SettingsSlider.h" - -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/SettingsSlider.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUISettingsSliderControl.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlSettingsSlider::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_settings_slider = - new AddonToKodiFuncTable_kodi_gui_control_settings_slider(); - - addonInterface->toKodi->kodi_gui->control_settings_slider->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_settings_slider->set_enabled = set_enabled; - - addonInterface->toKodi->kodi_gui->control_settings_slider->set_text = set_text; - addonInterface->toKodi->kodi_gui->control_settings_slider->reset = reset; - - addonInterface->toKodi->kodi_gui->control_settings_slider->set_int_range = set_int_range; - addonInterface->toKodi->kodi_gui->control_settings_slider->set_int_value = set_int_value; - addonInterface->toKodi->kodi_gui->control_settings_slider->get_int_value = get_int_value; - addonInterface->toKodi->kodi_gui->control_settings_slider->set_int_interval = set_int_interval; - - addonInterface->toKodi->kodi_gui->control_settings_slider->set_percentage = set_percentage; - addonInterface->toKodi->kodi_gui->control_settings_slider->get_percentage = get_percentage; - - addonInterface->toKodi->kodi_gui->control_settings_slider->set_float_range = set_float_range; - addonInterface->toKodi->kodi_gui->control_settings_slider->set_float_value = set_float_value; - addonInterface->toKodi->kodi_gui->control_settings_slider->get_float_value = get_float_value; - addonInterface->toKodi->kodi_gui->control_settings_slider->set_float_interval = - set_float_interval; -} - -void Interface_GUIControlSettingsSlider::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_settings_slider; -} - -void Interface_GUIControlSettingsSlider::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlSettingsSlider::set_enabled(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool enabled) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetEnabled(enabled); -} - -void Interface_GUIControlSettingsSlider::set_text(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* text) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control || !text) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}', text='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(text), - addon ? addon->ID() : "unknown"); - return; - } - - CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID()); - msg.SetLabel(text); - CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); -} - -void Interface_GUIControlSettingsSlider::reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID()); - CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); -} - -void Interface_GUIControlSettingsSlider::set_int_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int start, - int end) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(SLIDER_CONTROL_TYPE_INT); - control->SetRange(start, end); -} - -void Interface_GUIControlSettingsSlider::set_int_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(SLIDER_CONTROL_TYPE_INT); - control->SetIntValue(value); -} - -int Interface_GUIControlSettingsSlider::get_int_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return -1; - } - - return control->GetIntValue(); -} - -void Interface_GUIControlSettingsSlider::set_int_interval(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int interval) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetIntInterval(interval); -} - -void Interface_GUIControlSettingsSlider::set_percentage(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float percent) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(SLIDER_CONTROL_TYPE_PERCENTAGE); - control->SetPercentage(percent); -} - -float Interface_GUIControlSettingsSlider::get_percentage(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return 0.0f; - } - - return control->GetPercentage(); -} - -void Interface_GUIControlSettingsSlider::set_float_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float start, - float end) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(SLIDER_CONTROL_TYPE_FLOAT); - control->SetFloatRange(start, end); -} - -void Interface_GUIControlSettingsSlider::set_float_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(SLIDER_CONTROL_TYPE_FLOAT); - control->SetFloatValue(value); -} - -float Interface_GUIControlSettingsSlider::get_float_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return 0.0f; - } - - return control->GetFloatValue(); -} - -void Interface_GUIControlSettingsSlider::set_float_interval(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float interval) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISettingsSliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSettingsSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetFloatInterval(interval); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/SettingsSlider.h b/xbmc/addons/interfaces/gui/controls/SettingsSlider.h deleted file mode 100644 index 425c27564f181..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/SettingsSlider.h +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/settings_slider.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/SettingsSlider.h" - */ - struct Interface_GUIControlSettingsSlider - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - - static void set_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text); - static void reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - - static void set_int_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int start, - int end); - static void set_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int value); - static int get_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - static void set_int_interval(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int interval); - - static void set_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float percent); - static float get_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - - static void set_float_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float start, - float end); - static void set_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float value); - static float get_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - static void set_float_interval(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float interval); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/Slider.cpp b/xbmc/addons/interfaces/gui/controls/Slider.cpp deleted file mode 100644 index 73502d87e08ef..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Slider.cpp +++ /dev/null @@ -1,305 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Slider.h" - -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/Slider.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUISliderControl.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlSlider::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_slider = - new AddonToKodiFuncTable_kodi_gui_control_slider(); - - addonInterface->toKodi->kodi_gui->control_slider->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_slider->set_enabled = set_enabled; - - addonInterface->toKodi->kodi_gui->control_slider->reset = reset; - addonInterface->toKodi->kodi_gui->control_slider->get_description = get_description; - - addonInterface->toKodi->kodi_gui->control_slider->set_int_range = set_int_range; - addonInterface->toKodi->kodi_gui->control_slider->set_int_value = set_int_value; - addonInterface->toKodi->kodi_gui->control_slider->get_int_value = get_int_value; - addonInterface->toKodi->kodi_gui->control_slider->set_int_interval = set_int_interval; - - addonInterface->toKodi->kodi_gui->control_slider->set_percentage = set_percentage; - addonInterface->toKodi->kodi_gui->control_slider->get_percentage = get_percentage; - - addonInterface->toKodi->kodi_gui->control_slider->set_float_range = set_float_range; - addonInterface->toKodi->kodi_gui->control_slider->set_float_value = set_float_value; - addonInterface->toKodi->kodi_gui->control_slider->get_float_value = get_float_value; - addonInterface->toKodi->kodi_gui->control_slider->set_float_interval = set_float_interval; -} - -void Interface_GUIControlSlider::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_slider; -} - -void Interface_GUIControlSlider::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlSlider::set_enabled(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool enabled) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetEnabled(enabled); -} - -void Interface_GUIControlSlider::reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID()); - CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); -} - -char* Interface_GUIControlSlider::get_description(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - return strdup(control->GetDescription().c_str()); -} - -void Interface_GUIControlSlider::set_int_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int start, - int end) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(SLIDER_CONTROL_TYPE_INT); - control->SetRange(start, end); -} - -void Interface_GUIControlSlider::set_int_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(SLIDER_CONTROL_TYPE_INT); - control->SetIntValue(value); -} - -int Interface_GUIControlSlider::get_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return -1; - } - - return control->GetIntValue(); -} - -void Interface_GUIControlSlider::set_int_interval(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int interval) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetIntInterval(interval); -} - -void Interface_GUIControlSlider::set_percentage(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float percent) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(SLIDER_CONTROL_TYPE_PERCENTAGE); - control->SetPercentage(percent); -} - -float Interface_GUIControlSlider::get_percentage(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return 0.0f; - } - - return control->GetPercentage(); -} - -void Interface_GUIControlSlider::set_float_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float start, - float end) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(SLIDER_CONTROL_TYPE_FLOAT); - control->SetFloatRange(start, end); -} - -void Interface_GUIControlSlider::set_float_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(SLIDER_CONTROL_TYPE_FLOAT); - control->SetFloatValue(value); -} - -float Interface_GUIControlSlider::get_float_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return 0.0f; - } - - return control->GetFloatValue(); -} - -void Interface_GUIControlSlider::set_float_interval(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float interval) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISliderControl* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSlider::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetFloatInterval(interval); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/Slider.h b/xbmc/addons/interfaces/gui/controls/Slider.h deleted file mode 100644 index 30afbafadd775..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Slider.h +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/slider.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Slider.h" - */ - struct Interface_GUIControlSlider - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - - static void reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - - static char* get_description(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - - static void set_int_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int start, - int end); - static void set_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int value); - static int get_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - static void set_int_interval(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int interval); - - static void set_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float percent); - static float get_percentage(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - - static void set_float_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float start, - float end); - static void set_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float value); - static float get_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - static void set_float_interval(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float interval); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/Spin.cpp b/xbmc/addons/interfaces/gui/controls/Spin.cpp deleted file mode 100644 index b9eb6ea3fc559..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Spin.cpp +++ /dev/null @@ -1,346 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Spin.h" - -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/Spin.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUISpinControlEx.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlSpin::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_spin = new AddonToKodiFuncTable_kodi_gui_control_spin(); - - addonInterface->toKodi->kodi_gui->control_spin->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_spin->set_enabled = set_enabled; - - addonInterface->toKodi->kodi_gui->control_spin->set_text = set_text; - addonInterface->toKodi->kodi_gui->control_spin->reset = reset; - addonInterface->toKodi->kodi_gui->control_spin->set_type = set_type; - - addonInterface->toKodi->kodi_gui->control_spin->add_string_label = add_string_label; - addonInterface->toKodi->kodi_gui->control_spin->set_string_value = set_string_value; - addonInterface->toKodi->kodi_gui->control_spin->get_string_value = get_string_value; - - addonInterface->toKodi->kodi_gui->control_spin->add_int_label = add_int_label; - addonInterface->toKodi->kodi_gui->control_spin->set_int_range = set_int_range; - addonInterface->toKodi->kodi_gui->control_spin->set_int_value = set_int_value; - addonInterface->toKodi->kodi_gui->control_spin->get_int_value = get_int_value; - - addonInterface->toKodi->kodi_gui->control_spin->set_float_range = set_float_range; - addonInterface->toKodi->kodi_gui->control_spin->set_float_value = set_float_value; - addonInterface->toKodi->kodi_gui->control_spin->get_float_value = get_float_value; - addonInterface->toKodi->kodi_gui->control_spin->set_float_interval = set_float_interval; -} - -void Interface_GUIControlSpin::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_spin; -} - -void Interface_GUIControlSpin::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlSpin::set_enabled(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool enabled) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetEnabled(enabled); -} - -void Interface_GUIControlSpin::set_text(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* text) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control || !text) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}', " - "text='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(text), - addon ? addon->ID() : "unknown"); - return; - } - - CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID()); - msg.SetLabel(text); - CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); -} - -void Interface_GUIControlSpin::reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID()); - CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); -} - -void Interface_GUIControlSpin::set_type(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int type) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetType(type); -} - -void Interface_GUIControlSpin::add_string_label(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label, - const char* value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control || !label || !value) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}', " - "label='{}', value='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - static_cast(value), addon ? addon->ID() : "unknown"); - return; - } - - control->AddLabel(std::string(label), std::string(value)); -} - -void Interface_GUIControlSpin::set_string_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control || !value) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}', " - "value='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(value), - addon ? addon->ID() : "unknown"); - return; - } - - control->SetStringValue(std::string(value)); -} - -char* Interface_GUIControlSpin::get_string_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - return strdup(control->GetStringValue().c_str()); -} - -void Interface_GUIControlSpin::add_int_label(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label, - int value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control || !label) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}', " - "label='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(label), - addon ? addon->ID() : "unknown"); - return; - } - - control->AddLabel(std::string(label), value); -} - -void Interface_GUIControlSpin::set_int_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int start, - int end) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetRange(start, end); -} - -void Interface_GUIControlSpin::set_int_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetValue(value); -} - -int Interface_GUIControlSpin::get_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return -1; - } - - return control->GetValue(); -} - -void Interface_GUIControlSpin::set_float_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float start, - float end) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetFloatRange(start, end); -} - -void Interface_GUIControlSpin::set_float_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float value) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetFloatValue(value); -} - -float Interface_GUIControlSpin::get_float_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return 0.0f; - } - - return control->GetFloatValue(); -} - -void Interface_GUIControlSpin::set_float_interval(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float interval) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUISpinControlEx* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlSpin::{} - invalid handler data (kodiBase='{}', handle='{}') " - "on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetFloatInterval(interval); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/Spin.h b/xbmc/addons/interfaces/gui/controls/Spin.h deleted file mode 100644 index 1c7102ea44e03..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/Spin.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/spin.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/Spin.h" - */ - struct Interface_GUIControlSpin - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - static void set_enabled(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - - static void set_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text); - static void reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - static void set_type(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int type); - - static void add_string_label(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label, - const char* value); - static void add_int_label(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label, - int value); - - static void set_string_value(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* value); - static char* get_string_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - - static void set_int_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int start, - int end); - static void set_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int value); - static int get_int_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - - static void set_float_range(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float start, - float end); - static void set_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float value); - static float get_float_value(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - static void set_float_interval(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float interval); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/controls/TextBox.cpp b/xbmc/addons/interfaces/gui/controls/TextBox.cpp deleted file mode 100644 index 44c5f893d2656..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/TextBox.cpp +++ /dev/null @@ -1,147 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "TextBox.h" - -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/controls/TextBox.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUITextBox.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIControlTextBox::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->control_text_box = - new AddonToKodiFuncTable_kodi_gui_control_text_box(); - - addonInterface->toKodi->kodi_gui->control_text_box->set_visible = set_visible; - addonInterface->toKodi->kodi_gui->control_text_box->reset = reset; - addonInterface->toKodi->kodi_gui->control_text_box->set_text = set_text; - addonInterface->toKodi->kodi_gui->control_text_box->get_text = get_text; - addonInterface->toKodi->kodi_gui->control_text_box->scroll = scroll; - addonInterface->toKodi->kodi_gui->control_text_box->set_auto_scrolling = set_auto_scrolling; -} - -void Interface_GUIControlTextBox::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->control_text_box; -} - -void Interface_GUIControlTextBox::set_visible(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - bool visible) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUITextBox* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetVisible(visible); -} - -void Interface_GUIControlTextBox::reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUITextBox* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - CGUIMessage msg(GUI_MSG_LABEL_RESET, control->GetParentID(), control->GetID()); - CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); -} - -void Interface_GUIControlTextBox::set_text(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* text) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUITextBox* control = static_cast(handle); - if (!addon || !control || !text) - { - CLog::Log(LOGERROR, - "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', " - "handle='{}', text='{}') on addon '{}'", - __func__, kodiBase, handle, static_cast(text), - addon ? addon->ID() : "unknown"); - return; - } - - CGUIMessage msg(GUI_MSG_LABEL_SET, control->GetParentID(), control->GetID()); - msg.SetLabel(text); - CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, control->GetParentID()); -} - -char* Interface_GUIControlTextBox::get_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUITextBox* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return nullptr; - } - - return strdup(control->GetDescription().c_str()); -} - -void Interface_GUIControlTextBox::scroll(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - unsigned int position) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUITextBox* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->Scroll(position); -} - -void Interface_GUIControlTextBox::set_auto_scrolling( - KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int delay, int time, int repeat) -{ - CAddonDll* addon = static_cast(kodiBase); - CGUITextBox* control = static_cast(handle); - if (!addon || !control) - { - CLog::Log(LOGERROR, - "Interface_GUIControlTextBox::{} - invalid handler data (kodiBase='{}', " - "handle='{}') on addon '{}'", - __func__, kodiBase, handle, addon ? addon->ID() : "unknown"); - return; - } - - control->SetAutoScrolling(delay, time, repeat); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/controls/TextBox.h b/xbmc/addons/interfaces/gui/controls/TextBox.h deleted file mode 100644 index 09c2ff4e6152b..0000000000000 --- a/xbmc/addons/interfaces/gui/controls/TextBox.h +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/controls/text_box.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold general gui functions and initialize also all other gui related types not - * related to a instance type and usable for every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/controls/TextBox.h" - */ - struct Interface_GUIControlTextBox - { - - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void set_visible(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - static void reset(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - static void set_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text); - static char* get_text(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - static void scroll(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, unsigned int position); - static void set_auto_scrolling( - KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int delay, int time, int repeat); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/dialogs/CMakeLists.txt b/xbmc/addons/interfaces/gui/dialogs/CMakeLists.txt deleted file mode 100644 index 4dad4e9b73fa5..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/CMakeLists.txt +++ /dev/null @@ -1,23 +0,0 @@ -set(SOURCES ContextMenu.cpp - ExtendedProgressBar.cpp - FileBrowser.cpp - Keyboard.cpp - Numeric.cpp - OK.cpp - Progress.cpp - Select.cpp - TextViewer.cpp - YesNo.cpp) - -set(HEADERS ContextMenu.h - ExtendedProgressBar.h - FileBrowser.h - Keyboard.h - Numeric.h - OK.h - Progress.h - Select.h - TextViewer.h - YesNo.h) - -core_add_library(addons_interfaces_gui_dialogs) diff --git a/xbmc/addons/interfaces/gui/dialogs/ContextMenu.cpp b/xbmc/addons/interfaces/gui/dialogs/ContextMenu.cpp deleted file mode 100644 index e0e5684652ff6..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/ContextMenu.cpp +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "ContextMenu.h" - -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/ContextMenu.h" -#include "dialogs/GUIDialogContextMenu.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIDialogContextMenu::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->dialogContextMenu = - new AddonToKodiFuncTable_kodi_gui_dialogContextMenu(); - - addonInterface->toKodi->kodi_gui->dialogContextMenu->open = open; -} - -void Interface_GUIDialogContextMenu::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->dialogContextMenu; -} - -int Interface_GUIDialogContextMenu::open(KODI_HANDLE kodiBase, - const char* heading, - const char* entries[], - unsigned int size) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogContextMenu::{} - invalid data", __func__); - return -1; - } - - CGUIDialogContextMenu* dialog = - CServiceBroker::GetGUI()->GetWindowManager().GetWindow( - WINDOW_DIALOG_CONTEXT_MENU); - if (!heading || !entries || !dialog) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogContextMenu::{} - invalid handler data (heading='{}', " - "entries='{}', dialog='{}') on addon '{}'", - __func__, static_cast(heading), static_cast(entries), - kodiBase, addon->ID()); - return -1; - } - - CContextButtons choices; - for (unsigned int i = 0; i < size; ++i) - choices.Add(i, entries[i]); - - return dialog->Show(choices); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/dialogs/ContextMenu.h b/xbmc/addons/interfaces/gui/dialogs/ContextMenu.h deleted file mode 100644 index 7b41a28fbceb8..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/ContextMenu.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/context_menu.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ContextMenu.h" - */ - struct Interface_GUIDialogContextMenu - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static int open(KODI_HANDLE kodiBase, - const char* heading, - const char* entries[], - unsigned int size); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.cpp b/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.cpp deleted file mode 100644 index 9e7f7a7e69083..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.cpp +++ /dev/null @@ -1,305 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "ExtendedProgressBar.h" - -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/ExtendedProgress.h" -#include "dialogs/GUIDialogExtendedProgressBar.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIDialogExtendedProgress::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->dialogExtendedProgress = - new AddonToKodiFuncTable_kodi_gui_dialogExtendedProgress(); - - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->new_dialog = new_dialog; - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->delete_dialog = delete_dialog; - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->get_title = get_title; - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->set_title = set_title; - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->get_text = get_text; - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->set_text = set_text; - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->is_finished = is_finished; - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->mark_finished = mark_finished; - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->get_percentage = get_percentage; - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->set_percentage = set_percentage; - addonInterface->toKodi->kodi_gui->dialogExtendedProgress->set_progress = set_progress; -} - -void Interface_GUIDialogExtendedProgress::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->dialogExtendedProgress; -} - -KODI_GUI_HANDLE Interface_GUIDialogExtendedProgress::new_dialog(KODI_HANDLE kodiBase, - const char* title) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return nullptr; - } - - // setup the progress dialog - CGUIDialogExtendedProgressBar* dialog = - CServiceBroker::GetGUI()->GetWindowManager().GetWindow( - WINDOW_DIALOG_EXT_PROGRESS); - if (!title || !dialog) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid handler data (title='{}', " - "dialog='{}') on addon '{}'", - __func__, static_cast(title), static_cast(dialog), addon->ID()); - return nullptr; - } - - CGUIDialogProgressBarHandle* dlgProgressHandle = dialog->GetHandle(title); - return dlgProgressHandle; -} - -void Interface_GUIDialogExtendedProgress::delete_dialog(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid handler data (handle='{}') on " - "addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->MarkFinished(); -} - -char* Interface_GUIDialogExtendedProgress::get_title(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return nullptr; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid handler data (handle='{}') on " - "addon '{}'", - __func__, handle, addon->ID()); - return nullptr; - } - - return strdup(static_cast(handle)->Title().c_str()); -} - -void Interface_GUIDialogExtendedProgress::set_title(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - const char* title) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return; - } - - if (!handle || !title) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid handler data (handle='{}', " - "title='{}') on addon '{}'", - __func__, handle, static_cast(title), addon->ID()); - return; - } - - static_cast(handle)->SetTitle(title); -} - -char* Interface_GUIDialogExtendedProgress::get_text(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return nullptr; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on " - "addon '{}'", - __func__, handle, addon->ID()); - return nullptr; - } - - return strdup(static_cast(handle)->Text().c_str()); -} - -void Interface_GUIDialogExtendedProgress::set_text(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - const char* text) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return; - } - - if (!handle || !text) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid handler data (handle='{}', " - "text='{}') on addon '{}'", - __func__, handle, static_cast(text), addon->ID()); - return; - } - - static_cast(handle)->SetText(text); -} - -bool Interface_GUIDialogExtendedProgress::is_finished(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return false; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on " - "addon '{}'", - __func__, handle, addon->ID()); - return false; - } - - return static_cast(handle)->IsFinished(); -} - -void Interface_GUIDialogExtendedProgress::mark_finished(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on " - "addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->MarkFinished(); -} - -float Interface_GUIDialogExtendedProgress::get_percentage(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return 0.0f; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on " - "addon '{}'", - __func__, handle, addon->ID()); - return 0.0f; - } - - return static_cast(handle)->Percentage(); -} - -void Interface_GUIDialogExtendedProgress::set_percentage(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - float percentage) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on " - "addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->SetPercentage(percentage); -} - -void Interface_GUIDialogExtendedProgress::set_progress(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - int currentItem, - int itemCount) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogExtendedProgress::{} - invalid kodi base data", - __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogExtendedProgress::{} - invalid add-on data (handle='{}') on " - "addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->SetProgress(currentItem, itemCount); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.h b/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.h deleted file mode 100644 index 66ccb49e6b0dd..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/ExtendedProgressBar.h +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/extended_progress.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ExtendedProgress.h" - */ - struct Interface_GUIDialogExtendedProgress - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static KODI_GUI_HANDLE new_dialog(KODI_HANDLE kodiBase, const char* title); - static void delete_dialog(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - static char* get_title(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - static void set_title(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, const char* title); - static char* get_text(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - static void set_text(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, const char* text); - static bool is_finished(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - static void mark_finished(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - static float get_percentage(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - static void set_percentage(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, float percentage); - static void set_progress(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - int currentItem, - int itemCount); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/dialogs/FileBrowser.cpp b/xbmc/addons/interfaces/gui/dialogs/FileBrowser.cpp deleted file mode 100644 index 84d64432326ea..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/FileBrowser.cpp +++ /dev/null @@ -1,403 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "FileBrowser.h" - -#include "URL.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/FileBrowser.h" -#include "dialogs/GUIDialogFileBrowser.h" -#include "settings/MediaSourceSettings.h" -#include "storage/MediaManager.h" -#include "utils/URIUtils.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIDialogFileBrowser::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->dialogFileBrowser = - new AddonToKodiFuncTable_kodi_gui_dialogFileBrowser(); - - addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_directory = - show_and_get_directory; - addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_file = show_and_get_file; - addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_file_from_dir = - show_and_get_file_from_dir; - addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_file_list = - show_and_get_file_list; - addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_source = show_and_get_source; - addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_image = show_and_get_image; - addonInterface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_image_list = - show_and_get_image_list; - addonInterface->toKodi->kodi_gui->dialogFileBrowser->clear_file_list = clear_file_list; -} - -void Interface_GUIDialogFileBrowser::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->dialogFileBrowser; -} - -bool Interface_GUIDialogFileBrowser::show_and_get_directory(KODI_HANDLE kodiBase, - const char* shares, - const char* heading, - const char* path_in, - char** path_out, - bool write_only) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__); - return false; - } - - if (!shares || !heading || !path_in || !path_out) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogFileBrowser::{} - invalid handler data (shares='{}', " - "heading='{}', path_in='{}', path_out='{}') on addon '{}'", - __func__, static_cast(shares), static_cast(heading), - static_cast(path_in), static_cast(path_out), addon->ID()); - return false; - } - - std::string strPath = path_in; - - VECSOURCES vecShares; - GetVECShares(vecShares, shares, strPath); - bool bRet = CGUIDialogFileBrowser::ShowAndGetDirectory(vecShares, heading, strPath, write_only); - if (bRet) - *path_out = strdup(strPath.c_str()); - return bRet; -} - -bool Interface_GUIDialogFileBrowser::show_and_get_file(KODI_HANDLE kodiBase, - const char* shares, - const char* mask, - const char* heading, - const char* path_in, - char** path_out, - bool use_thumbs, - bool use_file_directories) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__); - return false; - } - - if (!shares || !mask || !heading || !path_in || !path_out) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogFileBrowser::{} - invalid handler data (shares='{}', mask='{}', " - "heading='{}', path_in='{}', path_out='{}') on addon '{}'", - __func__, static_cast(shares), static_cast(mask), - static_cast(heading), static_cast(path_in), - static_cast(path_out), addon->ID()); - return false; - } - - std::string strPath = path_in; - - VECSOURCES vecShares; - GetVECShares(vecShares, shares, strPath); - bool bRet = CGUIDialogFileBrowser::ShowAndGetFile(vecShares, mask, heading, strPath, use_thumbs, - use_file_directories); - if (bRet) - *path_out = strdup(strPath.c_str()); - return bRet; -} - -bool Interface_GUIDialogFileBrowser::show_and_get_file_from_dir(KODI_HANDLE kodiBase, - const char* directory, - const char* mask, - const char* heading, - const char* path_in, - char** path_out, - bool use_thumbs, - bool use_file_directories, - bool single_list) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__); - return false; - } - - if (!directory || !mask || !heading || !path_in || !path_out) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogFileBrowser::{} - invalid handler data (directory='{}', " - "mask='{}', heading='{}', path_in='{}', path_out='{}') on addon '{}'", - __func__, static_cast(directory), static_cast(mask), - static_cast(heading), static_cast(path_in), - static_cast(path_out), addon->ID()); - return false; - } - - std::string strPath = path_in; - bool bRet = CGUIDialogFileBrowser::ShowAndGetFile(directory, mask, heading, strPath, use_thumbs, - use_file_directories, single_list); - if (bRet) - *path_out = strdup(strPath.c_str()); - return bRet; -} - -bool Interface_GUIDialogFileBrowser::show_and_get_file_list(KODI_HANDLE kodiBase, - const char* shares, - const char* mask, - const char* heading, - char*** file_list, - unsigned int* entries, - bool use_thumbs, - bool use_file_directories) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__); - return false; - } - - if (!shares || !mask || !heading || !file_list || !entries) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogFileBrowser::{} - invalid handler data (shares='{}', mask='{}', " - "heading='{}', file_list='{}', entries='{}') on addon '{}'", - __func__, static_cast(shares), static_cast(mask), - static_cast(heading), static_cast(file_list), - static_cast(entries), addon->ID()); - return false; - } - - VECSOURCES vecShares; - GetVECShares(vecShares, shares, ""); - - std::vector pathsInt; - bool bRet = CGUIDialogFileBrowser::ShowAndGetFileList(vecShares, mask, heading, pathsInt, - use_thumbs, use_file_directories); - if (bRet) - { - *entries = pathsInt.size(); - *file_list = static_cast(malloc(*entries * sizeof(char*))); - for (unsigned int i = 0; i < *entries; ++i) - (*file_list)[i] = strdup(pathsInt[i].c_str()); - } - else - *entries = 0; - return bRet; -} - -bool Interface_GUIDialogFileBrowser::show_and_get_source(KODI_HANDLE kodiBase, - const char* path_in, - char** path_out, - bool allowNetworkShares, - const char* additionalShare, - const char* strType) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__); - return false; - } - - if (!strType || !additionalShare || !path_in || !path_out) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogFileBrowser::{} - invalid handler data (additionalShare='{}', " - "strType='{}', path_in='{}', path_out='{}') on addon '{}'", - __func__, static_cast(additionalShare), - static_cast(strType), static_cast(path_in), - static_cast(path_out), addon->ID()); - return false; - } - - std::string strPath = path_in; - - VECSOURCES vecShares; - if (additionalShare) - GetVECShares(vecShares, additionalShare, strPath); - bool bRet = - CGUIDialogFileBrowser::ShowAndGetSource(strPath, allowNetworkShares, &vecShares, strType); - if (bRet) - *path_out = strdup(strPath.c_str()); - return bRet; -} - -bool Interface_GUIDialogFileBrowser::show_and_get_image(KODI_HANDLE kodiBase, - const char* shares, - const char* heading, - const char* path_in, - char** path_out) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__); - return false; - } - - if (!shares || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogFileBrowser::{} - invalid handler data (shares='{}', " - "heading='{}') on addon '{}'", - __func__, static_cast(shares), static_cast(heading), - addon->ID()); - return false; - } - - std::string strPath = path_in; - - VECSOURCES vecShares; - GetVECShares(vecShares, shares, strPath); - bool bRet = CGUIDialogFileBrowser::ShowAndGetImage(vecShares, heading, strPath); - if (bRet) - *path_out = strdup(strPath.c_str()); - return bRet; -} - -bool Interface_GUIDialogFileBrowser::show_and_get_image_list(KODI_HANDLE kodiBase, - const char* shares, - const char* heading, - char*** file_list, - unsigned int* entries) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__); - return false; - } - - if (!shares || !heading || !file_list || !entries) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogFileBrowser::{} - invalid handler data (shares='{}', " - "heading='{}', file_list='{}', entries='{}') on addon '{}'", - __func__, static_cast(shares), static_cast(heading), - static_cast(file_list), static_cast(entries), addon->ID()); - return false; - } - - VECSOURCES vecShares; - GetVECShares(vecShares, shares, ""); - - std::vector pathsInt; - bool bRet = CGUIDialogFileBrowser::ShowAndGetImageList(vecShares, heading, pathsInt); - if (bRet) - { - *entries = pathsInt.size(); - *file_list = static_cast(malloc(*entries * sizeof(char*))); - for (unsigned int i = 0; i < *entries; ++i) - (*file_list)[i] = strdup(pathsInt[i].c_str()); - } - else - *entries = 0; - return bRet; -} - -void Interface_GUIDialogFileBrowser::clear_file_list(KODI_HANDLE kodiBase, - char*** file_list, - unsigned int entries) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogFileBrowser::{} - invalid data", __func__); - return; - } - - if (*file_list) - { - for (unsigned int i = 0; i < entries; ++i) - free((*file_list)[i]); - free(*file_list); - *file_list = nullptr; - } - else - { - - CLog::Log(LOGERROR, - "Interface_GUIDialogFileBrowser::{} - invalid handler data (file_list='{}') on " - "addon '{}'", - __func__, static_cast(file_list), addon->ID()); - } -} - -void Interface_GUIDialogFileBrowser::GetVECShares(VECSOURCES& vecShares, - const std::string& strShares, - const std::string& strPath) -{ - std::size_t found; - found = strShares.find("local"); - if (found != std::string::npos) - CServiceBroker::GetMediaManager().GetLocalDrives(vecShares); - found = strShares.find("network"); - if (found != std::string::npos) - CServiceBroker::GetMediaManager().GetNetworkLocations(vecShares); - found = strShares.find("removable"); - if (found != std::string::npos) - CServiceBroker::GetMediaManager().GetRemovableDrives(vecShares); - found = strShares.find("programs"); - if (found != std::string::npos) - { - VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("programs"); - if (sources != nullptr) - vecShares.insert(vecShares.end(), sources->begin(), sources->end()); - } - found = strShares.find("files"); - if (found != std::string::npos) - { - VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("files"); - if (sources != nullptr) - vecShares.insert(vecShares.end(), sources->begin(), sources->end()); - } - found = strShares.find("music"); - if (found != std::string::npos) - { - VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("music"); - if (sources != nullptr) - vecShares.insert(vecShares.end(), sources->begin(), sources->end()); - } - found = strShares.find("video"); - if (found != std::string::npos) - { - VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("video"); - if (sources != nullptr) - vecShares.insert(vecShares.end(), sources->begin(), sources->end()); - } - found = strShares.find("pictures"); - if (found != std::string::npos) - { - VECSOURCES* sources = CMediaSourceSettings::GetInstance().GetSources("pictures"); - if (sources != nullptr) - vecShares.insert(vecShares.end(), sources->begin(), sources->end()); - } - - if (vecShares.empty()) - { - CMediaSource share; - std::string basePath = strPath; - std::string tempPath; - while (URIUtils::GetParentPath(basePath, tempPath)) - basePath = tempPath; - share.strPath = basePath; - // don't include the user details in the share name - CURL url(share.strPath); - share.strName = url.GetWithoutUserDetails(); - vecShares.push_back(share); - } -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/dialogs/FileBrowser.h b/xbmc/addons/interfaces/gui/dialogs/FileBrowser.h deleted file mode 100644 index c2193f3f72ce3..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/FileBrowser.h +++ /dev/null @@ -1,116 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/filebrowser.h" - -#include -#include - -class CMediaSource; - -typedef std::vector VECSOURCES; - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/FileBrowser.h" - */ - struct Interface_GUIDialogFileBrowser - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static bool show_and_get_directory(KODI_HANDLE kodiBase, - const char* shares, - const char* heading, - const char* path_in, - char** path_out, - bool write_only); - - static bool show_and_get_file(KODI_HANDLE kodiBase, - const char* shares, - const char* mask, - const char* heading, - const char* path_in, - char** path_out, - bool use_thumbs, - bool use_file_directories); - - static bool show_and_get_file_from_dir(KODI_HANDLE kodiBase, - const char* directory, - const char* mask, - const char* heading, - const char* path_in, - char** path_out, - bool use_thumbs, - bool use_file_directories, - bool singleList); - - static bool show_and_get_file_list(KODI_HANDLE kodiBase, - const char* shares, - const char* mask, - const char* heading, - char*** file_list, - unsigned int* entries, - bool use_thumbs, - bool use_file_directories); - - static bool show_and_get_source(KODI_HANDLE kodiBase, - const char* path_in, - char** path_out, - bool allow_network_shares, - const char* additional_share, - const char* type); - - static bool show_and_get_image(KODI_HANDLE kodiBase, - const char* shares, - const char* heading, - const char* path_in, - char** path_out); - - static bool show_and_get_image_list(KODI_HANDLE kodiBase, - const char* shares, - const char* heading, - char*** file_list, - unsigned int* entries); - - static void clear_file_list(KODI_HANDLE kodiBase, char*** file_list, unsigned int entries); - //@} - - private: - static void GetVECShares(VECSOURCES& vecShares, - const std::string& strShares, - const std::string& strPath); - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/dialogs/Keyboard.cpp b/xbmc/addons/interfaces/gui/dialogs/Keyboard.cpp deleted file mode 100644 index 7ec56ab18b605..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/Keyboard.cpp +++ /dev/null @@ -1,319 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Keyboard.h" - -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/Keyboard.h" -#include "guilib/GUIKeyboardFactory.h" -#include "utils/Variant.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIDialogKeyboard::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->dialogKeyboard = - new AddonToKodiFuncTable_kodi_gui_dialogKeyboard(); - - addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_get_input_with_head = - show_and_get_input_with_head; - addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_get_input = show_and_get_input; - addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_get_new_password_with_head = - show_and_get_new_password_with_head; - addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_get_new_password = - show_and_get_new_password; - addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_verify_new_password_with_head = - show_and_verify_new_password_with_head; - addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_verify_new_password = - show_and_verify_new_password; - addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_verify_password = - show_and_verify_password; - addonInterface->toKodi->kodi_gui->dialogKeyboard->show_and_get_filter = show_and_get_filter; - addonInterface->toKodi->kodi_gui->dialogKeyboard->send_text_to_active_keyboard = - send_text_to_active_keyboard; - addonInterface->toKodi->kodi_gui->dialogKeyboard->is_keyboard_activated = is_keyboard_activated; -} - -void Interface_GUIDialogKeyboard::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->dialogKeyboard; -} - -bool Interface_GUIDialogKeyboard::show_and_get_input_with_head(KODI_HANDLE kodiBase, - const char* text_in, - char** text_out, - const char* heading, - bool allow_empty_result, - bool hidden_input, - unsigned int auto_close_ms) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__); - return false; - } - - if (!text_in || !text_out || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogKeyboard::{} - invalid handler data (text_in='{}', " - "text_out='{}', heading='{}') on addon '{}'", - __func__, static_cast(text_in), static_cast(text_out), - static_cast(heading), addon->ID()); - return false; - } - - std::string str = text_in; - bool bRet = CGUIKeyboardFactory::ShowAndGetInput(str, CVariant{heading}, allow_empty_result, - hidden_input, auto_close_ms); - if (bRet) - *text_out = strdup(str.c_str()); - return bRet; -} - -bool Interface_GUIDialogKeyboard::show_and_get_input(KODI_HANDLE kodiBase, - const char* text_in, - char** text_out, - bool allow_empty_result, - unsigned int auto_close_ms) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__); - return false; - } - - if (!text_in || !text_out) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogKeyboard::{} - invalid handler data (text_in='{}', " - "text_out='{}') on addon '{}'", - __func__, static_cast(text_in), static_cast(text_out), - addon->ID()); - return false; - } - - std::string str = text_in; - bool bRet = CGUIKeyboardFactory::ShowAndGetInput(str, allow_empty_result, auto_close_ms); - if (bRet) - *text_out = strdup(str.c_str()); - return bRet; -} - -bool Interface_GUIDialogKeyboard::show_and_get_new_password_with_head(KODI_HANDLE kodiBase, - const char* password_in, - char** password_out, - const char* heading, - bool allow_empty_result, - unsigned int auto_close_ms) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__); - return false; - } - - if (!password_in || !password_out || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogKeyboard::{} - invalid handler data (password_in='{}', " - "password_out='{}', heading='{}') on addon '{}'", - __func__, static_cast(password_in), static_cast(password_out), - static_cast(heading), addon->ID()); - return false; - } - - std::string str = password_in; - bool bRet = - CGUIKeyboardFactory::ShowAndGetNewPassword(str, heading, allow_empty_result, auto_close_ms); - if (bRet) - *password_out = strdup(str.c_str()); - return bRet; -} - -bool Interface_GUIDialogKeyboard::show_and_get_new_password(KODI_HANDLE kodiBase, - const char* password_in, - char** password_out, - unsigned int auto_close_ms) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__); - return false; - } - - if (!password_in || !password_out) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogKeyboard::{} - invalid handler data (password_in='{}', " - "password_out='{}') on addon '{}'", - __func__, static_cast(password_in), static_cast(password_out), - addon->ID()); - return false; - } - - std::string str = password_in; - bool bRet = CGUIKeyboardFactory::ShowAndGetNewPassword(str, auto_close_ms); - if (bRet) - *password_out = strdup(str.c_str()); - return bRet; -} - -bool Interface_GUIDialogKeyboard::show_and_verify_new_password_with_head(KODI_HANDLE kodiBase, - char** password_out, - const char* heading, - bool allowEmpty, - unsigned int auto_close_ms) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__); - return false; - } - - if (!password_out || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogKeyboard::{} - invalid handler data (password_out='{}', " - "heading='{}') on addon '{}'", - __func__, static_cast(password_out), static_cast(heading), - addon->ID()); - return false; - } - - std::string str; - bool bRet = - CGUIKeyboardFactory::ShowAndVerifyNewPassword(str, heading, allowEmpty, auto_close_ms); - if (bRet) - *password_out = strdup(str.c_str()); - return bRet; -} - -bool Interface_GUIDialogKeyboard::show_and_verify_new_password(KODI_HANDLE kodiBase, - char** password_out, - unsigned int auto_close_ms) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__); - return false; - } - - if (!password_out) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogKeyboard::{} - invalid handler data (password_out='{}') on " - "addon '{}'", - __func__, static_cast(password_out), addon->ID()); - return false; - } - - std::string str; - bool bRet = CGUIKeyboardFactory::ShowAndVerifyNewPassword(str, auto_close_ms); - if (bRet) - *password_out = strdup(str.c_str()); - return bRet; -} - -int Interface_GUIDialogKeyboard::show_and_verify_password(KODI_HANDLE kodiBase, - const char* password_in, - char** password_out, - const char* heading, - int retries, - unsigned int auto_close_ms) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__); - return false; - } - - if (!password_in || !password_out || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogKeyboard::{} - invalid handler data (password_in='{}', " - "password_out='{}', heading='{}') on addon '{}'", - __func__, static_cast(password_in), static_cast(password_out), - static_cast(heading), addon->ID()); - return false; - } - - std::string str = password_in; - int iRet = CGUIKeyboardFactory::ShowAndVerifyPassword(str, heading, retries, auto_close_ms); - if (iRet) - *password_out = strdup(str.c_str()); - return iRet; -} - -bool Interface_GUIDialogKeyboard::show_and_get_filter(KODI_HANDLE kodiBase, - const char* text_in, - char** text_out, - bool searching, - unsigned int auto_close_ms) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__); - return false; - } - - if (!text_in || !text_out) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogKeyboard::{} - invalid handler data (text_in='{}', " - "text_out='{}') on addon '{}'", - __func__, static_cast(text_in), static_cast(text_out), - addon->ID()); - return false; - } - - - std::string str = text_in; - bool bRet = CGUIKeyboardFactory::ShowAndGetFilter(str, searching, auto_close_ms); - if (bRet) - *text_out = strdup(str.c_str()); - return bRet; -} - -bool Interface_GUIDialogKeyboard::send_text_to_active_keyboard(KODI_HANDLE kodiBase, - const char* text, - bool close_keyboard) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__); - return false; - } - - return CGUIKeyboardFactory::SendTextToActiveKeyboard(text, close_keyboard); -} - -bool Interface_GUIDialogKeyboard::is_keyboard_activated(KODI_HANDLE kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogKeyboard::{} - invalid data", __func__); - return false; - } - - return CGUIKeyboardFactory::isKeyboardActivated(); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/dialogs/Keyboard.h b/xbmc/addons/interfaces/gui/dialogs/Keyboard.h deleted file mode 100644 index fb7d6b9d595ad..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/Keyboard.h +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/keyboard.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Keyboard.h" - */ - struct Interface_GUIDialogKeyboard - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static bool show_and_get_input_with_head(KODI_HANDLE kodiBase, - const char* text_in, - char** text_out, - const char* heading, - bool allow_empty_result, - bool hidden_input, - unsigned int auto_close_ms); - static bool show_and_get_input(KODI_HANDLE kodiBase, - const char* text_in, - char** text_out, - bool allow_empty_result, - unsigned int auto_close_ms); - static bool show_and_get_new_password_with_head(KODI_HANDLE kodiBase, - const char* password_in, - char** password_out, - const char* heading, - bool allow_empty_result, - unsigned int auto_close_ms); - static bool show_and_get_new_password(KODI_HANDLE kodiBase, - const char* password_in, - char** password_out, - unsigned int auto_close_ms); - static bool show_and_verify_new_password_with_head(KODI_HANDLE kodiBase, - char** password_out, - const char* heading, - bool allowEmpty, - unsigned int auto_close_ms); - static bool show_and_verify_new_password(KODI_HANDLE kodiBase, - char** password_out, - unsigned int auto_close_ms); - static int show_and_verify_password(KODI_HANDLE kodiBase, - const char* password_in, - char** password_out, - const char* heading, - int retries, - unsigned int auto_close_ms); - static bool show_and_get_filter(KODI_HANDLE kodiBase, - const char* text_in, - char** text_out, - bool searching, - unsigned int auto_close_ms); - static bool send_text_to_active_keyboard(KODI_HANDLE kodiBase, - const char* text, - bool close_keyboard); - static bool is_keyboard_activated(KODI_HANDLE kodiBase); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/dialogs/Numeric.cpp b/xbmc/addons/interfaces/gui/dialogs/Numeric.cpp deleted file mode 100644 index a78aa4af607af..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/Numeric.cpp +++ /dev/null @@ -1,270 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Numeric.h" - -#include "XBDateTime.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/Numeric.h" -#include "dialogs/GUIDialogNumeric.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIDialogNumeric::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->dialogNumeric = - new AddonToKodiFuncTable_kodi_gui_dialogNumeric(); - - addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_verify_new_password = - show_and_verify_new_password; - addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_verify_password = - show_and_verify_password; - addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_verify_input = show_and_verify_input; - addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_get_time = show_and_get_time; - addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_get_date = show_and_get_date; - addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_get_ip_address = - show_and_get_ip_address; - addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_get_number = show_and_get_number; - addonInterface->toKodi->kodi_gui->dialogNumeric->show_and_get_seconds = show_and_get_seconds; -} - -void Interface_GUIDialogNumeric::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->dialogNumeric; -} - -bool Interface_GUIDialogNumeric::show_and_verify_new_password(KODI_HANDLE kodiBase, char** password) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__); - return false; - } - - std::string str; - bool bRet = CGUIDialogNumeric::ShowAndVerifyNewPassword(str); - if (bRet) - *password = strdup(str.c_str()); - return bRet; -} - -int Interface_GUIDialogNumeric::show_and_verify_password(KODI_HANDLE kodiBase, - const char* password, - const char* heading, - int retries) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__); - return -1; - } - - if (!password || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogNumeric::{} - invalid handler data (password='{}', heading='{}') " - "on addon '{}'", - __func__, static_cast(password), static_cast(heading), - addon->ID()); - return -1; - } - - std::string pw(password); - return CGUIDialogNumeric::ShowAndVerifyPassword(pw, heading, retries); -} - -bool Interface_GUIDialogNumeric::show_and_verify_input(KODI_HANDLE kodiBase, - const char* verify_in, - char** verify_out, - const char* heading, - bool verify_input) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__); - return false; - } - - if (!verify_in || !verify_out || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogNumeric::{} - invalid handler data (verify_in='{}', " - "verify_out='{}', heading='{}') on addon '{}'", - __func__, static_cast(verify_in), static_cast(verify_out), - static_cast(heading), addon->ID()); - return false; - } - - std::string str = verify_in; - if (CGUIDialogNumeric::ShowAndVerifyInput(str, heading, verify_input) == - InputVerificationResult::SUCCESS) - { - *verify_out = strdup(str.c_str()); - return true; - } - return false; -} - -bool Interface_GUIDialogNumeric::show_and_get_time(KODI_HANDLE kodiBase, - tm* time, - const char* heading) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__); - return false; - } - - if (!time || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogNumeric::{} - invalid handler data (time='{}', heading='{}') on " - "addon '{}'", - __func__, static_cast(time), static_cast(heading), addon->ID()); - return false; - } - - KODI::TIME::SystemTime systemTime; - CDateTime dateTime(*time); - dateTime.GetAsSystemTime(systemTime); - if (CGUIDialogNumeric::ShowAndGetTime(systemTime, heading)) - { - dateTime = systemTime; - dateTime.GetAsTm(*time); - return true; - } - return false; -} - -bool Interface_GUIDialogNumeric::show_and_get_date(KODI_HANDLE kodiBase, - tm* date, - const char* heading) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__); - return false; - } - - if (!date || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogNumeric::{} - invalid handler data (date='{}', heading='{}') on " - "addon '{}'", - __func__, static_cast(date), static_cast(heading), addon->ID()); - return false; - } - - KODI::TIME::SystemTime systemTime; - CDateTime dateTime(*date); - dateTime.GetAsSystemTime(systemTime); - if (CGUIDialogNumeric::ShowAndGetDate(systemTime, heading)) - { - dateTime = systemTime; - dateTime.GetAsTm(*date); - return true; - } - return false; -} - -bool Interface_GUIDialogNumeric::show_and_get_ip_address(KODI_HANDLE kodiBase, - const char* ip_address_in, - char** ip_address_out, - const char* heading) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__); - return false; - } - - if (!ip_address_in || !ip_address_out || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogNumeric::{} - invalid handler data (ip_address_in='{}', " - "ip_address_out='{}', heading='{}') on addon '{}'", - __func__, static_cast(ip_address_in), static_cast(ip_address_out), - static_cast(heading), addon->ID()); - return false; - } - - std::string strIP = ip_address_in; - bool bRet = CGUIDialogNumeric::ShowAndGetIPAddress(strIP, heading); - if (bRet) - *ip_address_out = strdup(strIP.c_str()); - return bRet; -} - -bool Interface_GUIDialogNumeric::show_and_get_number(KODI_HANDLE kodiBase, - const char* number_in, - char** number_out, - const char* heading, - unsigned int auto_close_ms) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__); - return false; - } - - if (!number_in || !number_out || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogNumeric::{} - invalid handler data (number_in='{}', " - "number_out='{}', heading='{}') on addon '{}'", - __func__, static_cast(number_in), static_cast(number_out), - static_cast(heading), addon->ID()); - return false; - } - - std::string str = number_in; - bool bRet = CGUIDialogNumeric::ShowAndGetNumber(str, heading, auto_close_ms); - if (bRet) - *number_out = strdup(str.c_str()); - return bRet; -} - -bool Interface_GUIDialogNumeric::show_and_get_seconds(KODI_HANDLE kodiBase, - const char* time_in, - char** time_out, - const char* heading) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogNumeric::{} - invalid data", __func__); - return false; - } - - if (!time_in || !time_out || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogNumeric::{} - invalid handler data (time_in='{}', time_out='{}', " - "heading='{}') on addon '{}'", - __func__, static_cast(time_in), static_cast(time_out), - static_cast(heading), addon->ID()); - return false; - } - - std::string str = time_in; - bool bRet = CGUIDialogNumeric::ShowAndGetSeconds(str, heading); - if (bRet) - *time_out = strdup(str.c_str()); - return bRet; -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/dialogs/Numeric.h b/xbmc/addons/interfaces/gui/dialogs/Numeric.h deleted file mode 100644 index a54ad525b5d6f..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/Numeric.h +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/numeric.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Numeric.h" - */ - struct Interface_GUIDialogNumeric - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static bool show_and_verify_new_password(KODI_HANDLE kodiBase, char** password); - static int show_and_verify_password(KODI_HANDLE kodiBase, - const char* password, - const char* heading, - int retries); - static bool show_and_verify_input(KODI_HANDLE kodiBase, - const char* verify_in, - char** verify_out, - const char* heading, - bool verify_input); - static bool show_and_get_time(KODI_HANDLE kodiBase, tm* time, const char* heading); - static bool show_and_get_date(KODI_HANDLE kodiBase, tm* date, const char* heading); - static bool show_and_get_ip_address(KODI_HANDLE kodiBase, - const char* ip_address_in, - char** ip_address_out, - const char* heading); - static bool show_and_get_number(KODI_HANDLE kodiBase, - const char* number_in, - char** number_out, - const char* heading, - unsigned int auto_close_ms); - static bool show_and_get_seconds(KODI_HANDLE kodiBase, - const char* time_in, - char** time_out, - const char* heading); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/dialogs/OK.cpp b/xbmc/addons/interfaces/gui/dialogs/OK.cpp deleted file mode 100644 index 90e9d6999b8f6..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/OK.cpp +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "OK.h" - -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/OK.h" -#include "messaging/helpers/DialogOKHelper.h" -#include "utils/Variant.h" -#include "utils/log.h" - -using namespace KODI::MESSAGING; - -namespace ADDON -{ - -void Interface_GUIDialogOK::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->dialogOK = new AddonToKodiFuncTable_kodi_gui_dialogOK(); - - addonInterface->toKodi->kodi_gui->dialogOK->show_and_get_input_single_text = - show_and_get_input_single_text; - addonInterface->toKodi->kodi_gui->dialogOK->show_and_get_input_line_text = - show_and_get_input_line_text; -} - -void Interface_GUIDialogOK::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->dialogOK; -} - -void Interface_GUIDialogOK::show_and_get_input_single_text(KODI_HANDLE kodiBase, - const char* heading, - const char* text) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon || !heading || !text) - { - CLog::Log( - LOGERROR, "Interface_GUIDialogOK:{} - invalid data (addon='{}', heading='{}', text='{}')", - __func__, kodiBase, static_cast(heading), static_cast(text)); - return; - } - - HELPERS::ShowOKDialogText(CVariant{heading}, CVariant{text}); -} - -void Interface_GUIDialogOK::show_and_get_input_line_text(KODI_HANDLE kodiBase, - const char* heading, - const char* line0, - const char* line1, - const char* line2) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon || !heading || !line0 || !line1 || !line2) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogOK::{} - invalid data (addon='{}', heading='{}', line0='{}', " - "line1='{}', line2='{}')", - __func__, kodiBase, static_cast(heading), - static_cast(line0), static_cast(line1), - static_cast(line2)); - return; - } - HELPERS::ShowOKDialogLines(CVariant{heading}, CVariant{line0}, CVariant{line1}, CVariant{line2}); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/dialogs/OK.h b/xbmc/addons/interfaces/gui/dialogs/OK.h deleted file mode 100644 index fd13719a99abd..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/OK.h +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/ok.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/OK.h" - */ - struct Interface_GUIDialogOK - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note For add of new functions use the "_" style to identify direct a - * add-on callback function. Everything with CamelCase is only for the - * usage in Kodi only. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void show_and_get_input_single_text(KODI_HANDLE kodiBase, - const char* heading, - const char* text); - static void show_and_get_input_line_text(KODI_HANDLE kodiBase, - const char* heading, - const char* line0, - const char* line1, - const char* line2); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/dialogs/Progress.cpp b/xbmc/addons/interfaces/gui/dialogs/Progress.cpp deleted file mode 100644 index ff6c7424ba81f..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/Progress.cpp +++ /dev/null @@ -1,328 +0,0 @@ -/* - * Copyright (C) 2015-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Progress.h" - -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/Progress.h" -#include "dialogs/GUIDialogProgress.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUIWindowManager.h" -#include "utils/Variant.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIDialogProgress::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->dialogProgress = - new AddonToKodiFuncTable_kodi_gui_dialogProgress(); - - addonInterface->toKodi->kodi_gui->dialogProgress->new_dialog = new_dialog; - addonInterface->toKodi->kodi_gui->dialogProgress->delete_dialog = delete_dialog; - addonInterface->toKodi->kodi_gui->dialogProgress->open = open; - addonInterface->toKodi->kodi_gui->dialogProgress->set_heading = set_heading; - addonInterface->toKodi->kodi_gui->dialogProgress->set_line = set_line; - addonInterface->toKodi->kodi_gui->dialogProgress->set_can_cancel = set_can_cancel; - addonInterface->toKodi->kodi_gui->dialogProgress->is_canceled = is_canceled; - addonInterface->toKodi->kodi_gui->dialogProgress->set_percentage = set_percentage; - addonInterface->toKodi->kodi_gui->dialogProgress->get_percentage = get_percentage; - addonInterface->toKodi->kodi_gui->dialogProgress->show_progress_bar = show_progress_bar; - addonInterface->toKodi->kodi_gui->dialogProgress->set_progress_max = set_progress_max; - addonInterface->toKodi->kodi_gui->dialogProgress->set_progress_advance = set_progress_advance; - addonInterface->toKodi->kodi_gui->dialogProgress->abort = abort; -} - -void Interface_GUIDialogProgress::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->dialogProgress; -} - -KODI_GUI_HANDLE Interface_GUIDialogProgress::new_dialog(KODI_HANDLE kodiBase) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return nullptr; - } - - CGUIDialogProgress* dialog = - CServiceBroker::GetGUI()->GetWindowManager().GetWindow( - WINDOW_DIALOG_PROGRESS); - if (!dialog) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (dialog='{}') on addon '{}'", - __func__, static_cast(dialog), addon->ID()); - return nullptr; - } - - return dialog; -} - -void Interface_GUIDialogProgress::delete_dialog(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->Close(); -} - -void Interface_GUIDialogProgress::open(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->Open(); -} - -void Interface_GUIDialogProgress::set_heading(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - const char* heading) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return; - } - - if (!handle || !heading) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}', heading='{}') " - "on addon '{}'", - __func__, handle, static_cast(heading), addon->ID()); - return; - } - - static_cast(handle)->SetHeading(heading); -} - -void Interface_GUIDialogProgress::set_line(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - unsigned int line, - const char* text) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return; - } - - if (!handle || !text) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}', text='{}') on " - "addon '{}'", - __func__, handle, static_cast(text), addon->ID()); - return; - } - - static_cast(handle)->SetLine(line, text); -} - -void Interface_GUIDialogProgress::set_can_cancel(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - bool canCancel) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->SetCanCancel(canCancel); -} - -bool Interface_GUIDialogProgress::is_canceled(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return false; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon->ID()); - return false; - } - - return static_cast(handle)->IsCanceled(); -} - -void Interface_GUIDialogProgress::set_percentage(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - int percentage) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->SetPercentage(percentage); -} - -int Interface_GUIDialogProgress::get_percentage(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return 0; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon->ID()); - return 0; - } - - return static_cast(handle)->GetPercentage(); -} - -void Interface_GUIDialogProgress::show_progress_bar(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - bool onOff) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->ShowProgressBar(onOff); -} - -void Interface_GUIDialogProgress::set_progress_max(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - int max) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->SetProgressMax(max); -} - -void Interface_GUIDialogProgress::set_progress_advance(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - int nSteps) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon->ID()); - return; - } - - static_cast(handle)->SetProgressAdvance(nSteps); -} - -bool Interface_GUIDialogProgress::abort(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogProgress::{} - invalid data", __func__); - return false; - } - - if (!handle) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogProgress::{} - invalid handler data (handle='{}') on addon '{}'", - __func__, handle, addon->ID()); - return false; - } - - return static_cast(handle)->Abort(); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/dialogs/Progress.h b/xbmc/addons/interfaces/gui/dialogs/Progress.h deleted file mode 100644 index ba31f3c74c1ec..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/Progress.h +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/progress.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Progress.h" - */ - struct Interface_GUIDialogProgress - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static KODI_GUI_HANDLE new_dialog(KODI_HANDLE kodiBase); - static void delete_dialog(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - static void open(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - static void set_heading(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, const char* heading); - static void set_line(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - unsigned int line, - const char* text); - static void set_can_cancel(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, bool canCancel); - static bool is_canceled(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - static void set_percentage(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, int percentage); - static int get_percentage(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - static void show_progress_bar(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, bool bOnOff); - static void set_progress_max(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, int max); - static void set_progress_advance(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, int nSteps); - static bool abort(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/dialogs/Select.cpp b/xbmc/addons/interfaces/gui/dialogs/Select.cpp deleted file mode 100644 index 7ad6ed667fd2e..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/Select.cpp +++ /dev/null @@ -1,143 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "Select.h" - -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/Select.h" -#include "dialogs/GUIDialogSelect.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUIWindowManager.h" -#include "utils/Variant.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIDialogSelect::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->dialogSelect = new AddonToKodiFuncTable_kodi_gui_dialogSelect(); - - addonInterface->toKodi->kodi_gui->dialogSelect->open = open; - addonInterface->toKodi->kodi_gui->dialogSelect->open_multi_select = open_multi_select; -} - -void Interface_GUIDialogSelect::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->dialogSelect; -} - -int Interface_GUIDialogSelect::open(KODI_HANDLE kodiBase, - const char* heading, - const char* entries[], - unsigned int size, - int selected, - unsigned int autoclose) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogSelect::{} - invalid data", __func__); - return -1; - } - - CGUIDialogSelect* dialog = - CServiceBroker::GetGUI()->GetWindowManager().GetWindow( - WINDOW_DIALOG_SELECT); - if (!heading || !entries || !dialog) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogSelect::{} - invalid handler data (heading='{}', entries='{}', " - "dialog='{}') on addon '{}'", - __func__, static_cast(heading), static_cast(entries), - static_cast(dialog), addon->ID()); - return -1; - } - - dialog->Reset(); - dialog->SetHeading(CVariant{heading}); - - for (unsigned int i = 0; i < size; ++i) - dialog->Add(entries[i]); - - if (selected > 0) - dialog->SetSelected(selected); - if (autoclose > 0) - dialog->SetAutoClose(autoclose); - - dialog->Open(); - return dialog->GetSelectedItem(); -} - - -bool Interface_GUIDialogSelect::open_multi_select(KODI_HANDLE kodiBase, - const char* heading, - const char* entryIDs[], - const char* entryNames[], - bool entriesSelected[], - unsigned int size, - unsigned int autoclose) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogMultiSelect::{} - invalid data", __func__); - return false; - } - - CGUIDialogSelect* dialog = - CServiceBroker::GetGUI()->GetWindowManager().GetWindow( - WINDOW_DIALOG_SELECT); - if (!heading || !entryIDs || !entryNames || !entriesSelected || !dialog) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogMultiSelect::{} - invalid handler data (heading='{}', " - "entryIDs='{}', entryNames='{}', entriesSelected='{}', dialog='{}') on addon '{}'", - __func__, static_cast(heading), static_cast(entryIDs), - static_cast(entryNames), static_cast(entriesSelected), - static_cast(dialog), addon->ID()); - return false; - } - - dialog->Reset(); - dialog->SetMultiSelection(true); - dialog->SetHeading(CVariant{heading}); - - std::vector selectedIndexes; - - for (unsigned int i = 0; i < size; ++i) - { - dialog->Add(entryNames[i]); - if (entriesSelected[i]) - selectedIndexes.push_back(i); - } - - dialog->SetSelected(selectedIndexes); - if (autoclose > 0) - dialog->SetAutoClose(autoclose); - - dialog->Open(); - if (dialog->IsConfirmed()) - { - for (unsigned int i = 0; i < size; ++i) - entriesSelected[i] = false; - - selectedIndexes = dialog->GetSelectedItems(); - - for (unsigned int i = 0; i < selectedIndexes.size(); ++i) - { - if (selectedIndexes[i]) - entriesSelected[selectedIndexes[i]] = true; - } - } - - return true; -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/dialogs/Select.h b/xbmc/addons/interfaces/gui/dialogs/Select.h deleted file mode 100644 index 5f2d0ef6aa72c..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/Select.h +++ /dev/null @@ -1,62 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/select.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Select.h" - */ - struct Interface_GUIDialogSelect - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static int open(KODI_HANDLE kodiBase, - const char* heading, - const char* entries[], - unsigned int size, - int selected, - unsigned int autoclose); - static bool open_multi_select(KODI_HANDLE kodiBase, - const char* heading, - const char* entryIDs[], - const char* entryNames[], - bool entriesSelected[], - unsigned int size, - unsigned int autoclose); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/dialogs/TextViewer.cpp b/xbmc/addons/interfaces/gui/dialogs/TextViewer.cpp deleted file mode 100644 index 637975a73b6cb..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/TextViewer.cpp +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "TextViewer.h" - -#include "ServiceBroker.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/TextViewer.h" -#include "dialogs/GUIDialogTextViewer.h" -#include "guilib/GUIComponent.h" -#include "guilib/GUIWindowManager.h" -#include "utils/log.h" - -namespace ADDON -{ - -void Interface_GUIDialogTextViewer::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->dialogTextViewer = - new AddonToKodiFuncTable_kodi_gui_dialogTextViewer(); - - addonInterface->toKodi->kodi_gui->dialogTextViewer->open = open; -} - -void Interface_GUIDialogTextViewer::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->dialogTextViewer; -} - -void Interface_GUIDialogTextViewer::open(KODI_HANDLE kodiBase, - const char* heading, - const char* text) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogTextViewer::{} - invalid data", __func__); - return; - } - - CGUIDialogTextViewer* dialog = - CServiceBroker::GetGUI()->GetWindowManager().GetWindow( - WINDOW_DIALOG_TEXT_VIEWER); - if (!heading || !text || !dialog) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogTextViewer::{} - invalid handler data (heading='{}', text='{}', " - "dialog='{}') on addon '{}'", - __func__, static_cast(heading), static_cast(text), - static_cast(dialog), addon->ID()); - return; - } - - dialog->SetHeading(heading); - dialog->SetText(text); - dialog->Open(); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/dialogs/TextViewer.h b/xbmc/addons/interfaces/gui/dialogs/TextViewer.h deleted file mode 100644 index 873dbbba4e0cd..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/TextViewer.h +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/text_viewer.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/TextViewer.h" - */ - struct Interface_GUIDialogTextViewer - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static void open(KODI_HANDLE kodiBase, const char* heading, const char* text); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/gui/dialogs/YesNo.cpp b/xbmc/addons/interfaces/gui/dialogs/YesNo.cpp deleted file mode 100644 index 89dea580ddede..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/YesNo.cpp +++ /dev/null @@ -1,136 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "YesNo.h" - -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/gui/dialogs/YesNo.h" -#include "dialogs/GUIDialogYesNo.h" -#include "messaging/helpers/DialogHelper.h" -#include "utils/log.h" - -using namespace KODI::MESSAGING; -using KODI::MESSAGING::HELPERS::DialogResponse; - -namespace ADDON -{ - -void Interface_GUIDialogYesNo::Init(AddonGlobalInterface* addonInterface) -{ - addonInterface->toKodi->kodi_gui->dialogYesNo = new AddonToKodiFuncTable_kodi_gui_dialogYesNo(); - - addonInterface->toKodi->kodi_gui->dialogYesNo->show_and_get_input_single_text = - show_and_get_input_single_text; - addonInterface->toKodi->kodi_gui->dialogYesNo->show_and_get_input_line_text = - show_and_get_input_line_text; - addonInterface->toKodi->kodi_gui->dialogYesNo->show_and_get_input_line_button_text = - show_and_get_input_line_button_text; -} - -void Interface_GUIDialogYesNo::DeInit(AddonGlobalInterface* addonInterface) -{ - delete addonInterface->toKodi->kodi_gui->dialogYesNo; -} - -bool Interface_GUIDialogYesNo::show_and_get_input_single_text(KODI_HANDLE kodiBase, - const char* heading, - const char* text, - bool* canceled, - const char* noLabel, - const char* yesLabel) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogYesNo::{} - invalid data", __func__); - return false; - } - - if (!heading || !text || !canceled || !noLabel || !yesLabel) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogYesNo::{} - invalid handler data (heading='{}', text='{}', " - "canceled='{}', noLabel='{}', yesLabel='{}') on addon '{}'", - __func__, static_cast(heading), static_cast(text), - static_cast(canceled), static_cast(noLabel), - static_cast(yesLabel), addon->ID()); - return false; - } - - DialogResponse result = HELPERS::ShowYesNoDialogText(heading, text, noLabel, yesLabel); - *canceled = (result == DialogResponse::CHOICE_CANCELLED); - return (result == DialogResponse::CHOICE_YES); -} - -bool Interface_GUIDialogYesNo::show_and_get_input_line_text(KODI_HANDLE kodiBase, - const char* heading, - const char* line0, - const char* line1, - const char* line2, - const char* noLabel, - const char* yesLabel) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogYesNo::{} - invalid data", __func__); - return false; - } - - if (!heading || !line0 || !line1 || !line2 || !noLabel || !yesLabel) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogYesNo::{} - invalid handler data (heading='{}', line0='{}', " - "line1='{}', line2='{}', " - "noLabel='{}', yesLabel='{}') on addon '{}'", - __func__, static_cast(heading), static_cast(line0), - static_cast(line1), static_cast(line2), - static_cast(noLabel), static_cast(yesLabel), addon->ID()); - return false; - } - - return HELPERS::ShowYesNoDialogLines(heading, line0, line1, line2, noLabel, yesLabel) == - DialogResponse::CHOICE_YES; -} - -bool Interface_GUIDialogYesNo::show_and_get_input_line_button_text(KODI_HANDLE kodiBase, - const char* heading, - const char* line0, - const char* line1, - const char* line2, - bool* canceled, - const char* noLabel, - const char* yesLabel) -{ - CAddonDll* addon = static_cast(kodiBase); - if (!addon) - { - CLog::Log(LOGERROR, "Interface_GUIDialogYesNo::{} - invalid data", __func__); - return false; - } - - if (!heading || !line0 || !line1 || !line2 || !canceled || !noLabel || !yesLabel) - { - CLog::Log(LOGERROR, - "Interface_GUIDialogYesNo::{} - invalid handler data (heading='{}', line0='{}', " - "line1='{}', line2='{}', " - "canceled='{}', noLabel='{}', yesLabel='{}') on addon '{}'", - __func__, static_cast(heading), static_cast(line0), - static_cast(line1), static_cast(line2), - static_cast(canceled), static_cast(noLabel), - static_cast(yesLabel), addon->ID()); - return false; - } - - DialogResponse result = - HELPERS::ShowYesNoDialogLines(heading, line0, line1, line2, noLabel, yesLabel); - *canceled = (result == DialogResponse::CHOICE_CANCELLED); - return (result == DialogResponse::CHOICE_YES); -} - -} /* namespace ADDON */ diff --git a/xbmc/addons/interfaces/gui/dialogs/YesNo.h b/xbmc/addons/interfaces/gui/dialogs/YesNo.h deleted file mode 100644 index 84e5d73bb77f0..0000000000000 --- a/xbmc/addons/interfaces/gui/dialogs/YesNo.h +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/yes_no.h" - -extern "C" -{ - - struct AddonGlobalInterface; - - namespace ADDON - { - - /*! - * @brief Global gui Add-on to Kodi callback functions - * - * To hold functions not related to a instance type and usable for - * every add-on type. - * - * Related add-on header is "./xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/YesNo.h" - */ - struct Interface_GUIDialogYesNo - { - static void Init(AddonGlobalInterface* addonInterface); - static void DeInit(AddonGlobalInterface* addonInterface); - - /*! - * @brief callback functions from add-on to kodi - * - * @note To add a new function use the "_" style to directly identify an - * add-on callback function. Everything with CamelCase is only to be used - * in Kodi. - * - * The parameter `kodiBase` is used to become the pointer for a `CAddonDll` - * class. - */ - //@{ - static bool show_and_get_input_single_text(KODI_HANDLE kodiBase, - const char* heading, - const char* text, - bool* canceled, - const char* noLabel, - const char* yesLabel); - - static bool show_and_get_input_line_text(KODI_HANDLE kodiBase, - const char* heading, - const char* line0, - const char* line1, - const char* line2, - const char* noLabel, - const char* yesLabel); - - static bool show_and_get_input_line_button_text(KODI_HANDLE kodiBase, - const char* heading, - const char* line0, - const char* line1, - const char* line2, - bool* canceled, - const char* noLabel, - const char* yesLabel); - //@} - }; - - } /* namespace ADDON */ -} /* extern "C" */ diff --git a/xbmc/addons/interfaces/platform/android/System.cpp b/xbmc/addons/interfaces/platform/android/System.cpp deleted file mode 100644 index 3203075309c45..0000000000000 --- a/xbmc/addons/interfaces/platform/android/System.cpp +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#include "System.h" - -#include "CompileInfo.h" -#include "addons/binary-addons/AddonDll.h" -#include "addons/kodi-dev-kit/include/kodi/platform/android/System.h" - -#include "platform/android/activity/XBMCApp.h" - -static AddonToKodiFuncTable_android_system function_table; - -namespace ADDON -{ - -void Interface_Android::Register() -{ - function_table.get_jni_env = get_jni_env; - function_table.get_sdk_version = get_sdk_version; - function_table.get_class_name = get_class_name; - Interface_Base::RegisterInterface(Get); -} - -void* Interface_Android::Get(const std::string &name, const std::string &version) -{ - if (name == INTERFACE_ANDROID_SYSTEM_NAME - && version >= INTERFACE_ANDROID_SYSTEM_VERSION_MIN - && version <= INTERFACE_ANDROID_SYSTEM_VERSION) - return &function_table; - - return nullptr; -}; - -void* Interface_Android::get_jni_env() -{ - return xbmc_jnienv(); -} - -int Interface_Android::get_sdk_version() -{ - return CXBMCApp::Get().GetSDKVersion(); -} - -const char *Interface_Android::get_class_name() -{ - return CCompileInfo::GetClass(); -} - - -} //namespace ADDON diff --git a/xbmc/addons/interfaces/platform/android/System.h b/xbmc/addons/interfaces/platform/android/System.h deleted file mode 100644 index 59805abcbbcf8..0000000000000 --- a/xbmc/addons/interfaces/platform/android/System.h +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include - -namespace ADDON -{ - -struct Interface_Android -{ - static void Register(); - static void* Get(const std::string &name, const std::string &version); - - static void* get_jni_env(); - static int get_sdk_version(); - static const char *get_class_name(); -}; - -} //namespace ADDON diff --git a/xbmc/addons/kodi-dev-kit/.gitignore b/xbmc/addons/kodi-dev-kit/.gitignore index 0256029dbb3ee..ae448b83ec11a 100644 --- a/xbmc/addons/kodi-dev-kit/.gitignore +++ b/xbmc/addons/kodi-dev-kit/.gitignore @@ -34,3 +34,4 @@ /include/groups.dox /tools/code-generator/creation_log.txt /tools/code-generator/creation_log.txt.old +/tools/code-generator/tmp diff --git a/xbmc/addons/kodi-dev-kit/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/CMakeLists.txt index 4b539b24f62a8..c8ac327eda09c 100644 --- a/xbmc/addons/kodi-dev-kit/CMakeLists.txt +++ b/xbmc/addons/kodi-dev-kit/CMakeLists.txt @@ -1,4 +1,8 @@ cmake_minimum_required(VERSION 3.5) project(kodi-dev-kit) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) + include(cmake/test/abi-interface-test.cmake) + +#add_subdirectory(src) diff --git a/xbmc/addons/kodi-dev-kit/cmake/Macros.cmake b/xbmc/addons/kodi-dev-kit/cmake/Macros.cmake new file mode 100644 index 0000000000000..03cb85673c2ad --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/cmake/Macros.cmake @@ -0,0 +1,25 @@ +include(../../../../../cmake/scripts/common/Macros.cmake) + +macro(devkit_add_object name) + add_library(${name} OBJECT ${SOURCES} ${HEADERS}) + set_target_properties(${name} PROPERTIES C_VISIBILITY_PRESET hidden + CXX_VISIBILITY_PRESET hidden + VISIBILITY_INLINES_HIDDEN ON + POSITION_INDEPENDENT_CODE ON) + set(DEVKIT_OBJECTS $ ${DEVKIT_OBJECTS} PARENT_SCOPE) +endmacro() + +# +# Removes the specified compile flag from the specified target. +# _target - The target to remove the compile flag from +# _flag - The compile flag to remove +# +# Pre: apply_global_cxx_flags_to_all_targets() must be invoked. +# +macro(remove_flag_from_target _target _flag) + get_target_property(_target_cxx_flags ${_target} COMPILE_OPTIONS) + if(_target_cxx_flags) + list(REMOVE_ITEM _target_cxx_flags ${_flag}) + set_target_properties(${_target} PROPERTIES COMPILE_OPTIONS "${_target_cxx_flags}") + endif() +endmacro() diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/AddonBase.h b/xbmc/addons/kodi-dev-kit/include/kodi/AddonBase.h index a626122042f0b..ac6c61cb06339 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/AddonBase.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/AddonBase.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2018 Team Kodi + * Copyright (C) 2005-2021 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later @@ -9,26 +9,26 @@ #pragma once #include "c-api/addon_base.h" -#include "versions.h" - -#include /* assert */ -#include /* va_list, va_start, va_arg, va_end */ +#include "c-api/dl/kodi_api_1.h" #ifdef __cplusplus -#include +#include #include -#include #include -#include #include -#include +#include -#include "tools/StringUtils.h" +#include +#include namespace kodi { +using AddonLog = ADDON_LOG; + +class dl; + namespace gui { struct IRenderHelper; @@ -65,16 +65,6 @@ using HardwareContext = ADDON_HARDWARE_CONTEXT; namespace addon { -/*! - * @brief Internal used structure to have stored C API data above and - * available for everything below. - */ -struct ATTR_DLL_LOCAL CPrivateBase -{ - // Interface function table to hold addresses on add-on and from kodi - static AddonGlobalInterface* m_interface; -}; - /* * Internally used helper class to manage processing of a "C" structure in "CPP" * class. @@ -289,12 +279,9 @@ class ATTR_DLL_LOCAL CSettingValue return static_cast(GetInt()); } - ///@} - private: const std::string str; }; -///@} //------------------------------------------------------------------------------ //============================================================================== @@ -307,8 +294,6 @@ class ATTR_DLL_LOCAL CSettingValue class ATTR_DLL_LOCAL IInstanceInfo { public: - explicit IInstanceInfo(KODI_ADDON_INSTANCE_STRUCT* instance) : m_instance(instance) {} - /// @defgroup cpp_kodi_addon_addonbase_Defs_IInstanceInfo_Help Value Help /// @ingroup cpp_kodi_addon_addonbase_Defs_IInstanceInfo /// @@ -326,41 +311,132 @@ class ATTR_DLL_LOCAL IInstanceInfo ///@{ /// @brief To get settings value as string. - KODI_ADDON_INSTANCE_TYPE GetType() const { return m_instance->info->type; } + KODI_ADDON_INSTANCE_TYPE GetType() const { return m_type; } /// @brief Check asked type used on this class. /// /// @param[in] type Type identifier to check /// @return True if type matches - bool IsType(KODI_ADDON_INSTANCE_TYPE type) const { return m_instance->info->type == type; } + bool IsType(KODI_ADDON_INSTANCE_TYPE type) const { return m_type == type; } /// @brief Get optional identification number (usage relate to addon type). - uint32_t GetNumber() const { return m_instance->info->number; } + uint32_t GetInstanceID() const { return m_instance_id; } /// @brief Get optional identification string (usage relate to addon type). - std::string GetID() const { return m_instance->info->id; } + std::string GetUniqueWorkID() const { return m_unique_work_id; } - /// @brief Get API version from Kodi about instance. - std::string GetAPIVersion() const { return m_instance->info->version; } - - /// @brief Check this is first created instance by Kodi. - bool FirstInstance() const { return m_instance->info->first_instance; } + KODI_ADDON_INSTANCE_BACKEND_HDL GetKodiHdl() const { return m_kodi; } + KODI_ADDON_INSTANCE_HDL GetParentHdl() const { return m_parent; } ///@} - operator KODI_ADDON_INSTANCE_STRUCT*() { return m_instance; } +private: + friend class CAddonBase; + friend class IAddonInstance; + friend class kodi::dl; - operator KODI_ADDON_INSTANCE_STRUCT*() const { return m_instance; } + IInstanceInfo() = default; + explicit IInstanceInfo(const KODI_ADDON_INSTANCE_INFO* instance) + { + *this = instance; + } -private: - IInstanceInfo() = delete; - IInstanceInfo(const IInstanceInfo&) = delete; + const IInstanceInfo& operator=(const KODI_ADDON_INSTANCE_INFO* right) + { + assert(right); + + m_type = right->type; + m_instance_id = right->instance_id; + m_unique_work_id = right->unique_work_id; + m_kodi = right->kodi; + m_parent = right->parent; + + return *this; + } - KODI_ADDON_INSTANCE_STRUCT* m_instance; + KODI_ADDON_INSTANCE_TYPE m_type{ADDON_INSTANCE_UNKNOWN}; + uint32_t m_instance_id{0}; + std::string m_unique_work_id; + KODI_ADDON_INSTANCE_BACKEND_HDL m_kodi{nullptr}; + KODI_ADDON_INSTANCE_HDL m_parent{nullptr}; }; ///@} //------------------------------------------------------------------------------ +class IAddonInstance; +class CAddonBase; + +} /* namespace addon */ + +class ATTR_DLL_LOCAL dl +{ +public: + static inline std::string get_kodi_lib_path(int argc, char* argv[]) + { + std::string main_shared; + + for (int i = 1; i < argc; ++i) + { + if (argv[i] == nullptr) + break; + + std::string arg = argv[i]; + if (arg.rfind("--dl=", 0) == 0) + { + main_shared = arg.substr(strlen("--dl=")); + break; + } + else if ((arg == "-l") || (arg == "--dl")) + { + if (i + 1 < argc) // Make sure we aren't at the end of argv! + { + main_shared = + argv[++i]; // Increment 'i' so we don't get the argument as the next argv[i]. + break; + } + } + } + + return main_shared; + } + + static inline bool LoadDll(int argc, char** argv) + { + const std::string libPath = get_kodi_lib_path(argc, argv); + local.dll = dlopen(libPath.c_str(), RTLD_LAZY | RTLD_GLOBAL); + if (local.dll == nullptr) + return false; + + bool (*load_kodi_api_1)(struct kodi_api_1*) = + reinterpret_cast(dlsym(local.dll, "load_kodi_api_1")); + if (!load_kodi_api_1 || !load_kodi_api_1(&api)) + { + fprintf(stderr, "FATAL: Failed to load required kodi dev kit lib '%s'!\n", libPath.c_str()); + dlclose(local.dll); + return false; + } + + return true; + } + + static inline void UnloadDll() { dlclose(local.dll); } + + static kodi_api_1 api; + static KODI_IFC_HDL hdl; + + struct LOCAL + { + KODI_DLL_HDL dll; + + kodi::addon::IAddonInstance* globalSingleInstance; + kodi::addon::IInstanceInfo firstKodiInstance; + kodi::addon::CAddonBase* addonBase; + } static local; +}; + +namespace addon +{ + //============================================================================== /* * Internal class to control various instance types with general parts defined @@ -374,14 +450,16 @@ class ATTR_DLL_LOCAL IInstanceInfo class ATTR_DLL_LOCAL IAddonInstance { public: - explicit IAddonInstance(const kodi::addon::IInstanceInfo& instance) : m_instance(instance) + IAddonInstance() + : m_instanceInfo(kodi::dl::local.firstKodiInstance), + m_kodi(kodi::dl::local.firstKodiInstance.GetKodiHdl()) + { + kodi::dl::local.globalSingleInstance = this; + } + + explicit IAddonInstance(const kodi::addon::IInstanceInfo& instance) + : m_instanceInfo(instance), m_kodi(instance.GetKodiHdl()) { - m_instance->functions->instance_setting_change_string = INSTANCE_instance_setting_change_string; - m_instance->functions->instance_setting_change_integer = - INSTANCE_instance_setting_change_integer; - m_instance->functions->instance_setting_change_boolean = - INSTANCE_instance_setting_change_boolean; - m_instance->functions->instance_setting_change_float = INSTANCE_instance_setting_change_float; } virtual ~IAddonInstance() = default; @@ -391,7 +469,7 @@ class ATTR_DLL_LOCAL IAddonInstance return ADDON_STATUS_NOT_IMPLEMENTED; } - std::string GetInstanceAPIVersion() const { return m_instance->info->version; } + virtual void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) = 0; virtual ADDON_STATUS SetInstanceSetting(const std::string& settingName, const kodi::addon::CSettingValue& settingValue) @@ -401,19 +479,18 @@ class ATTR_DLL_LOCAL IAddonInstance inline bool IsInstanceSettingUsingDefault(const std::string& settingName) { - return m_instance->info->functions->is_instance_setting_using_default(m_instance->info->kodi, - settingName.c_str()); + return kodi::dl::api.kodi_addon_instance_is_setting_using_default(m_kodi, settingName.c_str()); } inline std::string GetInstanceUserPath(const std::string& append = "") { - using namespace kodi::addon; + char* str = kodi::dl::api.kodi_addon_instance_get_user_path(m_kodi); + if (!str) + return ""; - char* str = m_instance->info->functions->get_instance_user_path( - CPrivateBase::m_interface->toKodi->kodiBase); std::string ret = str; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - str); + free(str); + if (!append.empty()) { if (append.at(0) != '\\' && append.at(0) != '/') @@ -430,8 +507,7 @@ class ATTR_DLL_LOCAL IAddonInstance inline bool CheckInstanceSettingString(const std::string& settingName, std::string& settingValue) { char* buffer = nullptr; - bool ret = m_instance->info->functions->get_instance_setting_string( - m_instance->info->kodi, settingName.c_str(), &buffer); + bool ret = kodi::dl::api.kodi_addon_instance_get_setting_string(m_kodi, settingName.c_str(), &buffer); if (buffer) { if (ret) @@ -452,14 +528,13 @@ class ATTR_DLL_LOCAL IAddonInstance inline void SetInstanceSettingString(const std::string& settingName, const std::string& settingValue) { - m_instance->info->functions->set_instance_setting_string( - m_instance->info->kodi, settingName.c_str(), settingValue.c_str()); + kodi::dl::api.kodi_addon_instance_set_setting_string(m_kodi, settingName.c_str(), + settingValue.c_str()); } inline bool CheckInstanceSettingInt(const std::string& settingName, int& settingValue) { - KODI_ADDON_INSTANCE_FUNC_CB* cb = m_instance->info->functions; - return cb->get_instance_setting_int(m_instance->info->kodi, settingName.c_str(), &settingValue); + return kodi::dl::api.kodi_addon_instance_get_setting_int(m_kodi, settingName.c_str(), &settingValue); } inline int GetInstanceSettingInt(const std::string& settingName, int defaultValue = 0) @@ -471,14 +546,12 @@ class ATTR_DLL_LOCAL IAddonInstance inline void SetInstanceSettingInt(const std::string& settingName, int settingValue) { - m_instance->info->functions->set_instance_setting_int(m_instance->info->kodi, - settingName.c_str(), settingValue); + kodi::dl::api.kodi_addon_instance_set_setting_int(m_kodi, settingName.c_str(), settingValue); } inline bool CheckInstanceSettingBoolean(const std::string& settingName, bool& settingValue) { - return m_instance->info->functions->get_instance_setting_bool( - m_instance->info->kodi, settingName.c_str(), &settingValue); + return kodi::dl::api.kodi_addon_instance_get_setting_bool(m_kodi, settingName.c_str(), &settingValue); } inline bool GetInstanceSettingBoolean(const std::string& settingName, bool defaultValue = false) @@ -490,27 +563,24 @@ class ATTR_DLL_LOCAL IAddonInstance inline void SetInstanceSettingBoolean(const std::string& settingName, bool settingValue) { - m_instance->info->functions->set_instance_setting_bool(m_instance->info->kodi, - settingName.c_str(), settingValue); + kodi::dl::api.kodi_addon_instance_set_setting_bool(m_kodi, settingName.c_str(), settingValue); } - inline bool CheckInstanceSettingFloat(const std::string& settingName, float& settingValue) + inline bool CheckInstanceSettingFloat(const std::string& settingName, double& settingValue) { - return m_instance->info->functions->get_instance_setting_float( - m_instance->info->kodi, settingName.c_str(), &settingValue); + return kodi::dl::api.kodi_addon_instance_get_setting_float(m_kodi, settingName.c_str(), &settingValue); } - inline float GetInstanceSettingFloat(const std::string& settingName, float defaultValue = 0.0f) + inline double GetInstanceSettingFloat(const std::string& settingName, double defaultValue = 0.0) { - float settingValue = defaultValue; + double settingValue = defaultValue; CheckInstanceSettingFloat(settingName, settingValue); return settingValue; } - inline void SetInstanceSettingFloat(const std::string& settingName, float settingValue) + inline void SetInstanceSettingFloat(const std::string& settingName, double settingValue) { - m_instance->info->functions->set_instance_setting_float(m_instance->info->kodi, - settingName.c_str(), settingValue); + kodi::dl::api.kodi_addon_instance_set_setting_float(m_kodi, settingName.c_str(), settingValue); } template @@ -519,8 +589,8 @@ class ATTR_DLL_LOCAL IAddonInstance using namespace kodi::addon; int settingValueInt = static_cast(settingValue); - bool ret = m_instance->info->functions->get_instance_setting_int( - m_instance->info->kodi, settingName.c_str(), &settingValueInt); + bool ret = + kodi::dl::api.kodi_addon_instance_get_setting_int(m_kodi, settingName.c_str(), &settingValueInt); if (ret) settingValue = static_cast(settingValueInt); return ret; @@ -538,41 +608,58 @@ class ATTR_DLL_LOCAL IAddonInstance template inline void SetInstanceSettingEnum(const std::string& settingName, enumType settingValue) { - m_instance->info->functions->set_instance_setting_int( - m_instance->info->kodi, settingName.c_str(), static_cast(settingValue)); + kodi::dl::api.kodi_addon_instance_set_setting_int(m_kodi, settingName.c_str(), + static_cast(settingValue)); } + const kodi::addon::IInstanceInfo& GetInfo() const { return m_instanceInfo; } + KODI_ADDON_INSTANCE_BACKEND_HDL GetBackendInstanceHdl() const { return m_kodi; } + +protected: + kodi::addon::IInstanceInfo m_instanceInfo; + KODI_ADDON_INSTANCE_BACKEND_HDL m_kodi; + private: + friend class CAddonBase; + static inline ADDON_STATUS INSTANCE_instance_setting_change_string( - const KODI_ADDON_INSTANCE_HDL hdl, const char* name, const char* value) + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + const char* value) { return static_cast(hdl)->SetInstanceSetting(name, CSettingValue(value)); } static inline ADDON_STATUS INSTANCE_instance_setting_change_boolean( - const KODI_ADDON_INSTANCE_HDL hdl, const char* name, bool value) + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + bool value) { return static_cast(hdl)->SetInstanceSetting(name, CSettingValue(value ? "1" : "0")); } static inline ADDON_STATUS INSTANCE_instance_setting_change_integer( - const KODI_ADDON_INSTANCE_HDL hdl, const char* name, int value) + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + int value) { return static_cast(hdl)->SetInstanceSetting( name, CSettingValue(std::to_string(value))); } static inline ADDON_STATUS INSTANCE_instance_setting_change_float( - const KODI_ADDON_INSTANCE_HDL hdl, const char* name, float value) + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + double value) { return static_cast(hdl)->SetInstanceSetting( name, CSettingValue(std::to_string(value))); } - - friend class CAddonBase; - - const KODI_ADDON_INSTANCE_STRUCT* m_instance; }; //============================================================================ @@ -588,17 +675,7 @@ class ATTR_DLL_LOCAL CAddonBase /// @ingroup cpp_kodi_addon_addonbase /// @brief Addon base class constructor. /// - CAddonBase() - { - CPrivateBase::m_interface->toAddon->create = nullptr; - CPrivateBase::m_interface->toAddon->destroy = ADDONBASE_Destroy; - CPrivateBase::m_interface->toAddon->create_instance = ADDONBASE_CreateInstance; - CPrivateBase::m_interface->toAddon->destroy_instance = ADDONBASE_DestroyInstance; - CPrivateBase::m_interface->toAddon->setting_change_string = ADDONBASE_setting_change_string; - CPrivateBase::m_interface->toAddon->setting_change_boolean = ADDONBASE_setting_change_boolean; - CPrivateBase::m_interface->toAddon->setting_change_integer = ADDONBASE_setting_change_integer; - CPrivateBase::m_interface->toAddon->setting_change_float = ADDONBASE_setting_change_float; - } + CAddonBase() = default; //---------------------------------------------------------------------------- //============================================================================ @@ -757,34 +834,69 @@ class ATTR_DLL_LOCAL CAddonBase /* Background helper for GUI render systems, e.g. Screensaver or Visualization */ std::shared_ptr m_renderHelper; + static KODI_ADDON_FUNC GetAddonFunctions() + { + KODI_ADDON_FUNC func = {ADDONBASE_create, + ADDONBASE_destroy, + + ADDONBASE_setting_change_string, + ADDONBASE_setting_change_boolean, + ADDONBASE_setting_change_integer, + ADDONBASE_setting_change_float, + + ADDONBASE_create_instance, + ADDONBASE_destroy_instance, + + IAddonInstance::INSTANCE_instance_setting_change_string, + IAddonInstance::INSTANCE_instance_setting_change_boolean, + IAddonInstance::INSTANCE_instance_setting_change_integer, + IAddonInstance::INSTANCE_instance_setting_change_float}; + return func; + } + private: - static inline void ADDONBASE_Destroy(const KODI_ADDON_HDL hdl) + static ADDON_STATUS ADDONBASE_create(const struct KODI_ADDON_INSTANCE_INFO* first_instance, KODI_ADDON_HDL* hdl); + + static inline void ADDONBASE_destroy(const KODI_ADDON_HDL hdl) { delete static_cast(hdl); + kodi::dl::local.globalSingleInstance = nullptr; + kodi::dl::local.addonBase = nullptr; } - static inline ADDON_STATUS ADDONBASE_CreateInstance(const KODI_ADDON_HDL hdl, - struct KODI_ADDON_INSTANCE_STRUCT* instance) + static inline ADDON_STATUS ADDONBASE_create_instance(const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + struct KODI_ADDON_INSTANCE_STRUCT* instance) { + ADDON_STATUS status = ADDON_STATUS_NOT_IMPLEMENTED; + CAddonBase* base = static_cast(hdl); + if (base == nullptr || info == nullptr || instance == nullptr) + { + kodi::dl::api.kodi_log( + ADDON_LOG_FATAL, + "kodi::addon::CAddonBase CreateInstance called with empty instance memory"); + return ADDON_STATUS_PERMANENT_FAILURE; + } - ADDON_STATUS status = ADDON_STATUS_NOT_IMPLEMENTED; + IAddonInstance* instanceHdl = nullptr; /* Check about single instance usage: * 1. The kodi side instance pointer must be equal to first one * 2. The addon side instance pointer must be set * 3. And the requested type must be equal with used add-on class */ - if (CPrivateBase::m_interface->firstKodiInstance == instance && - CPrivateBase::m_interface->globalSingleInstance && - static_cast(CPrivateBase::m_interface->globalSingleInstance) - ->m_instance->info->type == instance->info->type) + if (kodi::dl::local.globalSingleInstance && + kodi::dl::local.globalSingleInstance->GetInfo().GetType() == info->type && + kodi::dl::local.globalSingleInstance->GetInfo().GetKodiHdl() == info->kodi) { /* The handling here is intended for the case of the add-on only one * instance and this is integrated in the add-on base class. */ - instance->hdl = CPrivateBase::m_interface->globalSingleInstance; status = ADDON_STATUS_OK; + + instanceHdl = kodi::dl::local.globalSingleInstance; + instance->hdl = instanceHdl; } else { @@ -792,28 +904,40 @@ class ATTR_DLL_LOCAL CAddonBase * creation of several on one addon. */ - IInstanceInfo instanceInfo(instance); + IInstanceInfo instanceInfo(info); /* Check first a parent is defined about (e.g. Codec within inputstream) */ - if (instance->info->parent != nullptr) - status = static_cast(instance->info->parent) - ->CreateInstance(instanceInfo, instance->hdl); + if (info->parent != nullptr) + status = + static_cast(info->parent)->CreateInstance(instanceInfo, instance->hdl); /* if no parent call the main instance creation function to get it */ if (status == ADDON_STATUS_NOT_IMPLEMENTED) { + if (kodi::dl::local.globalSingleInstance != nullptr) + { + kodi::dl::api.kodi_log(ADDON_LOG_FATAL, + "kodi::addon::CAddonBase Creation of multiple together with " + "single instance way is not allowed!"); + return ADDON_STATUS_PERMANENT_FAILURE; + } status = base->CreateInstance(instanceInfo, instance->hdl); } + + instanceHdl = static_cast(instance->hdl); } - if (instance->hdl == nullptr) + if (instanceHdl != nullptr) + { + instanceHdl->SetAddonStruct(instance); + } + else { if (status == ADDON_STATUS_OK) { - CPrivateBase::m_interface->toKodi->addon_log_msg( - CPrivateBase::m_interface->toKodi->kodiBase, ADDON_LOG_FATAL, - "kodi::addon::CAddonBase CreateInstance returned an " - "empty instance pointer, but reported OK!"); + kodi::dl::api.kodi_log(ADDON_LOG_FATAL, + "kodi::addon::CAddonBase CreateInstance returned an " + "empty instance pointer, but reported OK!"); return ADDON_STATUS_PERMANENT_FAILURE; } else @@ -822,10 +946,10 @@ class ATTR_DLL_LOCAL CAddonBase } } - if (static_cast(instance->hdl)->m_instance->info->type != instance->info->type) + if (instanceHdl->GetInfo().GetType() != info->type) { - CPrivateBase::m_interface->toKodi->addon_log_msg( - CPrivateBase::m_interface->toKodi->kodiBase, ADDON_LOG_FATAL, + kodi::dl::api.kodi_log( + ADDON_LOG_FATAL, "kodi::addon::CAddonBase CreateInstance difference between given and returned"); delete static_cast(instance->hdl); instance->hdl = nullptr; @@ -835,16 +959,17 @@ class ATTR_DLL_LOCAL CAddonBase return status; } - static inline void ADDONBASE_DestroyInstance(const KODI_ADDON_HDL hdl, - struct KODI_ADDON_INSTANCE_STRUCT* instance) + static inline void ADDONBASE_destroy_instance(const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + const KODI_ADDON_INSTANCE_HDL instance_hdl) { CAddonBase* base = static_cast(hdl); - if (CPrivateBase::m_interface->globalSingleInstance == nullptr && instance->hdl != base) + if (kodi::dl::local.globalSingleInstance == nullptr && instance_hdl != base) { - IInstanceInfo instanceInfo(instance); - base->DestroyInstance(instanceInfo, instance->hdl); - delete static_cast(instance->hdl); + IInstanceInfo instanceInfo(info); + base->DestroyInstance(instanceInfo, instance_hdl); + delete static_cast(instance_hdl); } } @@ -871,7 +996,7 @@ class ATTR_DLL_LOCAL CAddonBase static inline ADDON_STATUS ADDONBASE_setting_change_float(const KODI_ADDON_HDL hdl, const char* name, - float value) + double value) { return static_cast(hdl)->SetSetting(name, CSettingValue(std::to_string(value))); } @@ -886,12 +1011,9 @@ class ATTR_DLL_LOCAL CAddonBase /// inline std::string ATTR_DLL_LOCAL GetAddonPath(const std::string& append = "") { - using namespace kodi::addon; - - char* str = CPrivateBase::m_interface->toKodi->kodi_addon->get_addon_path( - CPrivateBase::m_interface->toKodi->kodiBase); + char* str = kodi::dl::api.kodi_addon_get_addon_path(); std::string ret = str; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, str); + free(str); if (!append.empty()) { if (append.at(0) != '\\' && append.at(0) != '/') @@ -923,12 +1045,9 @@ inline std::string ATTR_DLL_LOCAL GetAddonPath(const std::string& append = "") /// inline std::string ATTR_DLL_LOCAL GetLibPath(const std::string& append = "") { - using namespace kodi::addon; - - char* str = CPrivateBase::m_interface->toKodi->kodi_addon->get_lib_path( - CPrivateBase::m_interface->toKodi->kodiBase); + char* str = kodi_addon_get_lib_path(); std::string ret = str; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, str); + free(str); if (!append.empty()) { if (append.at(0) != '\\' && append.at(0) != '/') @@ -955,12 +1074,9 @@ inline std::string ATTR_DLL_LOCAL GetLibPath(const std::string& append = "") /// inline std::string ATTR_DLL_LOCAL GetUserPath(const std::string& append = "") { - using namespace kodi::addon; - - char* str = CPrivateBase::m_interface->toKodi->kodi_addon->get_user_path( - CPrivateBase::m_interface->toKodi->kodiBase); + char* str = kodi::dl::api.kodi_addon_get_user_path(); std::string ret = str; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, str); + free(str); if (!append.empty()) { if (append.at(0) != '\\' && append.at(0) != '/') @@ -988,12 +1104,9 @@ inline std::string ATTR_DLL_LOCAL GetUserPath(const std::string& append = "") /// inline std::string ATTR_DLL_LOCAL GetTempPath(const std::string& append = "") { - using namespace kodi::addon; - - char* str = CPrivateBase::m_interface->toKodi->kodi_addon->get_temp_path( - CPrivateBase::m_interface->toKodi->kodiBase); + char* str = kodi::dl::api.kodi_addon_get_temp_path(); std::string ret = str; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, str); + free(str); if (!append.empty()) { if (append.at(0) != '\\' && append.at(0) != '/') @@ -1038,23 +1151,18 @@ inline std::string ATTR_DLL_LOCAL GetTempPath(const std::string& append = "") inline std::string ATTR_DLL_LOCAL GetLocalizedString(uint32_t labelId, const std::string& defaultStr = "") { - using namespace kodi::addon; - std::string retString = defaultStr; - char* strMsg = CPrivateBase::m_interface->toKodi->kodi_addon->get_localized_string( - CPrivateBase::m_interface->toKodi->kodiBase, labelId); + char* strMsg = kodi::dl::api.kodi_get_localized_string(labelId); if (strMsg != nullptr) { if (std::strlen(strMsg)) retString = strMsg; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - strMsg); + free(strMsg); } return retString; } //------------------------------------------------------------------------------ - //############################################################################## /// @ingroup cpp_kodi_addon /// @defgroup cpp_kodi_settings 1. Setting control @@ -1087,9 +1195,7 @@ inline std::string ATTR_DLL_LOCAL GetLocalizedString(uint32_t labelId, /// inline bool ATTR_DLL_LOCAL OpenSettings() { - using namespace kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_addon->open_settings_dialog( - CPrivateBase::m_interface->toKodi->kodiBase); + return kodi::dl::api.kodi_addon_open_settings_dialog(); } //------------------------------------------------------------------------------ @@ -1103,9 +1209,7 @@ inline bool ATTR_DLL_LOCAL OpenSettings() /// inline bool ATTR_DLL_LOCAL IsSettingUsingDefault(const std::string& settingName) { - using namespace kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_addon->is_setting_using_default( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str()); + return kodi::dl::api.kodi_addon_is_setting_using_default(settingName.c_str()); } //------------------------------------------------------------------------------ @@ -1135,17 +1239,13 @@ inline bool ATTR_DLL_LOCAL IsSettingUsingDefault(const std::string& settingName) inline bool ATTR_DLL_LOCAL CheckSettingString(const std::string& settingName, std::string& settingValue) { - using namespace kodi::addon; - char* buffer = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_addon->get_setting_string( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), &buffer); + bool ret = kodi::dl::api.kodi_addon_get_setting_string(settingName.c_str(), &buffer); if (buffer) { if (ret) settingValue = buffer; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - buffer); + free(buffer); } return ret; } @@ -1201,10 +1301,7 @@ inline std::string ATTR_DLL_LOCAL GetSettingString(const std::string& settingNam inline void ATTR_DLL_LOCAL SetSettingString(const std::string& settingName, const std::string& settingValue) { - using namespace kodi::addon; - - CPrivateBase::m_interface->toKodi->kodi_addon->set_setting_string( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), settingValue.c_str()); + kodi::dl::api.kodi_addon_set_setting_string(settingName.c_str(), settingValue.c_str()); } //------------------------------------------------------------------------------ @@ -1233,10 +1330,7 @@ inline void ATTR_DLL_LOCAL SetSettingString(const std::string& settingName, /// inline bool ATTR_DLL_LOCAL CheckSettingInt(const std::string& settingName, int& settingValue) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_addon->get_setting_int( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValue); + return kodi::dl::api.kodi_addon_get_setting_int(settingName.c_str(), &settingValue); } //------------------------------------------------------------------------------ @@ -1288,10 +1382,7 @@ inline int ATTR_DLL_LOCAL GetSettingInt(const std::string& settingName, int defa /// inline void ATTR_DLL_LOCAL SetSettingInt(const std::string& settingName, int settingValue) { - using namespace kodi::addon; - - CPrivateBase::m_interface->toKodi->kodi_addon->set_setting_int( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), settingValue); + kodi::dl::api.kodi_addon_set_setting_int(settingName.c_str(), settingValue); } //------------------------------------------------------------------------------ @@ -1320,10 +1411,7 @@ inline void ATTR_DLL_LOCAL SetSettingInt(const std::string& settingName, int set /// inline bool ATTR_DLL_LOCAL CheckSettingBoolean(const std::string& settingName, bool& settingValue) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_addon->get_setting_bool( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValue); + return kodi::dl::api.kodi_addon_get_setting_bool(settingName.c_str(), &settingValue); } //------------------------------------------------------------------------------ @@ -1376,10 +1464,7 @@ inline bool ATTR_DLL_LOCAL GetSettingBoolean(const std::string& settingName, /// inline void ATTR_DLL_LOCAL SetSettingBoolean(const std::string& settingName, bool settingValue) { - using namespace kodi::addon; - - CPrivateBase::m_interface->toKodi->kodi_addon->set_setting_bool( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), settingValue); + kodi::dl::api.kodi_addon_set_setting_bool(settingName.c_str(), settingValue); } //------------------------------------------------------------------------------ @@ -1406,12 +1491,9 @@ inline void ATTR_DLL_LOCAL SetSettingBoolean(const std::string& settingName, boo /// value = 1.0f; // My default of them /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL CheckSettingFloat(const std::string& settingName, float& settingValue) +inline bool ATTR_DLL_LOCAL CheckSettingFloat(const std::string& settingName, double& settingValue) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_addon->get_setting_float( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValue); + return kodi::dl::api.kodi_addon_get_setting_float(settingName.c_str(), &settingValue); } //------------------------------------------------------------------------------ @@ -1431,13 +1513,13 @@ inline bool ATTR_DLL_LOCAL CheckSettingFloat(const std::string& settingName, flo /// ~~~~~~~~~~~~~{.cpp} /// #include /// -/// float value = kodi::GetSettingFloat("my_float_value"); +/// double value = kodi::GetSettingFloat("my_float_value"); /// ~~~~~~~~~~~~~ /// inline float ATTR_DLL_LOCAL GetSettingFloat(const std::string& settingName, - float defaultValue = 0.0f) + double defaultValue = 0.0f) { - float settingValue = defaultValue; + double settingValue = defaultValue; CheckSettingFloat(settingName, settingValue); return settingValue; } @@ -1458,16 +1540,13 @@ inline float ATTR_DLL_LOCAL GetSettingFloat(const std::string& settingName, /// ~~~~~~~~~~~~~{.cpp} /// #include /// -/// float value = 1.0f; +/// double value = 1.0f; /// kodi::SetSettingFloat("my_float_value", value); /// ~~~~~~~~~~~~~ /// -inline void ATTR_DLL_LOCAL SetSettingFloat(const std::string& settingName, float settingValue) +inline void ATTR_DLL_LOCAL SetSettingFloat(const std::string& settingName, double settingValue) { - using namespace kodi::addon; - - CPrivateBase::m_interface->toKodi->kodi_addon->set_setting_float( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), settingValue); + kodi::dl::api.kodi_addon_set_setting_float(settingName.c_str(), settingValue); } //------------------------------------------------------------------------------ @@ -1505,11 +1584,8 @@ inline void ATTR_DLL_LOCAL SetSettingFloat(const std::string& settingName, float template inline bool ATTR_DLL_LOCAL CheckSettingEnum(const std::string& settingName, enumType& settingValue) { - using namespace kodi::addon; - int settingValueInt = static_cast(settingValue); - bool ret = CPrivateBase::m_interface->toKodi->kodi_addon->get_setting_int( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), &settingValueInt); + bool ret = kodi::dl::api.kodi_addon_get_setting_int(settingName.c_str(), &settingValueInt); if (ret) settingValue = static_cast(settingValueInt); return ret; @@ -1585,11 +1661,7 @@ inline enumType ATTR_DLL_LOCAL GetSettingEnum(const std::string& settingName, template inline void ATTR_DLL_LOCAL SetSettingEnum(const std::string& settingName, enumType settingValue) { - using namespace kodi::addon; - - CPrivateBase::m_interface->toKodi->kodi_addon->set_setting_int( - CPrivateBase::m_interface->toKodi->kodiBase, settingName.c_str(), - static_cast(settingValue)); + kodi::dl::api.kodi_addon_set_setting_int(settingName.c_str(), static_cast(settingValue)); } //------------------------------------------------------------------------------ @@ -1623,72 +1695,18 @@ inline void ATTR_DLL_LOCAL SetSettingEnum(const std::string& settingName, enumTy /// inline std::string ATTR_DLL_LOCAL GetAddonInfo(const std::string& id) { - using namespace kodi::addon; - - AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi; - std::string strReturn; - char* strMsg = toKodi->kodi_addon->get_addon_info(toKodi->kodiBase, id.c_str()); + char* strMsg = kodi::dl::api.kodi_addon_get_info(id.c_str()); if (strMsg != nullptr) { if (std::strlen(strMsg)) strReturn = strMsg; - toKodi->free_string(toKodi->kodiBase, strMsg); + free(strMsg); } return strReturn; } //------------------------------------------------------------------------------ -//============================================================================== -/// @ingroup cpp_kodi_addon -/// @brief Returns a function table to a named interface -/// -/// @return pointer to struct containing interface functions -/// -/// -/// ------------------------------------------------------------------------ -/// -/// **Example:** -/// ~~~~~~~~~~~~~{.cpp} -/// #include -/// #include -/// ... -/// FuncTable_foo *table = kodi::GetPlatformInfo(foo_name, foo_version); -/// ... -/// ~~~~~~~~~~~~~ -/// -inline void* GetInterface(const std::string& name, const std::string& version) -{ - using namespace kodi::addon; - - AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi; - - return toKodi->kodi_addon->get_interface(toKodi->kodiBase, name.c_str(), version.c_str()); -} -//---------------------------------------------------------------------------- - -//============================================================================== -/// @ingroup cpp_kodi_addon -/// @brief To get used version inside Kodi itself about asked type. -/// -/// This thought to allow a addon a handling of newer addon versions within -/// older Kodi until the type min version not changed. -/// -/// @param[in] type The wanted type of @ref ADDON_TYPE to ask -/// @return The version string about type in MAJOR.MINOR.PATCH style. -/// -inline std::string ATTR_DLL_LOCAL GetKodiTypeVersion(int type) -{ - using namespace kodi::addon; - - char* str = CPrivateBase::m_interface->toKodi->kodi_addon->get_type_version( - CPrivateBase::m_interface->toKodi->kodiBase, type); - std::string ret = str; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, str); - return ret; -} -//------------------------------------------------------------------------------ - //============================================================================ /// @ingroup cpp_kodi_addon /// @brief Get to related @ref ADDON_STATUS a human readable text. @@ -1731,7 +1749,6 @@ inline std::string ATTR_DLL_LOCAL TranslateAddonStatus(ADDON_STATUS status) /// @param[in] format The format of the message to pass to Kodi. /// @param[in] ... Additional text to insert in format text /// -/// /// @note This method uses limited buffer (16k) for the formatted output. /// So data, which will not fit into it, will be silently discarded. /// @@ -1746,19 +1763,38 @@ inline std::string ATTR_DLL_LOCAL TranslateAddonStatus(ADDON_STATUS status) /// /// ~~~~~~~~~~~~~ /// -inline void ATTR_DLL_LOCAL Log(const ADDON_LOG loglevel, const char* format, ...) +#ifndef SWIG +template +inline void ATTR_DLL_LOCAL Log(const AddonLog loglevel, const std::string& fmt, Args&&... args) { - using namespace kodi::addon; - - va_list args; - va_start(args, format); - const std::string str = kodi::tools::StringUtils::FormatV(format, args); - va_end(args); - CPrivateBase::m_interface->toKodi->addon_log_msg(CPrivateBase::m_interface->toKodi->kodiBase, - loglevel, str.c_str()); + kodi::dl::api.kodi_log(loglevel, fmt.c_str(), args...); } +#endif //------------------------------------------------------------------------------ +#ifndef SWIG +inline bool ATTR_DLL_LOCAL Init( + unsigned int api, int argc, char* argv[], KODI_ADDON_FUNC* func, bool via_main, bool no_receive) +{ + if (!kodi::dl::LoadDll(argc, argv)) + return false; + + KODI_IFC_HDL hdl = kodi::dl::api.kodi_init(api, argc, argv, func, via_main, no_receive); + if (!hdl) + return false; + + kodi::dl::hdl = hdl; + + return true; +} +#endif + +inline void ATTR_DLL_LOCAL Deinit() +{ + kodi::dl::api.kodi_deinit(kodi::dl::hdl); + kodi::dl::UnloadDll(); +} + } /* namespace kodi */ //============================================================================== @@ -1855,23 +1891,46 @@ inline void ATTR_DLL_LOCAL Log(const ADDON_LOG loglevel, const char* format, ... /// } /// \table_end /// + +#define KODI_STARTER \ + kodi_api_1 kodi::dl::api{0}; \ + KODI_IFC_HDL kodi::dl::hdl{nullptr}; \ + kodi::dl::LOCAL kodi::dl::local{}; #define ADDONCREATOR(AddonClass) \ - extern "C" ATTR_DLL_EXPORT ADDON_STATUS ADDON_Create(KODI_HANDLE addonInterface) \ + KODI_STARTER \ + ADDON_STATUS kodi::addon::CAddonBase::ADDONBASE_create(const struct KODI_ADDON_INSTANCE_INFO* first_instance, KODI_ADDON_HDL* hdl) \ { \ - using namespace kodi::addon; \ - CPrivateBase::m_interface = static_cast(addonInterface); \ - CPrivateBase::m_interface->addonBase = new AddonClass; \ - return static_cast(CPrivateBase::m_interface->addonBase)->Create(); \ + using namespace ::kodi::addon; \ + kodi::dl::local.firstKodiInstance = first_instance; \ + kodi::dl::local.addonBase = new AddonClass; \ + *hdl = kodi::dl::local.addonBase; \ + return kodi::dl::local.addonBase->Create(); \ } \ - extern "C" ATTR_DLL_EXPORT const char* ADDON_GetTypeVersion(int type) \ + extern "C" ATTR_DLL_EXPORT int main(int argc, char** argv) \ { \ - return kodi::addon::GetTypeVersion(type); \ + using namespace ::kodi::addon; \ + fprintf(stderr, "TEMP DEBUG: Addon main started, PID %i\n", getpid()); \ + /*sleep(10);*/ \ + KODI_ADDON_FUNC func = CAddonBase::GetAddonFunctions(); \ + if (!kodi::Init(__KODI_API__, argc, argv, &func, true, false)) \ + { \ + fprintf(stderr, "TEMP DEBUG: Addon main start failed!!! PID %i\n", getpid()); \ + return -1; \ + } \ + while (1) \ + { \ + if (!kodi::dl::api.kodi_process(kodi::dl::hdl)) \ + break; \ + } \ + kodi::Deinit(); \ + return 0; \ } \ - extern "C" ATTR_DLL_EXPORT const char* ADDON_GetTypeMinVersion(int type) \ + extern "C" ATTR_DLL_EXPORT int non_blocking_main_start(int argc, char** argv) \ { \ - return kodi::addon::GetTypeMinVersion(type); \ + using namespace ::kodi::addon; \ + KODI_ADDON_FUNC func = CAddonBase::GetAddonFunctions(); \ + return kodi::Init(__KODI_API__, argc, argv, &func, true, false) ? 0 : -1; \ } \ - AddonGlobalInterface* kodi::addon::CPrivateBase::m_interface = nullptr; -//------------------------------------------------------------------------------ + extern "C" ATTR_DLL_EXPORT void non_blocking_main_stop() { kodi::Deinit(); } #endif /* __cplusplus */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/AudioEngine.h b/xbmc/addons/kodi-dev-kit/include/kodi/AudioEngine.h index 2afe351e69ba3..10d96ed5fd4ef 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/AudioEngine.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/AudioEngine.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2019 Team Kodi + * Copyright (C) 2005-2020 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later @@ -9,10 +9,13 @@ #pragma once #include "AddonBase.h" +#include "General.h" #include "c-api/audio_engine.h" #ifdef __cplusplus +#include + namespace kodi { namespace audioengine @@ -100,107 +103,65 @@ namespace audioengine /// ///@{ class ATTR_DLL_LOCAL AudioEngineFormat - : public addon::CStructHdl + : public addon::CStructHdl { public: - /*! \cond PRIVATE */ AudioEngineFormat() { - m_cStructure->m_dataFormat = AUDIOENGINE_FMT_INVALID; - m_cStructure->m_sampleRate = 0; - m_cStructure->m_encodedRate = 0; - m_cStructure->m_frames = 0; - m_cStructure->m_frameSize = 0; - m_cStructure->m_channelCount = 0; + m_cStructure->data_format = AUDIOENGINE_FMT_INVALID; + m_cStructure->sample_rate = 0; + m_cStructure->frames = 0; + m_cStructure->frame_size = 0; + m_cStructure->channel_count = 0; for (size_t ch = 0; ch < AUDIOENGINE_CH_MAX; ++ch) - m_cStructure->m_channels[ch] = AUDIOENGINE_CH_NULL; + m_cStructure->channels[ch] = AUDIOENGINE_CH_NULL; } AudioEngineFormat(const AudioEngineFormat& channel) : CStructHdl(channel) {} - AudioEngineFormat(const AUDIO_ENGINE_FORMAT* channel) : CStructHdl(channel) {} - AudioEngineFormat(AUDIO_ENGINE_FORMAT* channel) : CStructHdl(channel) {} - /*! \endcond */ - - /// @defgroup cpp_kodi_audioengine_Defs_AudioEngineFormat_Help *Value Help* - /// @ingroup cpp_kodi_audioengine_Defs_AudioEngineFormat - /// - /// The following table contains values that can be set with @ref cpp_kodi_audioengine_Defs_AudioEngineFormat : - /// | Name | Type | Set call | Get call - /// |------|------|----------|---------- - /// | **Data format**, see @ref AudioEngineDataFormat for available types | enum | @ref AudioEngineFormat::SetDataFormat "SetDataFormat" | @ref AudioEngineFormat::GetDataFormat "GetDataFormat" - /// | **Sample rate** | unsigned int | @ref AudioEngineFormat::SetSampleRate "SetSampleRate" | @ref AudioEngineFormat::GetSampleRate "GetSampleRate" - /// | **Encoded rate** | unsigned int | @ref AudioEngineFormat::SetEncodedRate "SetEncodedRate" | @ref AudioEngineFormat::GetEncodedRate "GetEncodedRate" - /// | **Channel layout**, see @ref AudioEngineChannel for available types | std::vector | @ref AudioEngineFormat::SetChannelLayout "SetChannelLayout" | @ref AudioEngineFormat::GetChannelLayout "GetChannelLayout" - /// | **Frames amount** | unsigned int | @ref AudioEngineFormat::SetFramesAmount "SetFramesAmount" | @ref AudioEngineFormat::GetFramesAmount "GetFramesAmount" - /// | **Frame size** | unsigned int | @ref AudioEngineFormat::SetFrameSize "SetFrameSize" | @ref AudioEngineFormat::GetFrameSize "GetFrameSize" - /// - /// Further is @ref AudioEngineFormat::CompareFormat "CompareFormat" included to compare this class with another. - /// - - /// @addtogroup cpp_kodi_audioengine_Defs_AudioEngineFormat - /// @copydetails cpp_kodi_audioengine_Defs_AudioEngineFormat_Help - ///@{ - - /// @brief The stream's data format (eg, AUDIOENGINE_FMT_S16LE) - void SetDataFormat(enum AudioEngineDataFormat format) { m_cStructure->m_dataFormat = format; } + AudioEngineFormat(const AUDIO_ENGINE_FMT* channel) : CStructHdl(channel) {} + AudioEngineFormat(AUDIO_ENGINE_FMT* channel) : CStructHdl(channel) {} - /// @brief To get with @ref SetDataFormat changed values. - enum AudioEngineDataFormat GetDataFormat() const { return m_cStructure->m_dataFormat; } + void SetDataFormat(AudioEngineDataFormat format) { m_cStructure->data_format = format; } + AudioEngineDataFormat GetDataFormat() const { return m_cStructure->data_format; } - /// @brief The stream's sample rate (eg, 48000) - void SetSampleRate(unsigned int rate) { m_cStructure->m_sampleRate = rate; } + void SetSampleRate(unsigned int rate) { m_cStructure->sample_rate = rate; } + unsigned int GetSampleRate() const { return m_cStructure->sample_rate; } - /// @brief To get with @ref SetSampleRate changed values. - unsigned int GetSampleRate() const { return m_cStructure->m_sampleRate; } - - /// @brief The encoded streams sample rate if a bitstream, otherwise undefined - void SetEncodedRate(unsigned int rate) { m_cStructure->m_encodedRate = rate; } - - /// @brief To get with @ref SetEncodedRate changed values. - unsigned int GetEncodedRate() const { return m_cStructure->m_encodedRate; } - - /// @brief The stream's channel layout - void SetChannelLayout(const std::vector& layout) + void SetChannelLayout(const std::vector& layout) { // Reset first all to empty values to AUDIOENGINE_CH_NULL, in case given list is empty - m_cStructure->m_channelCount = 0; + m_cStructure->channel_count = 0; for (size_t ch = 0; ch < AUDIOENGINE_CH_MAX; ++ch) - m_cStructure->m_channels[ch] = AUDIOENGINE_CH_NULL; + m_cStructure->channels[ch] = AUDIOENGINE_CH_NULL; for (size_t ch = 0; ch < layout.size() && ch < AUDIOENGINE_CH_MAX; ++ch) { - m_cStructure->m_channels[ch] = layout[ch]; - m_cStructure->m_channelCount++; + m_cStructure->channels[ch] = layout[ch]; + m_cStructure->channel_count++; } } - /// @brief To get with @ref SetChannelLayout changed values. - std::vector GetChannelLayout() const + std::vector GetChannelLayout() const { - std::vector channels; + std::vector channels; for (size_t ch = 0; ch < AUDIOENGINE_CH_MAX; ++ch) { - if (m_cStructure->m_channels[ch] == AUDIOENGINE_CH_NULL) + if (m_cStructure->channels[ch] == AUDIOENGINE_CH_NULL) break; - channels.push_back(m_cStructure->m_channels[ch]); + channels.push_back(m_cStructure->channels[ch]); } return channels; } - /// @brief The number of frames per period - void SetFramesAmount(unsigned int frames) { m_cStructure->m_frames = frames; } - - /// @brief To get with @ref SetFramesAmount changed values. - unsigned int GetFramesAmount() const { return m_cStructure->m_frames; } + unsigned int GetChannelCount() { return m_cStructure->channel_count; } - /// @brief The size of one frame in bytes - void SetFrameSize(unsigned int frameSize) { m_cStructure->m_frameSize = frameSize; } + void SetFramesAmount(unsigned int frames) { m_cStructure->frames = frames; } + unsigned int GetFramesAmount() const { return m_cStructure->frames; } - /// @brief To get with @ref SetFrameSize changed values. - unsigned int GetFrameSize() const { return m_cStructure->m_frameSize; } + void SetFrameSize(unsigned int frameSize) { m_cStructure->frame_size = frameSize; } + unsigned int GetFrameSize() const { return m_cStructure->frame_size; } - /// @brief Function to compare the format structure with another bool CompareFormat(const AudioEngineFormat* fmt) { if (!fmt) @@ -208,19 +169,18 @@ class ATTR_DLL_LOCAL AudioEngineFormat return false; } - if (m_cStructure->m_dataFormat != fmt->m_cStructure->m_dataFormat || - m_cStructure->m_sampleRate != fmt->m_cStructure->m_sampleRate || - m_cStructure->m_encodedRate != fmt->m_cStructure->m_encodedRate || - m_cStructure->m_frames != fmt->m_cStructure->m_frames || - m_cStructure->m_frameSize != fmt->m_cStructure->m_frameSize || - m_cStructure->m_channelCount != fmt->m_cStructure->m_channelCount) + if (m_cStructure->data_format != fmt->m_cStructure->data_format || + m_cStructure->sample_rate != fmt->m_cStructure->sample_rate || + m_cStructure->frames != fmt->m_cStructure->frames || + m_cStructure->frame_size != fmt->m_cStructure->frame_size || + m_cStructure->channel_count != fmt->m_cStructure->channel_count) { return false; } for (unsigned int ch = 0; ch < AUDIOENGINE_CH_MAX; ++ch) { - if (fmt->m_cStructure->m_channels[ch] != m_cStructure->m_channels[ch]) + if (fmt->m_cStructure->channels[ch] != m_cStructure->channels[ch]) { return false; } @@ -228,7 +188,6 @@ class ATTR_DLL_LOCAL AudioEngineFormat return true; } - ///@} }; ///@} //---------------------------------------------------------------------------- @@ -302,53 +261,35 @@ class ATTR_DLL_LOCAL CAEStream /// /// ~~~~~~~~~~~~~ /// - CAEStream(AudioEngineFormat& format, unsigned int options = 0) - : m_kodiBase(::kodi::addon::CPrivateBase::m_interface->toKodi->kodiBase), - m_cb(::kodi::addon::CPrivateBase::m_interface->toKodi->kodi_audioengine) + CAEStream(AudioEngineFormat& format, unsigned int options = 0) : m_format(format) { - m_StreamHandle = m_cb->make_stream(m_kodiBase, format, options); - if (m_StreamHandle == nullptr) + m_streamHandle = kodi::dl::api.kodi_audioengine_stream_make(m_format, options); + if (m_streamHandle == nullptr) { kodi::Log(ADDON_LOG_FATAL, "CAEStream: make_stream failed!"); + return; } + + m_planes = kodi::dl::api.kodi_audioengine_is_planar_format(format.GetDataFormat()) + ? format.GetChannelCount() + : 1; } - //-------------------------------------------------------------------------- + //------------------------------------------------------------------------------ - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Class destructor. - /// ~CAEStream() { - if (m_StreamHandle) + if (m_streamHandle) { - m_cb->free_stream(m_kodiBase, m_StreamHandle); - m_StreamHandle = nullptr; + kodi::dl::api.kodi_audioengine_stream_free(m_streamHandle); + m_streamHandle = nullptr; } } - //-------------------------------------------------------------------------- - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Returns the amount of space available in the stream. - /// - /// @return The number of bytes AddData will consume - /// - unsigned int GetSpace() { return m_cb->aestream_get_space(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + unsigned int GetSpace() + { + return kodi::dl::api.kodi_audioengine_stream_get_space(m_streamHandle); + } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Add planar or interleaved PCM data to the stream. - /// - /// @param[in] data array of pointers to the planes - /// @param[in] offset to frame in frames - /// @param[in] frames number of frames - /// @param[in] pts [opt] presentation timestamp, default is 0 - /// @param[in] hasDownmix [opt] set true if downmix is present, default is false - /// @param[in] centerMixLevel [opt] level to mix left and right to center default is 1.0 - /// @return The number of frames consumed - /// unsigned int AddData(uint8_t* const* data, unsigned int offset, unsigned int frames, @@ -356,222 +297,91 @@ class ATTR_DLL_LOCAL CAEStream bool hasDownmix = false, double centerMixLevel = 1.0) { - return m_cb->aestream_add_data(m_kodiBase, m_StreamHandle, data, offset, frames, pts, - hasDownmix, centerMixLevel); + return kodi::dl::api.kodi_audioengine_stream_add_data( + m_streamHandle, data, m_planes, frames * m_format.GetFrameSize(), offset, frames, + m_format.GetFrameSize(), pts, hasDownmix, centerMixLevel); } - //-------------------------------------------------------------------------- - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Returns the time in seconds that it will take for the next added - /// packet to be heard from the speakers. - /// - /// @return seconds - /// - double GetDelay() { return m_cb->aestream_get_delay(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + double GetDelay() { return kodi::dl::api.kodi_audioengine_stream_get_delay(m_streamHandle); } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Returns if the stream is buffering. - /// - /// @return True if the stream is buffering - /// - bool IsBuffering() { return m_cb->aestream_is_buffering(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + bool IsBuffering() { return kodi::dl::api.kodi_audioengine_stream_is_buffering(m_streamHandle); } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Returns the time in seconds of the stream's cached audio samples. - /// Engine buffers excluded. - /// - /// @return seconds - /// - double GetCacheTime() { return m_cb->aestream_get_cache_time(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + double GetCacheTime() + { + return kodi::dl::api.kodi_audioengine_stream_get_cache_time(m_streamHandle); + } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Returns the total time in seconds of the cache. - /// - /// @return seconds - /// - double GetCacheTotal() { return m_cb->aestream_get_cache_total(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + double GetCacheTotal() + { + return kodi::dl::api.kodi_audioengine_stream_get_cache_total(m_streamHandle); + } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Pauses the stream playback. - /// - void Pause() { return m_cb->aestream_pause(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + void Pause() { return kodi::dl::api.kodi_audioengine_stream_pause(m_streamHandle); } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Resumes the stream after pausing - /// - void Resume() { return m_cb->aestream_resume(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + void Resume() { return kodi::dl::api.kodi_audioengine_stream_resume(m_streamHandle); } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Start draining the stream. - /// - /// @param[in] wait [opt] Wait until drain is finished if set to true, - /// otherwise it returns direct - /// - /// @note Once called AddData will not consume more data. - /// - void Drain(bool wait = true) { return m_cb->aestream_drain(m_kodiBase, m_StreamHandle, wait); } - //-------------------------------------------------------------------------- + void Drain(bool wait = true) + { + return kodi::dl::api.kodi_audioengine_stream_drain(m_streamHandle, wait); + } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Returns true if the is stream draining. - /// - bool IsDraining() { return m_cb->aestream_is_draining(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + bool IsDraining() { return kodi::dl::api.kodi_audioengine_stream_is_draining(m_streamHandle); } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Returns true if the is stream has finished draining. - /// - bool IsDrained() { return m_cb->aestream_is_drained(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + bool IsDrained() { return kodi::dl::api.kodi_audioengine_stream_is_drained(m_streamHandle); } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Flush all buffers dropping the audio data. - /// - void Flush() { return m_cb->aestream_flush(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + void Flush() { return kodi::dl::api.kodi_audioengine_stream_flush(m_streamHandle); } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Return the stream's current volume level. - /// - /// @return The volume level between 0.0 and 1.0 - /// - float GetVolume() { return m_cb->aestream_get_volume(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + float GetVolume() { return kodi::dl::api.kodi_audioengine_stream_get_volume(m_streamHandle); } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Set the stream's volume level. - /// - /// @param[in] volume The new volume level between 0.0 and 1.0 - /// void SetVolume(float volume) { - return m_cb->aestream_set_volume(m_kodiBase, m_StreamHandle, volume); + return kodi::dl::api.kodi_audioengine_stream_set_volume(m_streamHandle, volume); } - //-------------------------------------------------------------------------- - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Gets the stream's volume amplification in linear units. - /// - /// @return The volume amplification factor between 1.0 and 1000.0 - /// - float GetAmplification() { return m_cb->aestream_get_amplification(m_kodiBase, m_StreamHandle); } - //-------------------------------------------------------------------------- + float GetAmplification() + { + return kodi::dl::api.kodi_audioengine_stream_get_amplification(m_streamHandle); + } - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Sets the stream's volume amplification in linear units. - /// - /// @param[in] amplify The volume amplification factor between 1.0 and 1000.0 - /// void SetAmplification(float amplify) { - return m_cb->aestream_set_amplification(m_kodiBase, m_StreamHandle, amplify); + return kodi::dl::api.kodi_audioengine_stream_set_amplification(m_streamHandle, amplify); } - //-------------------------------------------------------------------------- - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Returns the size of one audio frame in bytes (channelCount * resolution). - /// - /// @return The size in bytes of one frame - /// unsigned int GetFrameSize() const { - return m_cb->aestream_get_frame_size(m_kodiBase, m_StreamHandle); + return kodi::dl::api.kodi_audioengine_stream_get_frame_size(m_streamHandle); } - //-------------------------------------------------------------------------- - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Returns the number of channels the stream is configured to accept. - /// - /// @return The channel count - /// unsigned int GetChannelCount() const { - return m_cb->aestream_get_channel_count(m_kodiBase, m_StreamHandle); + return kodi::dl::api.kodi_audioengine_stream_get_channel_count(m_streamHandle); } - //-------------------------------------------------------------------------- - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Returns the stream's sample rate, if the stream is using a dynamic - /// sample rate, this value will NOT reflect any changes made by calls to - /// SetResampleRatio(). - /// - /// @return The stream's sample rate (eg, 48000) - /// unsigned int GetSampleRate() const { - return m_cb->aestream_get_sample_rate(m_kodiBase, m_StreamHandle); + return kodi::dl::api.kodi_audioengine_stream_get_sample_rate(m_streamHandle); } - //-------------------------------------------------------------------------- - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Return the data format the stream has been configured with. - /// - /// @return The stream's data format (eg, AUDIOENGINE_FMT_S16LE) - /// AudioEngineDataFormat GetDataFormat() const { - return m_cb->aestream_get_data_format(m_kodiBase, m_StreamHandle); + return kodi::dl::api.kodi_audioengine_stream_get_data_format(m_streamHandle); } - //-------------------------------------------------------------------------- - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Return the resample ratio. - /// - /// @note This will return an undefined value if the stream is not resampling. - /// - /// @return the current resample ratio or undefined if the stream is not resampling - /// double GetResampleRatio() { - return m_cb->aestream_get_resample_ratio(m_kodiBase, m_StreamHandle); + return kodi::dl::api.kodi_audioengine_stream_get_resample_ratio(m_streamHandle); } - //-------------------------------------------------------------------------- - //========================================================================== - /// @ingroup cpp_kodi_audioengine_CAEStream - /// @brief Sets the resample ratio. - /// - /// @note This function may return false if the stream is not resampling, if - /// you wish to use this be sure to set the AESTREAM_FORCE_RESAMPLE option. - /// - /// @param[in] ratio the new sample rate ratio, calculated by - /// ((double)desiredRate / (double)GetSampleRate()) - /// void SetResampleRatio(double ratio) { - m_cb->aestream_set_resample_ratio(m_kodiBase, m_StreamHandle, ratio); + kodi::dl::api.kodi_audioengine_stream_set_resample_ratio(m_streamHandle, ratio); } - //-------------------------------------------------------------------------- private: - void* m_kodiBase; - AddonToKodiFuncTable_kodi_audioengine* m_cb; - AEStreamHandle* m_StreamHandle; + const AudioEngineFormat m_format; + int m_planes = 1; + KODI_AE_HDL m_streamHandle; }; //---------------------------------------------------------------------------- @@ -605,13 +415,13 @@ class ATTR_DLL_LOCAL CAEStream /// inline bool ATTR_DLL_LOCAL GetCurrentSinkFormat(AudioEngineFormat& format) { - using namespace kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_audioengine->get_current_sink_format( - CPrivateBase::m_interface->toKodi->kodiBase, format); + return kodi::dl::api.kodi_audioengine_get_current_sink_format(format); } -//---------------------------------------------------------------------------- -//}}} +inline bool IsPlanarFormat(AudioEngineDataFormat format) +{ + return kodi::dl::api.kodi_audioengine_is_planar_format(format); +} } // namespace audioengine } // namespace kodi diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/include/kodi/CMakeLists.txt index 5e396b945f170..12e49ce44cea8 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/CMakeLists.txt +++ b/xbmc/addons/kodi-dev-kit/include/kodi/CMakeLists.txt @@ -6,8 +6,8 @@ set(HEADERS AudioEngine.h Filesystem.h General.h + Monitor.h Network.h - versions.h ) if(HEADERS) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/Filesystem.h b/xbmc/addons/kodi-dev-kit/include/kodi/Filesystem.h index 7cd35bd4f726a..3d1ee0b42e5e1 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/Filesystem.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/Filesystem.h @@ -92,14 +92,14 @@ namespace vfs /// Used on kodi::vfs::StatFile() to get detailed information about a file. /// ///@{ -class ATTR_DLL_LOCAL FileStatus : public kodi::addon::CStructHdl +class FileStatus : public kodi::addon::CStructHdl { public: /*! \cond PRIVATE */ - FileStatus() { memset(m_cStructure, 0, sizeof(STAT_STRUCTURE)); } + FileStatus() { memset(m_cStructure, 0, sizeof(VFS_STAT_STRUCTURE)); } FileStatus(const FileStatus& channel) : CStructHdl(channel) {} - FileStatus(const STAT_STRUCTURE* channel) : CStructHdl(channel) {} - FileStatus(STAT_STRUCTURE* channel) : CStructHdl(channel) {} + FileStatus(const VFS_STAT_STRUCTURE* channel) : CStructHdl(channel) {} + FileStatus(VFS_STAT_STRUCTURE* channel) : CStructHdl(channel) {} /*! \endcond */ /// @defgroup cpp_kodi_vfs_Defs_FileStatus_Help Value Help @@ -128,6 +128,8 @@ class ATTR_DLL_LOCAL FileStatus : public kodi::addon::CStructHdldeviceId = deviceId; } @@ -221,15 +223,13 @@ class ATTR_DLL_LOCAL FileStatus : public kodi::addon::CStructHdl +class CacheStatus : public kodi::addon::CStructHdl { public: - /*! \cond PRIVATE */ - CacheStatus() { memset(m_cStructure, 0, sizeof(VFS_CACHE_STATUS_DATA)); } + CacheStatus() { memset(m_cStructure, 0, sizeof(VFS_CACHE_STATUS)); } CacheStatus(const CacheStatus& channel) : CStructHdl(channel) {} - CacheStatus(const VFS_CACHE_STATUS_DATA* channel) : CStructHdl(channel) {} - CacheStatus(VFS_CACHE_STATUS_DATA* channel) : CStructHdl(channel) {} + CacheStatus(const VFS_CACHE_STATUS* channel) : CStructHdl(channel) {} + CacheStatus(VFS_CACHE_STATUS* channel) : CStructHdl(channel) {} /*! \endcond */ /// @defgroup cpp_kodi_vfs_Defs_CacheStatus_Help Value Help @@ -291,7 +291,7 @@ class ATTR_DLL_LOCAL CacheStatus /// @copydetails cpp_kodi_vfs_Defs_HttpHeader_Help /// ///@{ -class ATTR_DLL_LOCAL HttpHeader +class HttpHeader { public: //========================================================================== @@ -299,23 +299,13 @@ class ATTR_DLL_LOCAL HttpHeader /// HttpHeader() { - using namespace ::kodi::addon; - - CPrivateBase::m_interface->toKodi->kodi_filesystem->http_header_create( - CPrivateBase::m_interface->toKodi->kodiBase, &m_handle); } //-------------------------------------------------------------------------- //========================================================================== /// @brief Class destructor. /// - ~HttpHeader() - { - using namespace ::kodi::addon; - - CPrivateBase::m_interface->toKodi->kodi_filesystem->http_header_free( - CPrivateBase::m_interface->toKodi->kodiBase, &m_handle); - } + ~HttpHeader() { kodi::dl::api.kodi_vfs_http_header_close(m_handle); } //-------------------------------------------------------------------------- /// @defgroup cpp_kodi_vfs_Defs_HttpHeader_Help Value Help @@ -344,19 +334,15 @@ class ATTR_DLL_LOCAL HttpHeader /// std::string GetValue(const std::string& param) const { - using namespace ::kodi::addon; - - if (!m_handle.handle) + if (!m_handle) return ""; std::string protoLine; - char* string = m_handle.get_value(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle, - param.c_str()); + char* string = kodi::dl::api.kodi_vfs_http_header_get_value(m_handle, param.c_str()); if (string != nullptr) { protoLine = string; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - string); + free(string); } return protoLine; } @@ -371,24 +357,22 @@ class ATTR_DLL_LOCAL HttpHeader /// std::vector GetValues(const std::string& param) const { - using namespace kodi::addon; - - if (!m_handle.handle) + if (!m_handle) return std::vector(); - int numValues = 0; - char** res(m_handle.get_values(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle, - param.c_str(), &numValues)); + size_t numValues = 0; + char** res(kodi::dl::api.kodi_vfs_http_header_get_values(m_handle, param.c_str(), &numValues)); if (res) { std::vector vecReturn; vecReturn.reserve(numValues); - for (int i = 0; i < numValues; ++i) + for (size_t i = 0; i < numValues; ++i) { vecReturn.emplace_back(res[i]); + free(res[i]); } - CPrivateBase::m_interface->toKodi->free_string_array( - CPrivateBase::m_interface->toKodi->kodiBase, res, numValues); + free(res); + return vecReturn; } return std::vector(); @@ -404,17 +388,15 @@ class ATTR_DLL_LOCAL HttpHeader { using namespace ::kodi::addon; - if (!m_handle.handle) + if (!m_handle) return ""; std::string header; - char* string = - m_handle.get_header(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle); + char* string = kodi::dl::api.kodi_vfs_http_header_get_header(m_handle); if (string != nullptr) { header = string; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - string); + free(string); } return header; } @@ -429,17 +411,15 @@ class ATTR_DLL_LOCAL HttpHeader { using namespace ::kodi::addon; - if (!m_handle.handle) + if (!m_handle) return ""; std::string protoLine; - char* string = - m_handle.get_mime_type(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle); + char* string = kodi::dl::api.kodi_vfs_http_header_get_mime_type(m_handle); if (string != nullptr) { protoLine = string; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - string); + free(string); } return protoLine; } @@ -454,17 +434,15 @@ class ATTR_DLL_LOCAL HttpHeader { using namespace ::kodi::addon; - if (!m_handle.handle) + if (!m_handle) return ""; std::string protoLine; - char* string = - m_handle.get_charset(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle); + char* string = kodi::dl::api.kodi_vfs_http_header_get_charset(m_handle); if (string != nullptr) { protoLine = string; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - string); + free(string); } return protoLine; } @@ -479,17 +457,15 @@ class ATTR_DLL_LOCAL HttpHeader { using namespace ::kodi::addon; - if (!m_handle.handle) + if (!m_handle) return ""; std::string protoLine; - char* string = - m_handle.get_proto_line(CPrivateBase::m_interface->toKodi->kodiBase, m_handle.handle); + char* string = kodi::dl::api.kodi_vfs_http_header_get_proto_line(m_handle); if (string != nullptr) { protoLine = string; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - string); + free(string); } return protoLine; } @@ -497,7 +473,7 @@ class ATTR_DLL_LOCAL HttpHeader ///@} - KODI_HTTP_HEADER m_handle; + KODI_HTTP_HEADER_HDL m_handle; }; ///@} //---------------------------------------------------------------------------- @@ -541,7 +517,7 @@ class ATTR_DLL_LOCAL HttpHeader /// to enjoy it. /// ///@{ -class ATTR_DLL_LOCAL CDirEntry +class CDirEntry { public: //============================================================================ @@ -573,7 +549,7 @@ class ATTR_DLL_LOCAL CDirEntry // // @param[in] dirEntry pointer to own class type // - explicit CDirEntry(const VFSDirEntry& dirEntry) + explicit CDirEntry(const VFS_DIR_ENTRY& dirEntry) : m_label(dirEntry.label ? dirEntry.label : ""), m_path(dirEntry.path ? dirEntry.path : ""), m_folder(dirEntry.folder), @@ -581,6 +557,8 @@ class ATTR_DLL_LOCAL CDirEntry m_dateTime(dirEntry.date_time) { } + + //---------------------------------------------------------------------------- /// @defgroup cpp_kodi_vfs_CDirEntry_Help Value Help @@ -772,12 +750,9 @@ class ATTR_DLL_LOCAL CDirEntry /// ... /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL CreateDirectory(const std::string& path) +inline bool CreateDirectory(const std::string& path) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->create_directory( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str()); + return kodi::dl::api.kodi_vfs_create_directory(path.c_str()); } //------------------------------------------------------------------------------ @@ -804,12 +779,9 @@ inline bool ATTR_DLL_LOCAL CreateDirectory(const std::string& path) /// ... /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL DirectoryExists(const std::string& path) +inline bool DirectoryExists(const std::string& path) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->directory_exists( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str()); + return kodi::dl::api.kodi_vfs_directory_exists(path.c_str()); } //------------------------------------------------------------------------------ @@ -838,16 +810,12 @@ inline bool ATTR_DLL_LOCAL DirectoryExists(const std::string& path) /// ... /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL RemoveDirectory(const std::string& path, bool recursive = false) +inline bool RemoveDirectory(const std::string& path, bool recursive = false) { - using namespace kodi::addon; - if (!recursive) - return CPrivateBase::m_interface->toKodi->kodi_filesystem->remove_directory( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str()); + return kodi::dl::api.kodi_vfs_remove_directory(path.c_str()); else - return CPrivateBase::m_interface->toKodi->kodi_filesystem->remove_directory_recursive( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str()); + return kodi::dl::api.kodi_vfs_remove_directory_recursive(path.c_str()); } //------------------------------------------------------------------------------ @@ -887,25 +855,20 @@ inline bool ATTR_DLL_LOCAL RemoveDirectory(const std::string& path, bool recursi /// items[i].Path().c_str()); /// } /// ~~~~~~~~~~~~~ -inline bool ATTR_DLL_LOCAL GetDirectory(const std::string& path, - const std::string& mask, - std::vector& items) +inline bool GetDirectory(const std::string& path, + const std::string& mask, + std::vector& items) { - using namespace kodi::addon; - - VFSDirEntry* dir_list = nullptr; - unsigned int num_items = 0; - if (CPrivateBase::m_interface->toKodi->kodi_filesystem->get_directory( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str(), mask.c_str(), &dir_list, - &num_items)) + VFS_DIR_ENTRY* dir_list = nullptr; + size_t num_items = 0; + if (kodi::dl::api.kodi_vfs_get_directory(path.c_str(), mask.c_str(), &dir_list, &num_items)) { if (dir_list) { - for (unsigned int i = 0; i < num_items; ++i) + for (size_t i = 0; i < num_items; ++i) items.emplace_back(dir_list[i]); - CPrivateBase::m_interface->toKodi->kodi_filesystem->free_directory( - CPrivateBase::m_interface->toKodi->kodiBase, dir_list, num_items); + kodi::dl::api.kodi_vfs_free_directory(dir_list, num_items); } return true; @@ -914,8 +877,6 @@ inline bool ATTR_DLL_LOCAL GetDirectory(const std::string& path, } //------------------------------------------------------------------------------ -//}}} - //¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // "C++" File related functions //{{{ @@ -939,12 +900,9 @@ inline bool ATTR_DLL_LOCAL GetDirectory(const std::string& path, /// fprintf(stderr, "Log file should be always present, is it present? %s\n", exists ? "yes" : "no"); /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL FileExists(const std::string& filename, bool usecache = false) +inline bool FileExists(const std::string& filename, bool usecache = false) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->file_exists( - CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), usecache); + return kodi::dl::api.kodi_vfs_file_exists(filename.c_str(), usecache); } //------------------------------------------------------------------------------ @@ -994,12 +952,9 @@ inline bool ATTR_DLL_LOCAL FileExists(const std::string& filename, bool usecache /// ret); /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL StatFile(const std::string& filename, kodi::vfs::FileStatus& buffer) +inline bool StatFile(const std::string& filename, kodi::vfs::FileStatus& buffer) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->stat_file( - CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), buffer); + return kodi::dl::api.kodi_vfs_stat_file(filename.c_str(), buffer); } //------------------------------------------------------------------------------ @@ -1032,12 +987,9 @@ inline bool ATTR_DLL_LOCAL StatFile(const std::string& filename, kodi::vfs::File /// } /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL DeleteFile(const std::string& filename) +inline bool DeleteFile(const std::string& filename) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->delete_file( - CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str()); + return kodi::dl::api.kodi_vfs_delete_file(filename.c_str()); } //------------------------------------------------------------------------------ @@ -1050,12 +1002,9 @@ inline bool ATTR_DLL_LOCAL DeleteFile(const std::string& filename) /// @return true if successfully renamed /// /// -inline bool ATTR_DLL_LOCAL RenameFile(const std::string& filename, const std::string& newFileName) +inline bool RenameFile(const std::string& filename, const std::string& newFileName) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->rename_file( - CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), newFileName.c_str()); + return kodi::dl::api.kodi_vfs_rename_file(filename.c_str(), newFileName.c_str()); } //------------------------------------------------------------------------------ @@ -1068,17 +1017,12 @@ inline bool ATTR_DLL_LOCAL RenameFile(const std::string& filename, const std::st /// @return true if successfully copied /// /// -inline bool ATTR_DLL_LOCAL CopyFile(const std::string& filename, const std::string& destination) +inline bool CopyFile(const std::string& filename, const std::string& destination) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->copy_file( - CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), destination.c_str()); + return kodi::dl::api.kodi_vfs_copy_file(filename.c_str(), destination.c_str()); } //------------------------------------------------------------------------------ -//}}} - //¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // "C++" General filesystem functions //{{{ @@ -1109,19 +1053,16 @@ inline bool ATTR_DLL_LOCAL CopyFile(const std::string& filename, const std::stri /// } /// ~~~~~~~~~~~~~ /// -inline std::string ATTR_DLL_LOCAL GetFileMD5(const std::string& path) +inline std::string GetFileMD5(const std::string& path) { - using namespace kodi::addon; std::string strReturn; - char* strMd5 = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_md5( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str()); + char* strMd5 = kodi::dl::api.kodi_vfs_get_file_md5(path.c_str()); if (strMd5 != nullptr) { if (std::strlen(strMd5)) strReturn = strMd5; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - strMd5); + free(strMd5); } return strReturn; } @@ -1153,19 +1094,15 @@ inline std::string ATTR_DLL_LOCAL GetFileMD5(const std::string& path) /// } /// ~~~~~~~~~~~~~ /// -inline std::string ATTR_DLL_LOCAL GetCacheThumbName(const std::string& filename) +inline std::string GetCacheThumbName(const std::string& filename) { - using namespace kodi::addon; - std::string strReturn; - char* strThumbName = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_cache_thumb_name( - CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str()); + char* strThumbName = kodi::dl::api.kodi_vfs_get_cache_thumb_name(filename.c_str()); if (strThumbName != nullptr) { if (std::strlen(strThumbName)) strReturn = strThumbName; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - strThumbName); + free(strThumbName); } return strReturn; } @@ -1196,19 +1133,15 @@ inline std::string ATTR_DLL_LOCAL GetCacheThumbName(const std::string& filename) /// /* Returns as legal: 'jk___lj____.mpg' */ /// ~~~~~~~~~~~~~ /// -inline std::string ATTR_DLL_LOCAL MakeLegalFileName(const std::string& filename) +inline std::string MakeLegalFileName(const std::string& filename) { - using namespace kodi::addon; - std::string strReturn; - char* strLegalFileName = CPrivateBase::m_interface->toKodi->kodi_filesystem->make_legal_filename( - CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str()); + char* strLegalFileName = kodi::dl::api.kodi_vfs_make_legal_filename(filename.c_str()); if (strLegalFileName != nullptr) { if (std::strlen(strLegalFileName)) strReturn = strLegalFileName; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - strLegalFileName); + free(strLegalFileName); } return strReturn; } @@ -1239,19 +1172,15 @@ inline std::string ATTR_DLL_LOCAL MakeLegalFileName(const std::string& filename) /// /* Returns as legal: '/jk___lj____/hgjkg' */ /// ~~~~~~~~~~~~~ /// -inline std::string ATTR_DLL_LOCAL MakeLegalPath(const std::string& path) +inline std::string MakeLegalPath(const std::string& path) { - using namespace kodi::addon; - std::string strReturn; - char* strLegalPath = CPrivateBase::m_interface->toKodi->kodi_filesystem->make_legal_path( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str()); + char* strLegalPath = kodi::dl::api.kodi_vfs_make_legal_path(path.c_str()); if (strLegalPath != nullptr) { if (std::strlen(strLegalPath)) strReturn = strLegalPath; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - strLegalPath); + free(strLegalPath); } return strReturn; } @@ -1287,19 +1216,15 @@ inline std::string ATTR_DLL_LOCAL MakeLegalPath(const std::string& path) /// ... /// ~~~~~~~~~~~~~ /// -inline std::string ATTR_DLL_LOCAL TranslateSpecialProtocol(const std::string& source) +inline std::string TranslateSpecialProtocol(const std::string& source) { - using namespace kodi::addon; - std::string strReturn; - char* protocol = CPrivateBase::m_interface->toKodi->kodi_filesystem->translate_special_protocol( - CPrivateBase::m_interface->toKodi->kodiBase, source.c_str()); + char* protocol = kodi::dl::api.kodi_vfs_translate_special_protocol(source.c_str()); if (protocol != nullptr) { if (std::strlen(protocol)) strReturn = protocol; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - protocol); + free(protocol); } return strReturn; } @@ -1341,16 +1266,14 @@ inline std::string ATTR_DLL_LOCAL TranslateSpecialProtocol(const std::string& so /// fprintf(stderr, " - available: %lu MByte\n", available / 1024 / 1024); /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL GetDiskSpace(const std::string& path, - uint64_t& capacity, - uint64_t& free, - uint64_t& available) -{ - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_disk_space( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str(), &capacity, &free, &available); -} +// inline bool GetDiskSpace(const std::string& path, +// uint64_t& capacity, +// uint64_t& free, +// uint64_t& available) +// { +// return kodi::dl::api.kodi_vfs_get_disk_space( +// path.c_str(), &capacity, &free, &available); +// } //------------------------------------------------------------------------------ //============================================================================== @@ -1371,7 +1294,7 @@ inline bool ATTR_DLL_LOCAL GetDiskSpace(const std::string& path, /// fprintf(stderr, "File name is '%s'\n", fileName.c_str()); /// ~~~~~~~~~~~~~ /// -inline std::string ATTR_DLL_LOCAL GetFileName(const std::string& path) +inline std::string GetFileName(const std::string& path) { /* find the last slash */ const size_t slash = path.find_last_of("/\\"); @@ -1397,7 +1320,7 @@ inline std::string ATTR_DLL_LOCAL GetFileName(const std::string& path) /// fprintf(stderr, "Directory name is '%s'\n", dirName.c_str()); /// ~~~~~~~~~~~~~ /// -inline std::string ATTR_DLL_LOCAL GetDirectoryName(const std::string& path) +inline std::string GetDirectoryName(const std::string& path) { // Will from a full filename return the directory the file resides in. // Keeps the final slash at end and possible |option=foo options. @@ -1432,7 +1355,7 @@ inline std::string ATTR_DLL_LOCAL GetDirectoryName(const std::string& path) /// fprintf(stderr, "Directory name is '%s'\n", dirName.c_str()); /// ~~~~~~~~~~~~~ /// -inline void ATTR_DLL_LOCAL RemoveSlashAtEnd(std::string& path) +inline void RemoveSlashAtEnd(std::string& path) { if (!path.empty()) { @@ -1452,7 +1375,7 @@ inline void ATTR_DLL_LOCAL RemoveSlashAtEnd(std::string& path) /// @param[in] minimum The minimum size (or maybe the minimum number of chunks?) /// @return The aligned size /// -inline unsigned int ATTR_DLL_LOCAL GetChunkSize(unsigned int chunk, unsigned int minimum) +inline unsigned int GetChunkSize(unsigned int chunk, unsigned int minimum) { if (chunk) return chunk * ((minimum + chunk - 1) / chunk); @@ -1509,12 +1432,9 @@ inline unsigned int ATTR_DLL_LOCAL GetChunkSize(unsigned int chunk, unsigned int /// kodi::vfs::IsInternetStream("ftp://do-somewhere.com/the-file.mkv") ? "yes" : "no", true); /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL IsInternetStream(const std::string& path, bool strictCheck = false) +inline bool IsInternetStream(const std::string& path, bool strictCheck = false) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->is_internet_stream( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str(), strictCheck); + return kodi::dl::api.kodi_vfs_is_internet_stream(path.c_str(), strictCheck); } //------------------------------------------------------------------------------ @@ -1541,12 +1461,9 @@ inline bool ATTR_DLL_LOCAL IsInternetStream(const std::string& path, bool strict /// bool lan = kodi::vfs::IsOnLAN("smb://path/to/file"); /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL IsOnLAN(const std::string& path) +inline bool IsOnLAN(const std::string& path) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->is_on_lan( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str()); + return kodi::dl::api.kodi_vfs_is_on_lan(path.c_str()); } //------------------------------------------------------------------------------ @@ -1570,12 +1487,9 @@ inline bool ATTR_DLL_LOCAL IsOnLAN(const std::string& path) /// bool remote = kodi::vfs::IsRemote("http://path/to/file"); /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL IsRemote(const std::string& path) +inline bool IsRemote(const std::string& path) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->is_remote( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str()); + return kodi::dl::api.kodi_vfs_is_remote(path.c_str()); } //------------------------------------------------------------------------------ @@ -1586,12 +1500,9 @@ inline bool ATTR_DLL_LOCAL IsRemote(const std::string& path) /// @param[in] path To checked path /// @return True if path is local, false otherwise /// -inline bool ATTR_DLL_LOCAL IsLocal(const std::string& path) +inline bool IsLocal(const std::string& path) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->is_local( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str()); + return kodi::dl::api.kodi_vfs_is_local(path.c_str()); } //------------------------------------------------------------------------------ @@ -1617,14 +1528,11 @@ inline bool ATTR_DLL_LOCAL IsLocal(const std::string& path) /// isURL = kodi::vfs::IsURL("/path/to/file"); /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL IsURL(const std::string& path) +inline bool IsURL(const std::string& path) { - using namespace kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->is_url( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str()); + return kodi::dl::api.kodi_vfs_is_url(path.c_str()); } -//-------------------------------------------------------------------------- +//------------------------------------------------------------------------------ //============================================================================ /// @ingroup cpp_kodi_vfs_General @@ -1650,14 +1558,12 @@ inline bool ATTR_DLL_LOCAL IsURL(const std::string& path) /// ... /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL GetHttpHeader(const std::string& url, HttpHeader& header) +inline bool GetHttpHeader(const std::string& url, HttpHeader& header) { - using namespace ::kodi::addon; - - return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_http_header( - CPrivateBase::m_interface->toKodi->kodiBase, url.c_str(), &header.m_handle); + header.m_handle = kodi::dl::api.kodi_vfs_http_header_open(url.c_str()); + return header.m_handle != nullptr; } -//---------------------------------------------------------------------------- +//------------------------------------------------------------------------------ //============================================================================ /// @ingroup cpp_kodi_vfs_General @@ -1681,24 +1587,20 @@ inline bool ATTR_DLL_LOCAL GetHttpHeader(const std::string& url, HttpHeader& hea /// ... /// ~~~~~~~~~~~~~ /// -inline bool ATTR_DLL_LOCAL GetMimeType(const std::string& url, - std::string& mimeType, - const std::string& useragent = "") +inline bool GetMimeType(const std::string& url, + std::string& mimeType, + const std::string& useragent = "") { - using namespace ::kodi::addon; - char* cMimeType = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_mime_type( - CPrivateBase::m_interface->toKodi->kodiBase, url.c_str(), &cMimeType, useragent.c_str()); + bool ret = kodi::dl::api.kodi_vfs_get_mime_type(url.c_str(), &cMimeType, useragent.c_str()); if (cMimeType != nullptr) { mimeType = cMimeType; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - cMimeType); + free(cMimeType); } return ret; } -//---------------------------------------------------------------------------- +//------------------------------------------------------------------------------ //============================================================================ /// @ingroup cpp_kodi_vfs_General @@ -1726,20 +1628,16 @@ inline bool ATTR_DLL_LOCAL GetContentType(const std::string& url, std::string& content, const std::string& useragent = "") { - using namespace ::kodi::addon; - char* cContent = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_content_type( - CPrivateBase::m_interface->toKodi->kodiBase, url.c_str(), &cContent, useragent.c_str()); + bool ret = kodi::dl::api.kodi_vfs_get_content_type(url.c_str(), &cContent, useragent.c_str()); if (cContent != nullptr) { content = cContent; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - cContent); + free(cContent); } return ret; } -//---------------------------------------------------------------------------- +//------------------------------------------------------------------------------ //============================================================================ /// @ingroup cpp_kodi_vfs_General @@ -1766,22 +1664,16 @@ inline bool ATTR_DLL_LOCAL GetContentType(const std::string& url, /// inline bool ATTR_DLL_LOCAL GetCookies(const std::string& url, std::string& cookies) { - using namespace ::kodi::addon; - char* cCookies = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_cookies( - CPrivateBase::m_interface->toKodi->kodiBase, url.c_str(), &cCookies); + bool ret = kodi::dl::api.kodi_vfs_get_cookies(url.c_str(), &cCookies); if (cCookies != nullptr) { cookies = cCookies; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - cCookies); + free(cCookies); } return ret; } -//---------------------------------------------------------------------------- - -//}}} +//------------------------------------------------------------------------------ //¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // "C++" CFile class @@ -1857,11 +1749,8 @@ class ATTR_DLL_LOCAL CFile /// bool OpenFile(const std::string& filename, unsigned int flags = 0) { - using namespace kodi::addon; - Close(); - m_file = CPrivateBase::m_interface->toKodi->kodi_filesystem->open_file( - CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), flags); + m_file = kodi::dl::api.kodi_vfs_file_open(filename.c_str(), flags); return m_file != nullptr; } //-------------------------------------------------------------------------- @@ -1880,23 +1769,17 @@ class ATTR_DLL_LOCAL CFile /// bool OpenFileForWrite(const std::string& filename, bool overwrite = false) { - using namespace kodi::addon; - Close(); // Try to open the file. If it fails, check if we need to create the directory first // This way we avoid checking if the directory exists every time - m_file = CPrivateBase::m_interface->toKodi->kodi_filesystem->open_file_for_write( - CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), overwrite); + m_file = kodi::dl::api.kodi_vfs_file_open_for_write(filename.c_str(), overwrite); if (!m_file) { std::string cacheDirectory = kodi::vfs::GetDirectoryName(filename); - if (CPrivateBase::m_interface->toKodi->kodi_filesystem->directory_exists( - CPrivateBase::m_interface->toKodi->kodiBase, cacheDirectory.c_str()) || - CPrivateBase::m_interface->toKodi->kodi_filesystem->create_directory( - CPrivateBase::m_interface->toKodi->kodiBase, cacheDirectory.c_str())) - m_file = CPrivateBase::m_interface->toKodi->kodi_filesystem->open_file_for_write( - CPrivateBase::m_interface->toKodi->kodiBase, filename.c_str(), overwrite); + if (kodi::dl::api.kodi_vfs_directory_exists(cacheDirectory.c_str()) || + kodi::dl::api.kodi_vfs_create_directory(cacheDirectory.c_str())) + m_file = kodi::dl::api.kodi_vfs_file_open_for_write(filename.c_str(), overwrite); } return m_file != nullptr; } @@ -1917,12 +1800,9 @@ class ATTR_DLL_LOCAL CFile /// void Close() { - using namespace kodi::addon; - if (!m_file) return; - CPrivateBase::m_interface->toKodi->kodi_filesystem->close_file( - CPrivateBase::m_interface->toKodi->kodiBase, m_file); + kodi::dl::api.kodi_vfs_file_close(m_file); m_file = nullptr; } //-------------------------------------------------------------------------- @@ -1936,10 +1816,7 @@ class ATTR_DLL_LOCAL CFile /// bool CURLCreate(const std::string& url) { - using namespace kodi::addon; - - m_file = CPrivateBase::m_interface->toKodi->kodi_filesystem->curl_create( - CPrivateBase::m_interface->toKodi->kodiBase, url.c_str()); + m_file = kodi::dl::api.kodi_vfs_file_curl_create(url.c_str()); return m_file != nullptr; } //-------------------------------------------------------------------------- @@ -1955,15 +1832,12 @@ class ATTR_DLL_LOCAL CFile /// bool CURLAddOption(CURLOptiontype type, const std::string& name, const std::string& value) { - using namespace kodi::addon; - if (!m_file) { kodi::Log(ADDON_LOG_ERROR, "kodi::vfs::CURLCreate(...) needed to call before!"); return false; } - return CPrivateBase::m_interface->toKodi->kodi_filesystem->curl_add_option( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, type, name.c_str(), value.c_str()); + return kodi::dl::api.kodi_vfs_file_curl_add_option(m_file, type, name.c_str(), value.c_str()); } //-------------------------------------------------------------------------- @@ -1976,15 +1850,12 @@ class ATTR_DLL_LOCAL CFile /// bool CURLOpen(unsigned int flags = 0) { - using namespace kodi::addon; - if (!m_file) { kodi::Log(ADDON_LOG_ERROR, "kodi::vfs::CURLCreate(...) needed to call before!"); return false; } - return CPrivateBase::m_interface->toKodi->kodi_filesystem->curl_open( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, flags); + return kodi::dl::api.kodi_vfs_file_curl_open(m_file, flags); } //-------------------------------------------------------------------------- @@ -1999,14 +1870,11 @@ class ATTR_DLL_LOCAL CFile /// file was reached) or undetectable error occur, -1 in case of any /// explicit error /// - ssize_t Read(void* ptr, size_t size) + ssize_t Read(uint8_t* ptr, size_t size) { - using namespace kodi::addon; - if (!m_file) return -1; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->read_file( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, ptr, size); + return kodi::dl::api.kodi_vfs_file_read(m_file, ptr, size); } //-------------------------------------------------------------------------- @@ -2019,8 +1887,6 @@ class ATTR_DLL_LOCAL CFile /// bool ReadLine(std::string& line) { - using namespace kodi::addon; - line.clear(); if (!m_file) return false; @@ -2028,8 +1894,7 @@ class ATTR_DLL_LOCAL CFile // chars, we didn't hit a newline. Otherwise, if file position is 1 or 2 // past the number of bytes read, we read (and skipped) a newline sequence. char buffer[1025]; - if (CPrivateBase::m_interface->toKodi->kodi_filesystem->read_file_string( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, buffer, sizeof(buffer))) + if (kodi::dl::api.kodi_vfs_file_read_line(m_file, buffer, sizeof(buffer))) { line = buffer; return !line.empty(); @@ -2048,14 +1913,11 @@ class ATTR_DLL_LOCAL CFile /// zero if no bytes were written and no detectable error occur,-1 /// in case of any explicit error /// - ssize_t Write(const void* ptr, size_t size) + ssize_t Write(const uint8_t* ptr, size_t size) { - using namespace kodi::addon; - if (!m_file) return -1; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->write_file( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, ptr, size); + return kodi::dl::api.kodi_vfs_file_write(m_file, ptr, size); } //-------------------------------------------------------------------------- @@ -2075,12 +1937,9 @@ class ATTR_DLL_LOCAL CFile /// void Flush() { - using namespace kodi::addon; - if (!m_file) return; - CPrivateBase::m_interface->toKodi->kodi_filesystem->flush_file( - CPrivateBase::m_interface->toKodi->kodiBase, m_file); + kodi::dl::api.kodi_vfs_file_flush(m_file); } //-------------------------------------------------------------------------- @@ -2104,12 +1963,9 @@ class ATTR_DLL_LOCAL CFile /// int64_t Seek(int64_t position, int whence = SEEK_SET) { - using namespace kodi::addon; - if (!m_file) return -1; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->seek_file( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, position, whence); + return kodi::dl::api.kodi_vfs_file_seek(m_file, position, whence); } //-------------------------------------------------------------------------- @@ -2122,12 +1978,9 @@ class ATTR_DLL_LOCAL CFile /// int Truncate(int64_t size) { - using namespace kodi::addon; - if (!m_file) return -1; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->truncate_file( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, size); + return kodi::dl::api.kodi_vfs_file_truncate(m_file, size); } //-------------------------------------------------------------------------- @@ -2139,12 +1992,9 @@ class ATTR_DLL_LOCAL CFile /// int64_t GetPosition() const { - using namespace kodi::addon; - if (!m_file) return -1; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_position( - CPrivateBase::m_interface->toKodi->kodiBase, m_file); + return kodi::dl::api.kodi_vfs_file_get_position(m_file); } //-------------------------------------------------------------------------- @@ -2156,12 +2006,9 @@ class ATTR_DLL_LOCAL CFile /// int64_t GetLength() const { - using namespace kodi::addon; - if (!m_file) return -1; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_length( - CPrivateBase::m_interface->toKodi->kodiBase, m_file); + return kodi::dl::api.kodi_vfs_file_get_length(m_file); } //-------------------------------------------------------------------------- @@ -2171,18 +2018,7 @@ class ATTR_DLL_LOCAL CFile /// /// @return If you've reached the end of the file, AtEnd() returns true. /// - bool AtEnd() const - { - using namespace kodi::addon; - - if (!m_file) - return true; - int64_t length = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_length( - CPrivateBase::m_interface->toKodi->kodiBase, m_file); - int64_t position = CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_position( - CPrivateBase::m_interface->toKodi->kodiBase, m_file); - return position >= length; - } + bool AtEnd() const { return kodi::dl::api.kodi_vfs_file_at_end(m_file); } //-------------------------------------------------------------------------- //========================================================================== @@ -2193,12 +2029,9 @@ class ATTR_DLL_LOCAL CFile /// int GetChunkSize() const { - using namespace kodi::addon; - if (!m_file) return -1; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_chunk_size( - CPrivateBase::m_interface->toKodi->kodiBase, m_file); + return kodi::dl::api.kodi_vfs_file_get_chunk_size(m_file); } //-------------------------------------------------------------------------- @@ -2210,12 +2043,9 @@ class ATTR_DLL_LOCAL CFile /// bool IoControlGetSeekPossible() const { - using namespace kodi::addon; - if (!m_file) return false; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->io_control_get_seek_possible( - CPrivateBase::m_interface->toKodi->kodiBase, m_file); + return kodi::dl::api.kodi_vfs_file_io_ctl_get_seek_possible(m_file); } //-------------------------------------------------------------------------- @@ -2231,14 +2061,11 @@ class ATTR_DLL_LOCAL CFile /// bool IoControlGetCacheStatus(CacheStatus& status) const { - using namespace kodi::addon; - if (!m_file) return false; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->io_control_get_cache_status( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, status); + return kodi::dl::api.kodi_vfs_file_io_ctl_get_cache_status(m_file, status); } - //-------------------------------------------------------------------------- + //------------------------------------------------------------------------------ //========================================================================== /// @ingroup cpp_kodi_vfs_CFile @@ -2249,14 +2076,11 @@ class ATTR_DLL_LOCAL CFile /// bool IoControlSetCacheRate(uint32_t rate) { - using namespace kodi::addon; - if (!m_file) return false; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->io_control_set_cache_rate( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, rate); + return kodi::dl::api.kodi_vfs_file_io_ctl_set_cache_rate(m_file, rate); } - //-------------------------------------------------------------------------- + //------------------------------------------------------------------------------ //========================================================================== /// @ingroup cpp_kodi_vfs_CFile @@ -2267,14 +2091,11 @@ class ATTR_DLL_LOCAL CFile /// bool IoControlSetRetry(bool retry) { - using namespace kodi::addon; - if (!m_file) return false; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->io_control_set_retry( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, retry); + return kodi::dl::api.kodi_vfs_file_io_ctl_set_retry(m_file, retry); } - //-------------------------------------------------------------------------- + //------------------------------------------------------------------------------ //========================================================================== /// @ingroup cpp_kodi_vfs_CFile @@ -2286,8 +2107,6 @@ class ATTR_DLL_LOCAL CFile /// const std::string GetPropertyValue(FilePropertyTypes type, const std::string& name) const { - using namespace kodi::addon; - if (!m_file) { kodi::Log(ADDON_LOG_ERROR, @@ -2314,27 +2133,27 @@ class ATTR_DLL_LOCAL CFile const std::vector GetPropertyValues(FilePropertyTypes type, const std::string& name) const { - using namespace kodi::addon; - if (!m_file) { kodi::Log(ADDON_LOG_ERROR, "kodi::vfs::CURLCreate(...) needed to call before GetPropertyValues!"); return std::vector(); } - int numValues = 0; - char** res(CPrivateBase::m_interface->toKodi->kodi_filesystem->get_property_values( - CPrivateBase::m_interface->toKodi->kodiBase, m_file, type, name.c_str(), &numValues)); + size_t numValues = 0; + char** res( + kodi::dl::api.kodi_vfs_file_get_property_values(m_file, type, name.c_str(), &numValues)); if (res) { std::vector vecReturn; vecReturn.reserve(numValues); - for (int i = 0; i < numValues; ++i) + for (size_t i = 0; i < numValues; ++i) { vecReturn.emplace_back(res[i]); + free(res[i]); } - CPrivateBase::m_interface->toKodi->free_string_array( - CPrivateBase::m_interface->toKodi->kodiBase, res, numValues); + + free(res); + return vecReturn; } return std::vector(); @@ -2349,22 +2168,15 @@ class ATTR_DLL_LOCAL CFile /// double GetFileDownloadSpeed() const { - using namespace kodi::addon; - if (!m_file) return 0.0; - return CPrivateBase::m_interface->toKodi->kodi_filesystem->get_file_download_speed( - CPrivateBase::m_interface->toKodi->kodiBase, m_file); + return kodi::dl::api.kodi_vfs_file_get_download_speed(m_file); } //-------------------------------------------------------------------------- private: - void* m_file = nullptr; + KODI_FILE_HDL m_file = nullptr; }; -///@} -//------------------------------------------------------------------------------ - -//}}} } /* namespace vfs */ } /* namespace kodi */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/General.h b/xbmc/addons/kodi-dev-kit/include/kodi/General.h index 71678c2a56c24..a1825929af5c1 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/General.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/General.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2018 Team Kodi + * Copyright (C) 2005-2021 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later @@ -14,6 +14,8 @@ #ifdef __cplusplus +#include + //============================================================================== /// \ingroup cpp_kodi_Defs /// @brief For kodi::Version used structure @@ -67,14 +69,12 @@ inline bool ATTR_DLL_LOCAL UnknownToUTF8(const std::string& stringSrc, using namespace kodi::addon; bool ret = false; - char* retString = CPrivateBase::m_interface->toKodi->kodi->unknown_to_utf8( - CPrivateBase::m_interface->toKodi->kodiBase, stringSrc.c_str(), &ret, failOnBadChar); + char* retString = kodi::dl::api.kodi_unknown_to_utf8(stringSrc.c_str(), &ret, failOnBadChar); if (retString != nullptr) { if (ret) utf8StringDst = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -107,17 +107,13 @@ inline bool ATTR_DLL_LOCAL UnknownToUTF8(const std::string& stringSrc, inline std::string ATTR_DLL_LOCAL GetLanguage(LangFormats format = LANG_FMT_ENGLISH_NAME, bool region = false) { - using namespace kodi::addon; - std::string language; - char* retString = CPrivateBase::m_interface->toKodi->kodi->get_language( - CPrivateBase::m_interface->toKodi->kodiBase, format, region); + char* retString = kodi::dl::api.kodi_get_language(format, region); if (retString != nullptr) { if (std::strlen(retString)) language = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return language; } @@ -201,16 +197,12 @@ inline std::string ATTR_DLL_LOCAL GetLanguage(LangFormats format = LANG_FMT_ENGL /// inline void ATTR_DLL_LOCAL QueueFormattedNotification(QueueMsg type, const char* format, ...) { - using namespace kodi::addon; - va_list args; va_start(args, format); const std::string str = kodi::tools::StringUtils::FormatV(format, args); va_end(args); - CPrivateBase::m_interface->toKodi->kodi->queue_notification( - CPrivateBase::m_interface->toKodi->kodiBase, type, "", str.c_str(), "", 5000, false, 1000); + kodi::dl::api.kodi_queue_notification(type, "", str.c_str(), "", 5000, false, 1000); } -//------------------------------------------------------------------------------ //============================================================================== /// \ingroup cpp_kodi @@ -265,46 +257,11 @@ inline void ATTR_DLL_LOCAL QueueNotification(QueueMsg type, bool withSound = true, unsigned int messageTime = 1000) { - using namespace kodi::addon; - - CPrivateBase::m_interface->toKodi->kodi->queue_notification( - CPrivateBase::m_interface->toKodi->kodiBase, type, header.c_str(), message.c_str(), - imageFile.c_str(), displayTime, withSound, messageTime); + kodi::dl::api.kodi_queue_notification(type, header.c_str(), message.c_str(), imageFile.c_str(), + displayTime, withSound, messageTime); } //------------------------------------------------------------------------------ -//============================================================================ -/// \ingroup cpp_kodi -/// @brief Get the MD5 digest of the given text -/// -/// @param[in] text text to compute the MD5 for -/// @return Returned MD5 digest -/// -/// -/// ------------------------------------------------------------------------ -/// -/// **Example:** -/// ~~~~~~~~~~~~~{.cpp} -/// #include -/// ... -/// std::string md5 = kodi::GetMD5("Make me as md5"); -/// fprintf(stderr, "My md5 digest is: '%s'\n", md5.c_str()); -/// ... -/// ~~~~~~~~~~~~~ -/// -inline std::string ATTR_DLL_LOCAL GetMD5(const std::string& text) -{ - using namespace kodi::addon; - - char* md5ret = static_cast(malloc(40 * sizeof(char))); // md5 size normally 32 bytes - CPrivateBase::m_interface->toKodi->kodi->get_md5(CPrivateBase::m_interface->toKodi->kodiBase, - text.c_str(), md5ret); - std::string md5 = md5ret; - free(md5ret); - return md5; -} -//---------------------------------------------------------------------------- - //============================================================================== /// \ingroup cpp_kodi /// @brief Returns your regions setting as a string for the specified id @@ -330,17 +287,13 @@ inline std::string ATTR_DLL_LOCAL GetMD5(const std::string& text) /// inline std::string ATTR_DLL_LOCAL GetRegion(const std::string& id) { - using namespace kodi::addon; - - AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi; - std::string strReturn; - char* strMsg = toKodi->kodi->get_region(toKodi->kodiBase, id.c_str()); + char* strMsg = kodi::dl::api.kodi_get_region(id.c_str()); if (strMsg != nullptr) { if (std::strlen(strMsg)) strReturn = strMsg; - toKodi->free_string(toKodi->kodiBase, strMsg); + free(strMsg); } return strReturn; } @@ -371,12 +324,9 @@ inline std::string ATTR_DLL_LOCAL GetRegion(const std::string& id) /// inline void ATTR_DLL_LOCAL GetFreeMem(long& free, long& total, bool asBytes = false) { - using namespace kodi::addon; - free = -1; total = -1; - AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi; - toKodi->kodi->get_free_mem(toKodi->kodiBase, &free, &total, asBytes); + kodi::dl::api.kodi_get_free_mem(&free, &total, asBytes); } //------------------------------------------------------------------------------ @@ -399,10 +349,7 @@ inline void ATTR_DLL_LOCAL GetFreeMem(long& free, long& total, bool asBytes = fa /// inline int ATTR_DLL_LOCAL GetGlobalIdleTime() { - using namespace kodi::addon; - - AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi; - return toKodi->kodi->get_global_idle_time(toKodi->kodiBase); + return kodi::dl::api.kodi_get_global_idle_time(); } //------------------------------------------------------------------------------ @@ -429,17 +376,13 @@ inline int ATTR_DLL_LOCAL GetGlobalIdleTime() /// inline std::string ATTR_DLL_LOCAL GetCurrentSkinId() { - using namespace kodi::addon; - - AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi; - std::string strReturn; - char* strMsg = toKodi->kodi->get_current_skin_id(toKodi->kodiBase); + char* strMsg = kodi::dl::api.kodi_get_current_skin_id(); if (strMsg != nullptr) { if (std::strlen(strMsg)) strReturn = strMsg; - toKodi->free_string(toKodi->kodiBase, strMsg); + free(strMsg); } return strReturn; } @@ -472,16 +415,12 @@ inline bool ATTR_DLL_LOCAL IsAddonAvailable(const std::string& id, std::string& version, bool& enabled) { - using namespace kodi::addon; - - AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi; - char* cVersion = nullptr; - bool ret = toKodi->kodi->is_addon_avilable(toKodi->kodiBase, id.c_str(), &cVersion, &enabled); + bool ret = kodi::dl::api.kodi_is_addon_avilable(id.c_str(), &cVersion, &enabled); if (cVersion) { version = cVersion; - toKodi->free_string(toKodi->kodiBase, cVersion); + free(cVersion); } return ret; } @@ -528,35 +467,32 @@ inline bool ATTR_DLL_LOCAL IsAddonAvailable(const std::string& id, /// inline void ATTR_DLL_LOCAL KodiVersion(kodi_version_t& version) { - using namespace kodi::addon; - char* compile_name = nullptr; char* revision = nullptr; char* tag = nullptr; char* tag_revision = nullptr; - AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi; - toKodi->kodi->kodi_version(toKodi->kodiBase, &compile_name, &version.major, &version.minor, - &revision, &tag, &tag_revision); + kodi::dl::api.kodi_version(&compile_name, &version.major, &version.minor, &revision, &tag, + &tag_revision); if (compile_name != nullptr) { version.compile_name = compile_name; - toKodi->free_string(toKodi->kodiBase, compile_name); + free(compile_name); } if (revision != nullptr) { version.revision = revision; - toKodi->free_string(toKodi->kodiBase, revision); + free(revision); } if (tag != nullptr) { version.tag = tag; - toKodi->free_string(toKodi->kodiBase, tag); + free(tag); } if (tag_revision != nullptr) { version.tag_revision = tag_revision; - toKodi->free_string(toKodi->kodiBase, tag_revision); + free(tag_revision); } } //------------------------------------------------------------------------------ @@ -598,19 +534,15 @@ inline bool ATTR_DLL_LOCAL GetKeyboardLayout(int modifierKey, std::string& layout_name, std::vector>& layout) { - using namespace kodi::addon; - - AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi; AddonKeyboardKeyTable c_layout; char* c_layout_name = nullptr; - bool ret = - toKodi->kodi->get_keyboard_layout(toKodi->kodiBase, &c_layout_name, modifierKey, &c_layout); + bool ret = kodi::dl::api.kodi_get_keyboard_layout(modifierKey, &c_layout_name, &c_layout); if (ret) { if (c_layout_name) { layout_name = c_layout_name; - toKodi->free_string(toKodi->kodiBase, c_layout_name); + free(c_layout_name); } layout.resize(STD_KB_BUTTONS_MAX_ROWS); @@ -623,7 +555,7 @@ inline bool ATTR_DLL_LOCAL GetKeyboardLayout(int modifierKey, if (button) { layout[row][column] = button; - toKodi->free_string(toKodi->kodiBase, button); + free(button); } } } @@ -668,21 +600,45 @@ inline bool ATTR_DLL_LOCAL GetKeyboardLayout(int modifierKey, /// inline bool ATTR_DLL_LOCAL ChangeKeyboardLayout(std::string& layout_name) { - using namespace kodi::addon; - - AddonToKodiFuncTable_Addon* toKodi = CPrivateBase::m_interface->toKodi; char* c_layout_name = nullptr; - bool ret = toKodi->kodi->change_keyboard_layout(toKodi->kodiBase, &c_layout_name); + bool ret = kodi::dl::api.kodi_change_keyboard_layout(&c_layout_name); if (c_layout_name) { layout_name = c_layout_name; - toKodi->free_string(toKodi->kodiBase, c_layout_name); + free(c_layout_name); } return ret; } //------------------------------------------------------------------------------ +//============================================================================== +/// @ingroup cpp_kodi +/// @brief +/// +/// +/// +/// @param[in] filename +/// @param[in] use_cached +/// +inline void ATTR_DLL_LOCAL PlaySFX(const std::string& filename, bool use_cached) +{ + kodi::dl::api.kodi_play_sfx(filename.c_str(), use_cached); +} +//------------------------------------------------------------------------------ + +//============================================================================== +/// @ingroup cpp_kodi +/// @brief +/// +/// +/// +inline void ATTR_DLL_LOCAL StopSFX() +{ + kodi::dl::api.kodi_stop_sfx(); +} +//------------------------------------------------------------------------------ + } /* namespace kodi */ #endif /* __cplusplus */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/Monitor.h b/xbmc/addons/kodi-dev-kit/include/kodi/Monitor.h new file mode 100644 index 0000000000000..73ffcf88ad920 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/include/kodi/Monitor.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2005-2021 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "AddonBase.h" +#include "c-api/monitor.h" + +#ifdef __cplusplus + +namespace kodi +{ +namespace monitor +{ + +inline bool ATTR_DLL_LOCAL WaitForAbort(double timeout) +{ + return kodi::dl::api.kodi_monitor_wait_for_abort(timeout); +} + +inline bool ATTR_DLL_LOCAL AbortRequested() +{ + return kodi::dl::api.kodi_monitor_abort_requested(); +} + +} /* namespace monitor */ +} /* namespace kodi */ + +#endif /* __cplusplus */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/Network.h b/xbmc/addons/kodi-dev-kit/include/kodi/Network.h index e6ff2c985e342..e98101c77d542 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/Network.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/Network.h @@ -40,8 +40,8 @@ inline bool ATTR_DLL_LOCAL WakeOnLan(const std::string& mac) { using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_network->wake_on_lan( - CPrivateBase::m_interface->toKodi->kodiBase, mac.c_str()); + return CPrivateBase::ifc.toKodi->kodi_network->wake_on_lan(CPrivateBase::ifc.toKodi->kodiBase, + mac.c_str()); } //---------------------------------------------------------------------------- @@ -68,13 +68,12 @@ inline std::string ATTR_DLL_LOCAL GetIPAddress() using namespace ::kodi::addon; std::string ip; - char* string = CPrivateBase::m_interface->toKodi->kodi_network->get_ip_address( - CPrivateBase::m_interface->toKodi->kodiBase); + char* string = + CPrivateBase::ifc.toKodi->kodi_network->get_ip_address(CPrivateBase::ifc.toKodi->kodiBase); if (string != nullptr) { ip = string; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - string); + CPrivateBase::ifc.toKodi->free_string(CPrivateBase::ifc.toKodi->kodiBase, string); } return ip; } @@ -103,13 +102,12 @@ inline std::string ATTR_DLL_LOCAL GetHostname() using namespace ::kodi::addon; std::string ip; - char* string = CPrivateBase::m_interface->toKodi->kodi_network->get_hostname( - CPrivateBase::m_interface->toKodi->kodiBase); + char* string = + CPrivateBase::ifc.toKodi->kodi_network->get_hostname(CPrivateBase::ifc.toKodi->kodiBase); if (string != nullptr) { ip = string; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - string); + CPrivateBase::ifc.toKodi->free_string(CPrivateBase::ifc.toKodi->kodiBase, string); } return ip; } @@ -139,13 +137,12 @@ inline std::string ATTR_DLL_LOCAL GetUserAgent() using namespace ::kodi::addon; std::string agent; - char* string = CPrivateBase::m_interface->toKodi->kodi_network->get_user_agent( - CPrivateBase::m_interface->toKodi->kodiBase); + char* string = + CPrivateBase::ifc.toKodi->kodi_network->get_user_agent(CPrivateBase::ifc.toKodi->kodiBase); if (string != nullptr) { agent = string; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - string); + CPrivateBase::ifc.toKodi->free_string(CPrivateBase::ifc.toKodi->kodiBase, string); } return agent; } @@ -174,8 +171,8 @@ inline bool ATTR_DLL_LOCAL IsLocalHost(const std::string& hostname) { using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_network->is_local_host( - CPrivateBase::m_interface->toKodi->kodiBase, hostname.c_str()); + return CPrivateBase::ifc.toKodi->kodi_network->is_local_host(CPrivateBase::ifc.toKodi->kodiBase, + hostname.c_str()); } //---------------------------------------------------------------------------- @@ -191,8 +188,8 @@ inline bool ATTR_DLL_LOCAL IsHostOnLAN(const std::string& hostname, bool offLine { using namespace kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_network->is_host_on_lan( - CPrivateBase::m_interface->toKodi->kodiBase, hostname.c_str(), offLineCheck); + return CPrivateBase::ifc.toKodi->kodi_network->is_host_on_lan(CPrivateBase::ifc.toKodi->kodiBase, + hostname.c_str(), offLineCheck); } //------------------------------------------------------------------------------ @@ -226,13 +223,12 @@ inline std::string ATTR_DLL_LOCAL URLEncode(const std::string& url) using namespace ::kodi::addon; std::string retString; - char* string = CPrivateBase::m_interface->toKodi->kodi_network->url_encode( - CPrivateBase::m_interface->toKodi->kodiBase, url.c_str()); + char* string = CPrivateBase::ifc.toKodi->kodi_network->url_encode( + CPrivateBase::ifc.toKodi->kodiBase, url.c_str()); if (string != nullptr) { retString = string; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - string); + CPrivateBase::ifc.toKodi->free_string(CPrivateBase::ifc.toKodi->kodiBase, string); } return retString; } @@ -269,13 +265,12 @@ inline bool ATTR_DLL_LOCAL DNSLookup(const std::string& hostName, std::string& i using namespace ::kodi::addon; bool ret = false; - char* string = CPrivateBase::m_interface->toKodi->kodi_network->dns_lookup( - CPrivateBase::m_interface->toKodi->kodiBase, hostName.c_str(), &ret); + char* string = CPrivateBase::ifc.toKodi->kodi_network->dns_lookup( + CPrivateBase::ifc.toKodi->kodiBase, hostName.c_str(), &ret); if (string != nullptr) { ipAddress = string; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - string); + CPrivateBase::ifc.toKodi->free_string(CPrivateBase::ifc.toKodi->kodiBase, string); } return ret; } diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioDecoder.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioDecoder.h index 8569bc3c93bbc..c3621e755e1c9 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioDecoder.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioDecoder.h @@ -467,10 +467,6 @@ class ATTR_DLL_LOCAL CInstanceAudioDecoder : public IAddonInstance explicit CInstanceAudioDecoder(const kodi::addon::IInstanceInfo& instance) : IAddonInstance(instance) { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstanceAudioDecoder: Creation of multiple together with single instance way is not allowed!"); - - SetAddonStruct(instance); } //-------------------------------------------------------------------------- @@ -523,7 +519,7 @@ class ATTR_DLL_LOCAL CInstanceAudioDecoder : public IAddonInstance /// @param[in] buffer Output buffer /// @param[in] size Size of output buffer /// @param[out] actualsize Actual number of bytes written to output buffer - /// @return @copydetails cpp_kodi_addon_audiodecoder_Defs_AUDIODECODER_READ_RETURN + /// @return @copydetails cpp_kodi_addon_audiodecoder_Defs_KODI_ADDON_AUDIODECODER_READ_RETURN /// virtual int ReadPCM(uint8_t* buffer, size_t size, size_t& actualsize) = 0; //-------------------------------------------------------------------------- @@ -608,15 +604,15 @@ class ATTR_DLL_LOCAL CInstanceAudioDecoder : public IAddonInstance //-------------------------------------------------------------------------- private: - void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) + void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) override { instance->hdl = this; - instance->audiodecoder->toAddon->supports_file = ADDON_supports_file; - instance->audiodecoder->toAddon->init = ADDON_init; - instance->audiodecoder->toAddon->read_pcm = ADDON_read_pcm; - instance->audiodecoder->toAddon->seek = ADDON_seek; - instance->audiodecoder->toAddon->read_tag = ADDON_read_tag; - instance->audiodecoder->toAddon->track_count = ADDON_track_count; + instance->audiodecoder->supports_file = ADDON_supports_file; + instance->audiodecoder->init = ADDON_init; + instance->audiodecoder->read_pcm = ADDON_read_pcm; + instance->audiodecoder->seek = ADDON_seek; + instance->audiodecoder->read_tag = ADDON_read_tag; + instance->audiodecoder->track_count = ADDON_track_count; } inline static bool ADDON_supports_file(const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioEncoder.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioEncoder.h index c79a472997745..c5f4c7db2c9b7 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioEncoder.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioEncoder.h @@ -13,8 +13,6 @@ #ifdef __cplusplus -#include - namespace kodi { namespace addon @@ -394,13 +392,9 @@ class ATTR_DLL_LOCAL CInstanceAudioEncoder : public IAddonInstance /// ~~~~~~~~~~~~~ /// explicit CInstanceAudioEncoder(const kodi::addon::IInstanceInfo& instance) - : IAddonInstance(instance) + : IAddonInstance(instance), + m_kodi(instance.GetKodiHdl()) { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstanceAudioEncoder: Creation of multiple together " - "with single instance way is not allowed!"); - - SetAddonStruct(instance); } //---------------------------------------------------------------------------- @@ -446,7 +440,7 @@ class ATTR_DLL_LOCAL CInstanceAudioEncoder : public IAddonInstance /// ssize_t Write(const uint8_t* data, size_t length) { - return m_kodi->write(m_kodi->kodiInstance, data, length); + return kodi::dl::api.kodi_addon_audioencoder_write(m_kodi, data, length); } //---------------------------------------------------------------------------- @@ -473,18 +467,17 @@ class ATTR_DLL_LOCAL CInstanceAudioEncoder : public IAddonInstance /// ssize_t Seek(ssize_t position, int whence = SEEK_SET) { - return m_kodi->seek(m_kodi->kodiInstance, position, whence); + return kodi::dl::api.kodi_addon_audioencoder_seek(m_kodi, position, whence); } //---------------------------------------------------------------------------- private: - void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) + void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) override { instance->hdl = this; - instance->audioencoder->toAddon->start = ADDON_start; - instance->audioencoder->toAddon->encode = ADDON_encode; - instance->audioencoder->toAddon->finish = ADDON_finish; - m_kodi = instance->audioencoder->toKodi; + instance->audioencoder->start = ADDON_start; + instance->audioencoder->encode = ADDON_encode; + instance->audioencoder->finish = ADDON_finish; } inline static bool ADDON_start(const KODI_ADDON_AUDIOENCODER_HDL hdl, @@ -505,7 +498,7 @@ class ATTR_DLL_LOCAL CInstanceAudioEncoder : public IAddonInstance return static_cast(hdl)->Finish(); } - AddonToKodiFuncTable_AudioEncoder* m_kodi{nullptr}; + const KODI_ADDON_INSTANCE_BACKEND_HDL m_kodi; }; } /* namespace addon */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/CMakeLists.txt index 8f7d20c8c4206..2c249562b48d7 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/CMakeLists.txt +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/CMakeLists.txt @@ -13,6 +13,7 @@ set(HEADERS VFS.h VideoCodec.h Visualization.h + Web.h ) if(HEADERS) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Game.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Game.h index b4f1a24264405..0a9c06ba36871 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Game.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Game.h @@ -159,16 +159,12 @@ class ATTR_DLL_LOCAL CInstanceGame : public IAddonInstance /// ADDONCREATOR(CGameExample) /// ~~~~~~~~~~~~~ /// - CInstanceGame() : IAddonInstance(IInstanceInfo(CPrivateBase::m_interface->firstKodiInstance)) - { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstanceGame: Creation of more as one in single " - "instance way is not allowed!"); + CInstanceGame() = default; + //---------------------------------------------------------------------------- - SetAddonStruct(CPrivateBase::m_interface->firstKodiInstance); - CPrivateBase::m_interface->globalSingleInstance = this; + explicit CInstanceGame(const IInstanceInfo& instance) : IAddonInstance(instance) + { } - //---------------------------------------------------------------------------- //============================================================================ /// @brief Destructor @@ -461,7 +457,7 @@ class ATTR_DLL_LOCAL CInstanceGame : public IAddonInstance /// bool Open(const game_stream_properties& properties) { - if (!CPrivateBase::m_interface->globalSingleInstance) + if (!CPrivateBase::ifc.globalSingleInstance) return false; if (m_handle) @@ -471,7 +467,7 @@ class ATTR_DLL_LOCAL CInstanceGame : public IAddonInstance } AddonToKodiFuncTable_Game& cb = - *static_cast(CPrivateBase::m_interface->globalSingleInstance) + *static_cast(CPrivateBase::ifc.globalSingleInstance) ->m_instanceData->toKodi; m_handle = cb.OpenStream(cb.kodiInstance, &properties); return m_handle != nullptr; @@ -486,11 +482,11 @@ class ATTR_DLL_LOCAL CInstanceGame : public IAddonInstance /// void Close() { - if (!m_handle || !CPrivateBase::m_interface->globalSingleInstance) + if (!m_handle || !CPrivateBase::ifc.globalSingleInstance) return; AddonToKodiFuncTable_Game& cb = - *static_cast(CPrivateBase::m_interface->globalSingleInstance) + *static_cast(CPrivateBase::ifc.globalSingleInstance) ->m_instanceData->toKodi; cb.CloseStream(cb.kodiInstance, m_handle); m_handle = nullptr; @@ -512,11 +508,11 @@ class ATTR_DLL_LOCAL CInstanceGame : public IAddonInstance /// bool GetBuffer(unsigned int width, unsigned int height, game_stream_buffer& buffer) { - if (!m_handle || !CPrivateBase::m_interface->globalSingleInstance) + if (!m_handle || !CPrivateBase::ifc.globalSingleInstance) return false; AddonToKodiFuncTable_Game& cb = - *static_cast(CPrivateBase::m_interface->globalSingleInstance) + *static_cast(CPrivateBase::ifc.globalSingleInstance) ->m_instanceData->toKodi; return cb.GetStreamBuffer(cb.kodiInstance, m_handle, width, height, &buffer); } @@ -532,11 +528,11 @@ class ATTR_DLL_LOCAL CInstanceGame : public IAddonInstance /// void AddData(const game_stream_packet& packet) { - if (!m_handle || !CPrivateBase::m_interface->globalSingleInstance) + if (!m_handle || !CPrivateBase::ifc.globalSingleInstance) return; AddonToKodiFuncTable_Game& cb = - *static_cast(CPrivateBase::m_interface->globalSingleInstance) + *static_cast(CPrivateBase::ifc.globalSingleInstance) ->m_instanceData->toKodi; cb.AddStreamData(cb.kodiInstance, m_handle, &packet); } @@ -552,11 +548,11 @@ class ATTR_DLL_LOCAL CInstanceGame : public IAddonInstance /// void ReleaseBuffer(game_stream_buffer& buffer) { - if (!m_handle || !CPrivateBase::m_interface->globalSingleInstance) + if (!m_handle || !CPrivateBase::ifc.globalSingleInstance) return; AddonToKodiFuncTable_Game& cb = - *static_cast(CPrivateBase::m_interface->globalSingleInstance) + *static_cast(CPrivateBase::ifc.globalSingleInstance) ->m_instanceData->toKodi; cb.ReleaseStreamBuffer(cb.kodiInstance, m_handle, &buffer); } diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/ImageDecoder.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/ImageDecoder.h index eb98f900285d6..cbe232acf6767 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/ImageDecoder.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/ImageDecoder.h @@ -13,21 +13,12 @@ #ifdef __cplusplus -#include - namespace kodi { namespace addon { -//############################################################################## -/// @defgroup cpp_kodi_addon_imagedecoder_Defs Definitions, structures and enumerators -/// @ingroup cpp_kodi_addon_imagedecoder -/// @brief **Image decoder add-on general variables** -/// -/// Used to exchange the available options between Kodi and addon. -/// -/// +using ImageFormat = ADDON_IMG_FMT; //============================================================================== /// @defgroup cpp_kodi_addon_imagedecoder_Defs_ImageDecoderInfoTag class ImageDecoderInfoTag @@ -546,11 +537,6 @@ class ATTR_DLL_LOCAL CInstanceImageDecoder : public IAddonInstance /// explicit CInstanceImageDecoder(const IInstanceInfo& instance) : IAddonInstance(instance) { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstanceImageDecoder: Creation of multiple together " - "with single instance way is not allowed!"); - - SetAddonStruct(instance); } //---------------------------------------------------------------------------- @@ -621,17 +607,17 @@ class ATTR_DLL_LOCAL CInstanceImageDecoder : public IAddonInstance unsigned int width, unsigned int height, unsigned int pitch, - ADDON_IMG_FMT format) = 0; + kodi::addon::ImageFormat format) = 0; //---------------------------------------------------------------------------- private: - void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) + void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) override { instance->hdl = this; - instance->imagedecoder->toAddon->supports_file = ADDON_supports_file; - instance->imagedecoder->toAddon->read_tag = ADDON_read_tag; - instance->imagedecoder->toAddon->load_image_from_memory = ADDON_load_image_from_memory; - instance->imagedecoder->toAddon->decode = ADDON_decode; + instance->imagedecoder->supports_file = ADDON_supports_file; + instance->imagedecoder->read_tag = ADDON_read_tag; + instance->imagedecoder->load_image_from_memory = ADDON_load_image_from_memory; + instance->imagedecoder->decode = ADDON_decode; } inline static bool ADDON_supports_file(const KODI_ADDON_IMAGEDECODER_HDL hdl, const char* file) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Inputstream.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Inputstream.h index 4df1807b821da..3ee588a50a69c 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Inputstream.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Inputstream.h @@ -1163,11 +1163,6 @@ class ATTR_DLL_LOCAL CInstanceInputStream : public IAddonInstance /// explicit CInstanceInputStream(const IInstanceInfo& instance) : IAddonInstance(instance) { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstanceInputStream: Creation of multiple together " - "with single instance way is not allowed!"); - - SetAddonStruct(instance); } //---------------------------------------------------------------------------- diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/PVR.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/PVR.h index 0ee71e28af35f..50fcb2cadeebe 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/PVR.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/PVR.h @@ -456,15 +456,7 @@ class ATTR_DLL_LOCAL CInstancePVRClient : public IAddonInstance /// ADDONCREATOR(CPVRExample) /// ~~~~~~~~~~~~~ /// - CInstancePVRClient() : IAddonInstance(IInstanceInfo(CPrivateBase::m_interface->firstKodiInstance)) - { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstancePVRClient: Creation of more as one in single " - "instance way is not allowed!"); - - SetAddonStruct(CPrivateBase::m_interface->firstKodiInstance); - CPrivateBase::m_interface->globalSingleInstance = this; - } + CInstancePVRClient() = default; //---------------------------------------------------------------------------- //============================================================================ @@ -502,11 +494,6 @@ class ATTR_DLL_LOCAL CInstancePVRClient : public IAddonInstance /// explicit CInstancePVRClient(const IInstanceInfo& instance) : IAddonInstance(instance) { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstancePVRClient: Creation of multiple together with " - "single instance way is not allowed!"); - - SetAddonStruct(instance); } //---------------------------------------------------------------------------- diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Peripheral.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Peripheral.h index ea07498d80418..373e2d755d693 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Peripheral.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Peripheral.h @@ -12,6 +12,9 @@ #include "peripheral/PeripheralUtils.h" #ifdef __cplusplus + +#include + namespace kodi { namespace addon @@ -215,16 +218,7 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance /// /// Used by an add-on that only supports peripheral. /// - CInstancePeripheral() - : IAddonInstance(IInstanceInfo(CPrivateBase::m_interface->firstKodiInstance)) - { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstancePeripheral: Creation of more as one in single " - "instance way is not allowed!"); - - SetAddonStruct(CPrivateBase::m_interface->firstKodiInstance); - CPrivateBase::m_interface->globalSingleInstance = this; - } + CInstancePeripheral() = default; //---------------------------------------------------------------------------- //============================================================================ @@ -263,11 +257,7 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance /// explicit CInstancePeripheral(const IInstanceInfo& instance) : IAddonInstance(instance) { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstancePeripheral: Creation of multiple together with " - "single instance way is not allowed!"); - - SetAddonStruct(instance); + m_kodi = instance.GetKodiHdl(); } //---------------------------------------------------------------------------- @@ -523,7 +513,7 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance /// /// @return The add-on installation path /// - const std::string AddonPath() const { return m_instanceData->props->addon_path; } + const std::string AddonPath() const { return kodi::addon::GetAddonPath(); } //---------------------------------------------------------------------------- //============================================================================ @@ -535,7 +525,7 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance /// /// @return Path to the user profile /// - const std::string UserPath() const { return m_instanceData->props->user_path; } + const std::string UserPath() const { return kodi::addon::GetUserPath(); } //---------------------------------------------------------------------------- //============================================================================ @@ -543,10 +533,7 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance /// /// The add-on calls this if a change in hardware is detected. /// - void TriggerScan(void) - { - return m_instanceData->toKodi->trigger_scan(m_instanceData->toKodi->kodiInstance); - } + void TriggerScan(void) { return kodi_addon_peripheral_trigger_scan(m_kodi); } //---------------------------------------------------------------------------- //============================================================================ @@ -559,8 +546,8 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance /// void RefreshButtonMaps(const std::string& deviceName = "", const std::string& controllerId = "") { - return m_instanceData->toKodi->refresh_button_maps(m_instanceData->toKodi->kodiInstance, - deviceName.c_str(), controllerId.c_str()); + return kodi_addon_peripheral_refresh_button_maps(m_kodi, deviceName.c_str(), + controllerId.c_str()); } //---------------------------------------------------------------------------- @@ -576,8 +563,7 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance unsigned int FeatureCount(const std::string& controllerId, JOYSTICK_FEATURE_TYPE type = JOYSTICK_FEATURE_TYPE_UNKNOWN) { - return m_instanceData->toKodi->feature_count(m_instanceData->toKodi->kodiInstance, - controllerId.c_str(), type); + return kodi_addon_peripheral_feature_count(m_kodi, controllerId.c_str(), type); } //---------------------------------------------------------------------------- @@ -591,64 +577,60 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance /// JOYSTICK_FEATURE_TYPE FeatureType(const std::string& controllerId, const std::string& featureName) { - return m_instanceData->toKodi->feature_type(m_instanceData->toKodi->kodiInstance, - controllerId.c_str(), featureName.c_str()); + return kodi_addon_peripheral_feature_type(m_kodi, controllerId.c_str(), featureName.c_str()); } //---------------------------------------------------------------------------- ///@} private: - void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) + friend class CAddonBase; + + void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) override { instance->hdl = this; - instance->peripheral->toAddon->get_capabilities = ADDON_GetCapabilities; - instance->peripheral->toAddon->perform_device_scan = ADDON_PerformDeviceScan; - instance->peripheral->toAddon->free_scan_results = ADDON_FreeScanResults; - instance->peripheral->toAddon->get_events = ADDON_GetEvents; - instance->peripheral->toAddon->free_events = ADDON_FreeEvents; - instance->peripheral->toAddon->send_event = ADDON_SendEvent; - - instance->peripheral->toAddon->get_joystick_info = ADDON_GetJoystickInfo; - instance->peripheral->toAddon->free_joystick_info = ADDON_FreeJoystickInfo; - instance->peripheral->toAddon->get_features = ADDON_GetFeatures; - instance->peripheral->toAddon->free_features = ADDON_FreeFeatures; - instance->peripheral->toAddon->map_features = ADDON_MapFeatures; - instance->peripheral->toAddon->get_ignored_primitives = ADDON_GetIgnoredPrimitives; - instance->peripheral->toAddon->free_primitives = ADDON_FreePrimitives; - instance->peripheral->toAddon->set_ignored_primitives = ADDON_SetIgnoredPrimitives; - instance->peripheral->toAddon->save_button_map = ADDON_SaveButtonMap; - instance->peripheral->toAddon->revert_button_map = ADDON_RevertButtonMap; - instance->peripheral->toAddon->reset_button_map = ADDON_ResetButtonMap; - instance->peripheral->toAddon->power_off_joystick = ADDON_PowerOffJoystick; - - m_instanceData = instance->peripheral; - m_instanceData->toAddon->addonInstance = this; + instance->peripheral->get_capabilities = ADDON_GetCapabilities; + instance->peripheral->perform_device_scan = ADDON_PerformDeviceScan; + instance->peripheral->free_scan_results = ADDON_FreeScanResults; + instance->peripheral->get_events = ADDON_GetEvents; + instance->peripheral->free_events = ADDON_FreeEvents; + instance->peripheral->send_event = ADDON_SendEvent; + + instance->peripheral->get_joystick_info = ADDON_GetJoystickInfo; + instance->peripheral->free_joystick_info = ADDON_FreeJoystickInfo; + instance->peripheral->get_features = ADDON_GetFeatures; + instance->peripheral->free_features = ADDON_FreeFeatures; + instance->peripheral->map_features = ADDON_MapFeatures; + instance->peripheral->get_ignored_primitives = ADDON_GetIgnoredPrimitives; + instance->peripheral->free_primitives = ADDON_FreePrimitives; + instance->peripheral->set_ignored_primitives = ADDON_SetIgnoredPrimitives; + instance->peripheral->save_button_map = ADDON_SaveButtonMap; + instance->peripheral->revert_button_map = ADDON_RevertButtonMap; + instance->peripheral->reset_button_map = ADDON_ResetButtonMap; + instance->peripheral->power_off_joystick = ADDON_PowerOffJoystick; } - inline static void ADDON_GetCapabilities(const AddonInstance_Peripheral* addonInstance, +private: + inline static void ADDON_GetCapabilities(KODI_ADDON_PERIPHERAL_HDL hdl, PERIPHERAL_CAPABILITIES* capabilities) { - if (!addonInstance || !capabilities) + if (!hdl || !capabilities) return; kodi::addon::PeripheralCapabilities peripheralCapabilities(capabilities); - static_cast(addonInstance->toAddon->addonInstance) - ->GetCapabilities(peripheralCapabilities); + static_cast(hdl)->GetCapabilities(peripheralCapabilities); } - inline static PERIPHERAL_ERROR ADDON_PerformDeviceScan( - const AddonInstance_Peripheral* addonInstance, - unsigned int* peripheral_count, - PERIPHERAL_INFO** scan_results) + inline static PERIPHERAL_ERROR ADDON_PerformDeviceScan(KODI_ADDON_PERIPHERAL_HDL hdl, + PERIPHERAL_INFO** scan_results, + size_t* peripheral_count) { - if (!addonInstance || !peripheral_count || !scan_results) + if (!hdl || !peripheral_count || !scan_results) return PERIPHERAL_ERROR_INVALID_PARAMETERS; std::vector> peripherals; - PERIPHERAL_ERROR err = static_cast(addonInstance->toAddon->addonInstance) - ->PerformDeviceScan(peripherals); + PERIPHERAL_ERROR err = static_cast(hdl)->PerformDeviceScan(peripherals); if (err == PERIPHERAL_NO_ERROR) { *peripheral_count = static_cast(peripherals.size()); @@ -658,26 +640,25 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance return err; } - inline static void ADDON_FreeScanResults(const AddonInstance_Peripheral* addonInstance, - unsigned int peripheral_count, - PERIPHERAL_INFO* scan_results) + inline static void ADDON_FreeScanResults(KODI_ADDON_PERIPHERAL_HDL hdl, + PERIPHERAL_INFO* scan_results, + size_t peripheral_count) { - if (!addonInstance) + if (!hdl) return; - kodi::addon::Peripherals::FreeStructs(peripheral_count, scan_results); + kodi::addon::Peripherals::FreeStructs(scan_results, peripheral_count); } - inline static PERIPHERAL_ERROR ADDON_GetEvents(const AddonInstance_Peripheral* addonInstance, - unsigned int* event_count, - PERIPHERAL_EVENT** events) + inline static PERIPHERAL_ERROR ADDON_GetEvents(KODI_ADDON_PERIPHERAL_HDL hdl, + PERIPHERAL_EVENT** events, + size_t* event_count) { - if (!addonInstance || !event_count || !events) + if (!hdl || !event_count || !events) return PERIPHERAL_ERROR_INVALID_PARAMETERS; std::vector peripheralEvents; - PERIPHERAL_ERROR err = static_cast(addonInstance->toAddon->addonInstance) - ->GetEvents(peripheralEvents); + PERIPHERAL_ERROR err = static_cast(hdl)->GetEvents(peripheralEvents); if (err == PERIPHERAL_NO_ERROR) { *event_count = static_cast(peripheralEvents.size()); @@ -687,35 +668,34 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance return err; } - inline static void ADDON_FreeEvents(const AddonInstance_Peripheral* addonInstance, - unsigned int event_count, - PERIPHERAL_EVENT* events) + inline static void ADDON_FreeEvents(KODI_ADDON_PERIPHERAL_HDL hdl, + PERIPHERAL_EVENT* events, + size_t event_count) { - if (!addonInstance) + if (!hdl) return; - kodi::addon::PeripheralEvents::FreeStructs(event_count, events); + kodi::addon::PeripheralEvents::FreeStructs(events, event_count); } - inline static bool ADDON_SendEvent(const AddonInstance_Peripheral* addonInstance, - const PERIPHERAL_EVENT* event) + inline static bool ADDON_SendEvent(KODI_ADDON_PERIPHERAL_HDL hdl, const PERIPHERAL_EVENT* event) { - if (!addonInstance || !event) + if (!hdl || !event) return false; - return static_cast(addonInstance->toAddon->addonInstance) - ->SendEvent(kodi::addon::PeripheralEvent(*event)); + return static_cast(hdl)->SendEvent(kodi::addon::PeripheralEvent(*event)); } - inline static PERIPHERAL_ERROR ADDON_GetJoystickInfo( - const AddonInstance_Peripheral* addonInstance, unsigned int index, JOYSTICK_INFO* info) + inline static PERIPHERAL_ERROR ADDON_GetJoystickInfo(KODI_ADDON_PERIPHERAL_HDL hdl, + unsigned int index, + JOYSTICK_INFO* info) { - if (!addonInstance || !info) + if (!hdl || !info) return PERIPHERAL_ERROR_INVALID_PARAMETERS; kodi::addon::Joystick addonInfo; - PERIPHERAL_ERROR err = static_cast(addonInstance->toAddon->addonInstance) - ->GetJoystickInfo(index, addonInfo); + PERIPHERAL_ERROR err = + static_cast(hdl)->GetJoystickInfo(index, addonInfo); if (err == PERIPHERAL_NO_ERROR) { addonInfo.ToStruct(*info); @@ -724,29 +704,28 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance return err; } - inline static void ADDON_FreeJoystickInfo(const AddonInstance_Peripheral* addonInstance, - JOYSTICK_INFO* info) + inline static void ADDON_FreeJoystickInfo(KODI_ADDON_PERIPHERAL_HDL hdl, JOYSTICK_INFO* info) { - if (!addonInstance) + if (!hdl) return; kodi::addon::Joystick::FreeStruct(*info); } - inline static PERIPHERAL_ERROR ADDON_GetFeatures(const AddonInstance_Peripheral* addonInstance, + inline static PERIPHERAL_ERROR ADDON_GetFeatures(KODI_ADDON_PERIPHERAL_HDL hdl, const JOYSTICK_INFO* joystick, const char* controller_id, - unsigned int* feature_count, - JOYSTICK_FEATURE** features) + JOYSTICK_FEATURE** features, + size_t* feature_count) { - if (!addonInstance || !joystick || !controller_id || !feature_count || !features) + if (!hdl || !joystick || !controller_id || !feature_count || !features) return PERIPHERAL_ERROR_INVALID_PARAMETERS; kodi::addon::Joystick addonJoystick(*joystick); std::vector featuresVector; - PERIPHERAL_ERROR err = static_cast(addonInstance->toAddon->addonInstance) - ->GetFeatures(addonJoystick, controller_id, featuresVector); + PERIPHERAL_ERROR err = static_cast(hdl)->GetFeatures( + addonJoystick, controller_id, featuresVector); if (err == PERIPHERAL_NO_ERROR) { *feature_count = static_cast(featuresVector.size()); @@ -756,23 +735,23 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance return err; } - inline static void ADDON_FreeFeatures(const AddonInstance_Peripheral* addonInstance, - unsigned int feature_count, - JOYSTICK_FEATURE* features) + inline static void ADDON_FreeFeatures(KODI_ADDON_PERIPHERAL_HDL hdl, + JOYSTICK_FEATURE* features, + size_t feature_count) { - if (!addonInstance) + if (!hdl) return; - kodi::addon::JoystickFeatures::FreeStructs(feature_count, features); + kodi::addon::JoystickFeatures::FreeStructs(features, feature_count); } - inline static PERIPHERAL_ERROR ADDON_MapFeatures(const AddonInstance_Peripheral* addonInstance, + inline static PERIPHERAL_ERROR ADDON_MapFeatures(KODI_ADDON_PERIPHERAL_HDL hdl, const JOYSTICK_INFO* joystick, const char* controller_id, - unsigned int feature_count, - const JOYSTICK_FEATURE* features) + const JOYSTICK_FEATURE* features, + size_t feature_count) { - if (!addonInstance || !joystick || !controller_id || (feature_count > 0 && !features)) + if (!hdl || !joystick || !controller_id || (feature_count > 0 && !features)) return PERIPHERAL_ERROR_INVALID_PARAMETERS; kodi::addon::Joystick addonJoystick(*joystick); @@ -781,24 +760,23 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance for (unsigned int i = 0; i < feature_count; i++) primitiveVector.emplace_back(*(features + i)); - return static_cast(addonInstance->toAddon->addonInstance) - ->MapFeatures(addonJoystick, controller_id, primitiveVector); + return static_cast(hdl)->MapFeatures(addonJoystick, controller_id, + primitiveVector); } - inline static PERIPHERAL_ERROR ADDON_GetIgnoredPrimitives( - const AddonInstance_Peripheral* addonInstance, - const JOYSTICK_INFO* joystick, - unsigned int* primitive_count, - JOYSTICK_DRIVER_PRIMITIVE** primitives) + inline static PERIPHERAL_ERROR ADDON_GetIgnoredPrimitives(KODI_ADDON_PERIPHERAL_HDL hdl, + const JOYSTICK_INFO* joystick, + JOYSTICK_DRIVER_PRIMITIVE** primitives, + size_t* primitive_count) { - if (!addonInstance || !joystick || !primitive_count || !primitives) + if (!hdl || !joystick || !primitive_count || !primitives) return PERIPHERAL_ERROR_INVALID_PARAMETERS; kodi::addon::Joystick addonJoystick(*joystick); std::vector primitiveVector; - PERIPHERAL_ERROR err = static_cast(addonInstance->toAddon->addonInstance) - ->GetIgnoredPrimitives(addonJoystick, primitiveVector); + PERIPHERAL_ERROR err = static_cast(hdl)->GetIgnoredPrimitives( + addonJoystick, primitiveVector); if (err == PERIPHERAL_NO_ERROR) { *primitive_count = static_cast(primitiveVector.size()); @@ -808,23 +786,23 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance return err; } - inline static void ADDON_FreePrimitives(const AddonInstance_Peripheral* addonInstance, - unsigned int primitive_count, - JOYSTICK_DRIVER_PRIMITIVE* primitives) + inline static void ADDON_FreePrimitives(KODI_ADDON_PERIPHERAL_HDL hdl, + JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count) { - if (!addonInstance) + if (!hdl) return; - kodi::addon::DriverPrimitives::FreeStructs(primitive_count, primitives); + kodi::addon::DriverPrimitives::FreeStructs(primitives, primitive_count); } inline static PERIPHERAL_ERROR ADDON_SetIgnoredPrimitives( - const AddonInstance_Peripheral* addonInstance, + KODI_ADDON_PERIPHERAL_HDL hdl, const JOYSTICK_INFO* joystick, - unsigned int primitive_count, - const JOYSTICK_DRIVER_PRIMITIVE* primitives) + const JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count) { - if (!addonInstance || !joystick || (primitive_count > 0 && !primitives)) + if (!hdl || !joystick || (primitive_count > 0 && !primitives)) return PERIPHERAL_ERROR_INVALID_PARAMETERS; kodi::addon::Joystick addonJoystick(*joystick); @@ -833,55 +811,50 @@ class ATTR_DLL_LOCAL CInstancePeripheral : public IAddonInstance for (unsigned int i = 0; i < primitive_count; i++) primitiveVector.emplace_back(*(primitives + i)); - return static_cast(addonInstance->toAddon->addonInstance) - ->SetIgnoredPrimitives(addonJoystick, primitiveVector); + return static_cast(hdl)->SetIgnoredPrimitives(addonJoystick, + primitiveVector); } - inline static void ADDON_SaveButtonMap(const AddonInstance_Peripheral* addonInstance, + inline static void ADDON_SaveButtonMap(KODI_ADDON_PERIPHERAL_HDL hdl, const JOYSTICK_INFO* joystick) { - if (!addonInstance || !joystick) + if (!hdl || !joystick) return; kodi::addon::Joystick addonJoystick(*joystick); - static_cast(addonInstance->toAddon->addonInstance) - ->SaveButtonMap(addonJoystick); + static_cast(hdl)->SaveButtonMap(addonJoystick); } - inline static void ADDON_RevertButtonMap(const AddonInstance_Peripheral* addonInstance, + inline static void ADDON_RevertButtonMap(KODI_ADDON_PERIPHERAL_HDL hdl, const JOYSTICK_INFO* joystick) { - if (!addonInstance || !joystick) + if (!hdl || !joystick) return; kodi::addon::Joystick addonJoystick(*joystick); - static_cast(addonInstance->toAddon->addonInstance) - ->RevertButtonMap(addonJoystick); + static_cast(hdl)->RevertButtonMap(addonJoystick); } - inline static void ADDON_ResetButtonMap(const AddonInstance_Peripheral* addonInstance, + inline static void ADDON_ResetButtonMap(KODI_ADDON_PERIPHERAL_HDL hdl, const JOYSTICK_INFO* joystick, const char* controller_id) { - if (!addonInstance || !joystick || !controller_id) + if (!hdl || !joystick || !controller_id) return; kodi::addon::Joystick addonJoystick(*joystick); - static_cast(addonInstance->toAddon->addonInstance) - ->ResetButtonMap(addonJoystick, controller_id); + static_cast(hdl)->ResetButtonMap(addonJoystick, controller_id); } - inline static void ADDON_PowerOffJoystick(const AddonInstance_Peripheral* addonInstance, - unsigned int index) + inline static void ADDON_PowerOffJoystick(KODI_ADDON_PERIPHERAL_HDL hdl, unsigned int index) { - if (!addonInstance) + if (!hdl) return; - static_cast(addonInstance->toAddon->addonInstance) - ->PowerOffJoystick(index); + static_cast(hdl)->PowerOffJoystick(index); } - AddonInstance_Peripheral* m_instanceData; + KODI_ADDON_INSTANCE_BACKEND_HDL m_kodi; }; } /* namespace addon */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Screensaver.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Screensaver.h index 1fd36fb40ebb5..b7bf049f75ce5 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Screensaver.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Screensaver.h @@ -13,6 +13,7 @@ #include "../gui/renderHelper.h" #ifdef __cplusplus + namespace kodi { namespace addon @@ -194,14 +195,8 @@ class ATTR_DLL_LOCAL CInstanceScreensaver : public IAddonInstance /// Used by an add-on that only supports screensavers. /// CInstanceScreensaver() - : IAddonInstance(IInstanceInfo(CPrivateBase::m_interface->firstKodiInstance)) { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstanceScreensaver: Creation of more as one in single " - "instance way is not allowed!"); - - SetAddonStruct(CPrivateBase::m_interface->firstKodiInstance); - CPrivateBase::m_interface->globalSingleInstance = this; + kodi_addon_screensaver_get_properties(m_kodi, &m_props); } //---------------------------------------------------------------------------- @@ -248,11 +243,7 @@ class ATTR_DLL_LOCAL CInstanceScreensaver : public IAddonInstance /// explicit CInstanceScreensaver(const IInstanceInfo& instance) : IAddonInstance(instance) { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstanceScreensaver: Creation of multiple together " - "with single instance way is not allowed!"); - - SetAddonStruct(instance); + kodi_addon_screensaver_get_properties(m_kodi, &m_props); } //---------------------------------------------------------------------------- @@ -370,14 +361,12 @@ class ATTR_DLL_LOCAL CInstanceScreensaver : public IAddonInstance ///@} private: - void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) + void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) override { instance->hdl = this; - instance->screensaver->toAddon->start = ADDON_start; - instance->screensaver->toAddon->stop = ADDON_stop; - instance->screensaver->toAddon->render = ADDON_render; - - instance->screensaver->toKodi->get_properties(instance->info->kodi, &m_props); + instance->screensaver->start = ADDON_start; + instance->screensaver->stop = ADDON_stop; + instance->screensaver->render = ADDON_render; } inline static bool ADDON_start(const KODI_ADDON_SCREENSAVER_HDL hdl) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VFS.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VFS.h index 6affffe04609e..047fb56d432a3 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VFS.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VFS.h @@ -30,7 +30,7 @@ class CInstanceVFS; /// places. /// ///@{ -using VFSFileHandle = VFS_FILE_HANDLE; +using VFSFileHandle = KODI_VFS_FILE_HDL; ///@} //------------------------------------------------------------------------------ @@ -47,7 +47,7 @@ using VFSFileHandle = VFS_FILE_HANDLE; /// @copydetails cpp_kodi_addon_vfs_Defs_VFSUrl_Help /// ///@{ -class ATTR_DLL_LOCAL VFSUrl : public CStructHdl +class ATTR_DLL_LOCAL VFSUrl : public CStructHdl { /*! \cond PRIVATE */ friend class CInstanceVFS; @@ -144,8 +144,8 @@ class ATTR_DLL_LOCAL VFSUrl : public CStructHdl private: VFSUrl() = delete; VFSUrl(const VFSUrl& channel) = delete; - VFSUrl(const VFSURL* channel) : CStructHdl(channel) {} - VFSUrl(VFSURL* channel) : CStructHdl(channel) {} + VFSUrl(const KODI_ADDON_VFS_URL* channel) : CStructHdl(channel) {} + VFSUrl(KODI_ADDON_VFS_URL* channel) : CStructHdl(channel) {} }; ///@} //------------------------------------------------------------------------------ @@ -442,14 +442,7 @@ class ATTR_DLL_LOCAL CInstanceVFS : public IAddonInstance /// /// @warning Only use `instance` from the @ref CAddonBase::CreateInstance call. /// - explicit CInstanceVFS(const IInstanceInfo& instance) : IAddonInstance(instance) - { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstanceVFS: Creation of multiple together with single " - "instance way is not allowed!"); - - SetAddonStruct(instance); - } + explicit CInstanceVFS(const kodi::addon::IInstanceInfo& instance) : IAddonInstance(instance) {} //---------------------------------------------------------------------------- //============================================================================ @@ -804,12 +797,12 @@ class ATTR_DLL_LOCAL CInstanceVFS : public IAddonInstance bool GetKeyboardInput(const std::string& heading, std::string& input, bool hiddenInput = false) { char* cInput = nullptr; - bool ret = m_cb->get_keyboard_input(m_cb->ctx, heading.c_str(), &cInput, hiddenInput); + bool ret = kodi_addon_vfs_get_dir_cb__get_keyboard_input( + m_instance, m_ctx_cb_hdl, heading.c_str(), &cInput, hiddenInput); if (cInput) { input = cInput; - ::kodi::addon::CPrivateBase::m_interface->toKodi->free_string( - ::kodi::addon::CPrivateBase::m_interface->toKodi->kodiBase, cInput); + free(cInput); } return ret; } @@ -827,8 +820,8 @@ class ATTR_DLL_LOCAL CInstanceVFS : public IAddonInstance const std::string& line2 = "", const std::string& line3 = "") { - m_cb->set_error_dialog(m_cb->ctx, heading.c_str(), line1.c_str(), line2.c_str(), - line3.c_str()); + kodi_addon_vfs_get_dir_cb__set_error_dialog(m_instance, m_ctx_cb_hdl, heading.c_str(), + line1.c_str(), line2.c_str(), line3.c_str()); } /// @ingroup cpp_kodi_addon_vfs_general_cb_GetDirectory @@ -837,13 +830,18 @@ class ATTR_DLL_LOCAL CInstanceVFS : public IAddonInstance /// @param[in] url The URL void RequireAuthentication(const std::string& url) { - m_cb->require_authentication(m_cb->ctx, url.c_str()); + kodi_addon_vfs_get_dir_cb__require_authentication(m_instance, m_ctx_cb_hdl, url.c_str()); } - explicit CVFSCallbacks(const VFSGetDirectoryCallbacks* cb) : m_cb(cb) {} + explicit CVFSCallbacks(const KODI_ADDON_INSTANCE_BACKEND_HDL instance, + const KODI_CTX_CB_HDL ctx_cb_hdl) + : m_instance(instance), m_ctx_cb_hdl(ctx_cb_hdl) + { + } private: - const VFSGetDirectoryCallbacks* m_cb; + const KODI_ADDON_INSTANCE_BACKEND_HDL m_instance; + const KODI_CTX_CB_HDL m_ctx_cb_hdl; }; //---------------------------------------------------------------------------- @@ -900,208 +898,197 @@ class ATTR_DLL_LOCAL CInstanceVFS : public IAddonInstance //@} private: - void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) + void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) override { - m_instanceData = instance; - m_instanceData->hdl = this; - m_instanceData->vfs->toAddon->addonInstance = this; - m_instanceData->vfs->toAddon->open = ADDON_Open; - m_instanceData->vfs->toAddon->open_for_write = ADDON_OpenForWrite; - m_instanceData->vfs->toAddon->read = ADDON_Read; - m_instanceData->vfs->toAddon->write = ADDON_Write; - m_instanceData->vfs->toAddon->seek = ADDON_Seek; - m_instanceData->vfs->toAddon->truncate = ADDON_Truncate; - m_instanceData->vfs->toAddon->get_length = ADDON_GetLength; - m_instanceData->vfs->toAddon->get_position = ADDON_GetPosition; - m_instanceData->vfs->toAddon->get_chunk_size = ADDON_GetChunkSize; - m_instanceData->vfs->toAddon->io_control_get_seek_possible = ADDON_IoControlGetSeekPossible; - m_instanceData->vfs->toAddon->io_control_get_cache_status = ADDON_IoControlGetCacheStatus; - m_instanceData->vfs->toAddon->io_control_set_cache_rate = ADDON_IoControlSetCacheRate; - m_instanceData->vfs->toAddon->io_control_set_retry = ADDON_IoControlSetRetry; - m_instanceData->vfs->toAddon->stat = ADDON_Stat; - m_instanceData->vfs->toAddon->close = ADDON_Close; - m_instanceData->vfs->toAddon->exists = ADDON_Exists; - m_instanceData->vfs->toAddon->clear_out_idle = ADDON_ClearOutIdle; - m_instanceData->vfs->toAddon->disconnect_all = ADDON_DisconnectAll; - m_instanceData->vfs->toAddon->delete_it = ADDON_Delete; - m_instanceData->vfs->toAddon->rename = ADDON_Rename; - m_instanceData->vfs->toAddon->directory_exists = ADDON_DirectoryExists; - m_instanceData->vfs->toAddon->remove_directory = ADDON_RemoveDirectory; - m_instanceData->vfs->toAddon->create_directory = ADDON_CreateDirectory; - m_instanceData->vfs->toAddon->get_directory = ADDON_GetDirectory; - m_instanceData->vfs->toAddon->free_directory = ADDON_FreeDirectory; - m_instanceData->vfs->toAddon->contains_files = ADDON_ContainsFiles; + instance->hdl = this; + instance->vfs->file_open = ADDON_file_open; + instance->vfs->file_open_for_write = ADDON_file_open_for_write; + instance->vfs->file_read = ADDON_file_read; + instance->vfs->file_write = ADDON_file_write; + instance->vfs->file_seek = ADDON_file_seek; + instance->vfs->file_truncate = ADDON_file_truncate; + instance->vfs->file_get_length = ADDON_file_get_length; + instance->vfs->file_get_position = ADDON_file_get_position; + instance->vfs->file_get_chunk_size = ADDON_file_get_chunk_size; + instance->vfs->file_io_control_get_seek_possible = ADDON_file_io_control_get_seek_possible; + instance->vfs->file_io_control_get_cache_status = ADDON_file_io_control_get_cache_status; + instance->vfs->file_io_control_set_cache_rate = ADDON_file_io_control_set_cache_rate; + instance->vfs->file_io_control_set_retry = ADDON_file_io_control_set_retry; + instance->vfs->stat = ADDON_stat; + instance->vfs->file_close = ADDON_file_close; + instance->vfs->exists = ADDON_exists; + instance->vfs->clear_out_idle = ADDON_clear_out_idle; + instance->vfs->disconnect_all = ADDON_disconnect_all; + instance->vfs->delete_it = ADDON_delete; + instance->vfs->rename = ADDON_rename; + instance->vfs->directory_exists = ADDON_directory_exists; + instance->vfs->directory_remove = ADDON_directory_remove; + instance->vfs->directory_create = ADDON_directory_create; + instance->vfs->directory_get = ADDON_directory_get; + instance->vfs->directory_contains_files = ADDON_directory_contains_files; } - inline static VFS_FILE_HANDLE ADDON_Open(const AddonInstance_VFSEntry* instance, - const VFSURL* url) + inline static KODI_VFS_FILE_HDL ADDON_file_open(const KODI_ADDON_VFS_HDL hdl, + const KODI_ADDON_VFS_URL* url) { - return static_cast(instance->toAddon->addonInstance)->Open(url); + return static_cast(hdl)->Open(url); } - inline static VFS_FILE_HANDLE ADDON_OpenForWrite(const AddonInstance_VFSEntry* instance, - const VFSURL* url, - bool overWrite) + inline static KODI_VFS_FILE_HDL ADDON_file_open_for_write(const KODI_ADDON_VFS_HDL hdl, + const KODI_ADDON_VFS_URL* url, + bool overWrite) { - return static_cast(instance->toAddon->addonInstance) - ->OpenForWrite(url, overWrite); + return static_cast(hdl)->OpenForWrite(url, overWrite); } - inline static ssize_t ADDON_Read(const AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - uint8_t* buffer, - size_t uiBufSize) + inline static ssize_t ADDON_file_read(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + uint8_t* buffer, + size_t uiBufSize) { - return static_cast(instance->toAddon->addonInstance) - ->Read(context, buffer, uiBufSize); + return static_cast(hdl)->Read(context, buffer, uiBufSize); } - inline static ssize_t ADDON_Write(const AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - const uint8_t* buffer, - size_t uiBufSize) + inline static ssize_t ADDON_file_write(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + const uint8_t* buffer, + size_t uiBufSize) { - return static_cast(instance->toAddon->addonInstance) - ->Write(context, buffer, uiBufSize); + return static_cast(hdl)->Write(context, buffer, uiBufSize); } - inline static int64_t ADDON_Seek(const AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - int64_t position, - int whence) + inline static int64_t ADDON_file_seek(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t position, + int whence) { - return static_cast(instance->toAddon->addonInstance) - ->Seek(context, position, whence); + return static_cast(hdl)->Seek(context, position, whence); } - inline static int ADDON_Truncate(const AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - int64_t size) + inline static int ADDON_file_truncate(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t size) { - return static_cast(instance->toAddon->addonInstance)->Truncate(context, size); + return static_cast(hdl)->Truncate(context, size); } - inline static int64_t ADDON_GetLength(const AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context) + inline static int64_t ADDON_file_get_length(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context) { - return static_cast(instance->toAddon->addonInstance)->GetLength(context); + return static_cast(hdl)->GetLength(context); } - inline static int64_t ADDON_GetPosition(const AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context) + inline static int64_t ADDON_file_get_position(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context) { - return static_cast(instance->toAddon->addonInstance)->GetPosition(context); + return static_cast(hdl)->GetPosition(context); } - inline static int ADDON_GetChunkSize(const AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context) + inline static int ADDON_file_get_chunk_size(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context) { - return static_cast(instance->toAddon->addonInstance)->GetChunkSize(context); + return static_cast(hdl)->GetChunkSize(context); } - inline static bool ADDON_IoControlGetSeekPossible(const AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context) + inline static bool ADDON_file_io_control_get_seek_possible(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context) { - return static_cast(instance->toAddon->addonInstance) - ->IoControlGetSeekPossible(context); + return static_cast(hdl)->IoControlGetSeekPossible(context); } - inline static bool ADDON_IoControlGetCacheStatus(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - VFS_CACHE_STATUS_DATA* status) + inline static bool ADDON_file_io_control_get_cache_status(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + VFS_CACHE_STATUS* status) { kodi::vfs::CacheStatus cppStatus(status); - return static_cast(instance->toAddon->addonInstance) - ->IoControlGetCacheStatus(context, cppStatus); + return static_cast(hdl)->IoControlGetCacheStatus(context, cppStatus); } - inline static bool ADDON_IoControlSetCacheRate(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - uint32_t rate) + inline static bool ADDON_file_io_control_set_cache_rate(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + uint32_t rate) { - return static_cast(instance->toAddon->addonInstance) - ->IoControlSetCacheRate(context, rate); + return static_cast(hdl)->IoControlSetCacheRate(context, rate); } - inline static bool ADDON_IoControlSetRetry(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - bool retry) + inline static bool ADDON_file_io_control_set_retry(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + bool retry) { - return static_cast(instance->toAddon->addonInstance) - ->IoControlSetRetry(context, retry); + return static_cast(hdl)->IoControlSetRetry(context, retry); } - inline static int ADDON_Stat(const AddonInstance_VFSEntry* instance, - const VFSURL* url, - struct STAT_STRUCTURE* buffer) + inline static int ADDON_stat(const KODI_ADDON_VFS_HDL hdl, + const KODI_ADDON_VFS_URL* url, + struct VFS_STAT_STRUCTURE* buffer) { kodi::vfs::FileStatus cppBuffer(buffer); - return static_cast(instance->toAddon->addonInstance)->Stat(url, cppBuffer); + return static_cast(hdl)->Stat(url, cppBuffer); } - inline static bool ADDON_Close(const AddonInstance_VFSEntry* instance, VFS_FILE_HANDLE context) + inline static bool ADDON_file_close(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context) { - return static_cast(instance->toAddon->addonInstance)->Close(context); + return static_cast(hdl)->Close(context); } - inline static bool ADDON_Exists(const AddonInstance_VFSEntry* instance, const VFSURL* url) + inline static bool ADDON_exists(const KODI_ADDON_VFS_HDL hdl, const KODI_ADDON_VFS_URL* url) { - return static_cast(instance->toAddon->addonInstance)->Exists(url); + return static_cast(hdl)->Exists(url); } - inline static void ADDON_ClearOutIdle(const AddonInstance_VFSEntry* instance) + inline static void ADDON_clear_out_idle(const KODI_ADDON_VFS_HDL hdl) { - return static_cast(instance->toAddon->addonInstance)->ClearOutIdle(); + return static_cast(hdl)->ClearOutIdle(); } - inline static void ADDON_DisconnectAll(const AddonInstance_VFSEntry* instance) + inline static void ADDON_disconnect_all(const KODI_ADDON_VFS_HDL hdl) { - return static_cast(instance->toAddon->addonInstance)->DisconnectAll(); + return static_cast(hdl)->DisconnectAll(); } - inline static bool ADDON_Delete(const AddonInstance_VFSEntry* instance, const VFSURL* url) + inline static bool ADDON_delete(const KODI_ADDON_VFS_HDL hdl, const KODI_ADDON_VFS_URL* url) { - return static_cast(instance->toAddon->addonInstance)->Delete(url); + return static_cast(hdl)->Delete(url); } - inline static bool ADDON_Rename(const AddonInstance_VFSEntry* instance, - const VFSURL* url, - const VFSURL* url2) + inline static bool ADDON_rename(const KODI_ADDON_VFS_HDL hdl, + const KODI_ADDON_VFS_URL* url, + const KODI_ADDON_VFS_URL* url2) { - return static_cast(instance->toAddon->addonInstance)->Rename(url, url2); + return static_cast(hdl)->Rename(url, url2); } - inline static bool ADDON_DirectoryExists(const AddonInstance_VFSEntry* instance, - const VFSURL* url) + inline static bool ADDON_directory_exists(const KODI_ADDON_VFS_HDL hdl, + const KODI_ADDON_VFS_URL* url) { - return static_cast(instance->toAddon->addonInstance)->DirectoryExists(url); + return static_cast(hdl)->DirectoryExists(url); } - inline static bool ADDON_RemoveDirectory(const AddonInstance_VFSEntry* instance, - const VFSURL* url) + inline static bool ADDON_directory_remove(const KODI_ADDON_VFS_HDL hdl, + const KODI_ADDON_VFS_URL* url) { - return static_cast(instance->toAddon->addonInstance)->RemoveDirectory(url); + return static_cast(hdl)->RemoveDirectory(url); } - inline static bool ADDON_CreateDirectory(const AddonInstance_VFSEntry* instance, - const VFSURL* url) + inline static bool ADDON_directory_create(const KODI_ADDON_VFS_HDL hdl, + const KODI_ADDON_VFS_URL* url) { - return static_cast(instance->toAddon->addonInstance)->CreateDirectory(url); + return static_cast(hdl)->CreateDirectory(url); } - inline static bool ADDON_GetDirectory(const AddonInstance_VFSEntry* instance, - const VFSURL* url, - VFSDirEntry** retEntries, - int* num_entries, - VFSGetDirectoryCallbacks* callbacks) + inline static bool ADDON_directory_get(const KODI_ADDON_VFS_HDL hdl, + const KODI_ADDON_VFS_URL* url, + VFS_DIR_ENTRY** retEntries, + size_t* num_entries, + KODI_CTX_CB_HDL ctx_cb_hdl) { std::vector addonEntries; - bool ret = static_cast(instance->toAddon->addonInstance) - ->GetDirectory(url, addonEntries, CVFSCallbacks(callbacks)); + bool ret = static_cast(hdl)->GetDirectory(url, addonEntries, + CVFSCallbacks(hdl, ctx_cb_hdl)); if (ret) { - VFSDirEntry* entries = - static_cast(malloc(sizeof(VFSDirEntry) * addonEntries.size())); + VFS_DIR_ENTRY* entries = + static_cast(malloc(sizeof(VFS_DIR_ENTRY) * addonEntries.size())); for (unsigned int i = 0; i < addonEntries.size(); ++i) { entries[i].label = strdup(addonEntries[i].Label().c_str()); @@ -1116,7 +1103,7 @@ class ATTR_DLL_LOCAL CInstanceVFS : public IAddonInstance if (!props.empty()) { entries[i].properties = - static_cast(malloc(sizeof(VFSProperty) * props.size())); + static_cast(malloc(sizeof(VFS_PROPERTY) * props.size())); for (const auto& prop : props) { entries[i].properties[entries[i].num_props].name = strdup(prop.first.c_str()); @@ -1133,44 +1120,19 @@ class ATTR_DLL_LOCAL CInstanceVFS : public IAddonInstance return ret; } - inline static void ADDON_FreeDirectory(const AddonInstance_VFSEntry* instance, - VFSDirEntry* entries, - int num_entries) - { - for (int i = 0; i < num_entries; ++i) - { - if (entries[i].properties) - { - for (unsigned int j = 0; j < entries[i].num_props; ++j) - { - free(entries[i].properties[j].name); - free(entries[i].properties[j].val); - } - free(entries[i].properties); - } - free(entries[i].label); - free(entries[i].title); - free(entries[i].path); - } - free(entries); - } - - inline static bool ADDON_ContainsFiles(const AddonInstance_VFSEntry* instance, - const VFSURL* url, - VFSDirEntry** retEntries, - int* num_entries, - char* rootpath) + inline static bool ADDON_directory_contains_files(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** retEntries, + size_t* num_entries, + char** rootpath) { std::string cppRootPath; std::vector addonEntries; - bool ret = static_cast(instance->toAddon->addonInstance) - ->ContainsFiles(url, addonEntries, cppRootPath); + bool ret = static_cast(hdl)->ContainsFiles(url, addonEntries, cppRootPath); if (ret) { - strncpy(rootpath, cppRootPath.c_str(), ADDON_STANDARD_STRING_LENGTH); - - VFSDirEntry* entries = - static_cast(malloc(sizeof(VFSDirEntry) * addonEntries.size())); + VFS_DIR_ENTRY* entries = + static_cast(malloc(sizeof(VFS_DIR_ENTRY) * addonEntries.size())); for (size_t i = 0; i < addonEntries.size(); ++i) { entries[i].label = strdup(addonEntries[i].Label().c_str()); @@ -1185,7 +1147,7 @@ class ATTR_DLL_LOCAL CInstanceVFS : public IAddonInstance if (!props.empty()) { entries[i].properties = - static_cast(malloc(sizeof(VFSProperty) * props.size())); + static_cast(malloc(sizeof(VFS_PROPERTY) * props.size())); for (const auto& prop : props) { entries[i].properties[entries[i].num_props].name = strdup(prop.first.c_str()); @@ -1196,13 +1158,13 @@ class ATTR_DLL_LOCAL CInstanceVFS : public IAddonInstance else entries[i].properties = nullptr; } + + *rootpath = strdup(cppRootPath.c_str()); *retEntries = entries; - *num_entries = static_cast(addonEntries.size()); + *num_entries = addonEntries.size(); } return ret; } - - KODI_ADDON_INSTANCE_STRUCT* m_instanceData{nullptr}; }; } /* namespace addon */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VideoCodec.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VideoCodec.h index 06f0fc85a61ca..1b28df5147683 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VideoCodec.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VideoCodec.h @@ -259,11 +259,6 @@ class ATTR_DLL_LOCAL CInstanceVideoCodec : public IAddonInstance /// explicit CInstanceVideoCodec(const IInstanceInfo& instance) : IAddonInstance(instance) { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstanceVideoCodec: Creation of multiple together with " - "single instance way is not allowed!"); - - SetAddonStruct(instance); } //---------------------------------------------------------------------------- diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Visualization.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Visualization.h index b058344c32e7a..9432385a25910 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Visualization.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Visualization.h @@ -13,11 +13,13 @@ #include "../gui/renderHelper.h" #ifdef __cplusplus + namespace kodi { namespace addon { +#include //============================================================================== /// @defgroup cpp_kodi_addon_visualization_Defs_VisualizationTrack class VisualizationTrack @@ -170,7 +172,7 @@ class VisualizationTrack ///@} private: - VisualizationTrack(const VIS_TRACK* tag) + VisualizationTrack(const KODI_ADDON_VISUALIZATION_TRACK* tag) { if (!tag) return; @@ -396,16 +398,7 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance /// /// Used by an add-on that only supports visualizations. /// - CInstanceVisualization() - : IAddonInstance(IInstanceInfo(CPrivateBase::m_interface->firstKodiInstance)) - { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error( - "kodi::addon::CInstanceVisualization: Cannot create multiple instances of add-on."); - - SetAddonStruct(CPrivateBase::m_interface->firstKodiInstance); - CPrivateBase::m_interface->globalSingleInstance = this; - } + CInstanceVisualization() = default; //---------------------------------------------------------------------------- //========================================================================== @@ -448,11 +441,7 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance /// explicit CInstanceVisualization(const IInstanceInfo& instance) : IAddonInstance(instance) { - if (CPrivateBase::m_interface->globalSingleInstance != nullptr) - throw std::logic_error("kodi::addon::CInstanceVisualization: Creation of multiple together " - "with single instance way is not allowed!"); - - SetAddonStruct(instance); + kodi_addon_visualization_get_properties(m_kodi, &m_props); } //---------------------------------------------------------------------------- @@ -493,18 +482,13 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance /// /// @param[in] audioData The raw audio data /// @param[in] audioDataLength Length of the audioData array - /// @param[in] freqData The [FFT](https://en.wikipedia.org/wiki/Fast_Fourier_transform) - /// of the audio data - /// @param[in] freqDataLength Length of frequency data array /// /// Values **freqData** and **freqDataLength** are used if GetInfo() returns /// true for the `wantsFreq` parameter. Otherwise, **freqData** is set to /// `nullptr` and **freqDataLength** is `0`. /// virtual void AudioData(const float* audioData, - int audioDataLength, - float* freqData, - int freqDataLength) + int audioDataLength) { } //---------------------------------------------------------------------------- @@ -529,21 +513,13 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance //============================================================================ /// @ingroup cpp_kodi_addon_visualization /// @brief Used to get the number of buffers from the current visualization. + + /// @return syncDelay The number of buffers to delay before calling + /// @ref AudioData() /// - /// @param[out] wantsFreq Indicates whether the add-on wants FFT data. If set - /// to true, the **freqData** and **freqDataLength** - /// parameters of @ref AudioData() are used - /// @param[out] syncDelay The number of buffers to delay before calling - /// @ref AudioData() - /// - /// @note If this function is not implemented, it will default to - /// `wantsFreq` = false and `syncDelay` = 0. + /// @note If this function is not implemented, it will default to 0. /// - virtual void GetInfo(bool& wantsFreq, int& syncDelay) - { - wantsFreq = false; - syncDelay = 0; - } + virtual int GetSyncDelay() { return 0; } //---------------------------------------------------------------------------- //============================================================================ @@ -708,11 +684,9 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance /// inline void TransferPresets(const std::vector& presets) { - m_instanceData->visualization->toKodi->clear_presets( - m_instanceData->visualization->toKodi->kodiInstance); + kodi_addon_visualization_clear_presets(GetInfo().GetKodiHdl()); for (const auto& it : presets) - m_instanceData->visualization->toKodi->transfer_preset( - m_instanceData->visualization->toKodi->kodiInstance, it.c_str()); + kodi_addon_visualization_transfer_preset(GetInfo().GetKodiHdl(), it.c_str()); } //---------------------------------------------------------------------------- @@ -737,7 +711,7 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance /// .. /// ~~~~~~~~~~~~~ /// - inline kodi::HardwareContext Device() { return m_instanceData->visualization->props->device; } + inline kodi::HardwareContext Device() { return m_props.props->device; } //---------------------------------------------------------------------------- //============================================================================ @@ -746,7 +720,7 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance /// /// @return The X position, in pixels /// - inline int X() { return m_instanceData->visualization->props->x; } + inline int X() { return m_props.props->x; } //---------------------------------------------------------------------------- //============================================================================ @@ -755,7 +729,7 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance /// /// @return The Y position, in pixels /// - inline int Y() { return m_instanceData->visualization->props->y; } + inline int Y() { return m_props.props->y; } //---------------------------------------------------------------------------- //============================================================================ @@ -764,7 +738,7 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance /// /// @return The width, in pixels /// - inline int Width() { return m_instanceData->visualization->props->width; } + inline int Width() { return m_props.props->width; } //---------------------------------------------------------------------------- //============================================================================ @@ -773,7 +747,7 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance /// /// @return The height, in pixels /// - inline int Height() { return m_instanceData->visualization->props->height; } + inline int Height() { return m_props.props->height; } //---------------------------------------------------------------------------- //============================================================================ @@ -783,106 +757,67 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance /// /// @return The pixel aspect ratio used by the display /// - inline float PixelRatio() { return m_instanceData->visualization->props->pixelRatio; } - //---------------------------------------------------------------------------- - - //============================================================================ - /// @ingroup cpp_kodi_addon_visualization_CB - /// @brief Used to get the name of the add-on defined in `addon.xml`. - /// - /// @return The add-on name - /// - inline std::string Name() { return m_instanceData->visualization->props->name; } - //---------------------------------------------------------------------------- - - //============================================================================ - /// @ingroup cpp_kodi_addon_visualization_CB - /// @brief Used to get the full path where the add-on is installed. - /// - /// @return The add-on installation path - /// - inline std::string Presets() { return m_instanceData->visualization->props->presets; } - //---------------------------------------------------------------------------- - - //============================================================================ - /// @ingroup cpp_kodi_addon_visualization_CB - /// @brief Used to get the full path to the add-on's user profile. - /// - /// @note The trailing folder (consisting of the add-on's ID) is not created - /// by default. If it is needed, you must call kodi::vfs::CreateDirectory() - /// to create the folder. - /// - /// @return Path to the user profile - /// - inline std::string Profile() { return m_instanceData->visualization->props->profile; } + inline float PixelRatio() { return m_props.props->pixelRatio; } //---------------------------------------------------------------------------- ///@} private: - void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) + void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) override { - m_instanceData = instance; - m_instanceData->hdl = this; - m_instanceData->visualization->toAddon->addonInstance = this; - m_instanceData->visualization->toAddon->start = ADDON_Start; - m_instanceData->visualization->toAddon->stop = ADDON_Stop; - m_instanceData->visualization->toAddon->audio_data = ADDON_AudioData; - m_instanceData->visualization->toAddon->is_dirty = ADDON_IsDirty; - m_instanceData->visualization->toAddon->render = ADDON_Render; - m_instanceData->visualization->toAddon->get_info = ADDON_GetInfo; - m_instanceData->visualization->toAddon->prev_preset = ADDON_PrevPreset; - m_instanceData->visualization->toAddon->next_preset = ADDON_NextPreset; - m_instanceData->visualization->toAddon->load_preset = ADDON_LoadPreset; - m_instanceData->visualization->toAddon->random_preset = ADDON_RandomPreset; - m_instanceData->visualization->toAddon->lock_preset = ADDON_LockPreset; - m_instanceData->visualization->toAddon->rate_preset = ADDON_RatePreset; - m_instanceData->visualization->toAddon->update_albumart = ADDON_UpdateAlbumart; - m_instanceData->visualization->toAddon->update_track = ADDON_UpdateTrack; - m_instanceData->visualization->toAddon->get_presets = ADDON_GetPresets; - m_instanceData->visualization->toAddon->get_active_preset = ADDON_GetActivePreset; - m_instanceData->visualization->toAddon->is_locked = ADDON_IsLocked; + instance->hdl = this; + instance->visualization->start = ADDON_start; + instance->visualization->stop = ADDON_stop; + instance->visualization->audio_data = ADDON_audio_data; + instance->visualization->is_dirty = ADDON_is_dirty; + instance->visualization->render = ADDON_render; + instance->visualization->get_sync_delay = ADDON_get_sync_delay; + instance->visualization->prev_preset = ADDON_prev_preset; + instance->visualization->next_preset = ADDON_next_preset; + instance->visualization->load_preset = ADDON_load_preset; + instance->visualization->random_preset = ADDON_random_preset; + instance->visualization->lock_preset = ADDON_lock_preset; + instance->visualization->rate_preset = ADDON_rate_preset; + instance->visualization->update_albumart = ADDON_update_albumart; + instance->visualization->update_track = ADDON_update_track; + instance->visualization->get_presets = ADDON_get_presets; + instance->visualization->get_active_preset = ADDON_get_active_preset; + instance->visualization->is_locked = ADDON_is_locked; } - inline static bool ADDON_Start(const AddonInstance_Visualization* addon, + inline static bool ADDON_start(const KODI_ADDON_VISUALIZATION_HDL hdl, int channels, int samplesPerSec, int bitsPerSample, const char* songName) { - CInstanceVisualization* thisClass = - static_cast(addon->toAddon->addonInstance); + CInstanceVisualization* thisClass = static_cast(hdl); thisClass->m_renderHelper = kodi::gui::GetRenderHelper(); return thisClass->Start(channels, samplesPerSec, bitsPerSample, songName); } - inline static void ADDON_Stop(const AddonInstance_Visualization* addon) + inline static void ADDON_stop(const KODI_ADDON_VISUALIZATION_HDL hdl) { - CInstanceVisualization* thisClass = - static_cast(addon->toAddon->addonInstance); + CInstanceVisualization* thisClass = static_cast(hdl); thisClass->Stop(); thisClass->m_renderHelper = nullptr; } - inline static void ADDON_AudioData(const AddonInstance_Visualization* addon, + inline static void ADDON_audio_data(const KODI_ADDON_VISUALIZATION_HDL hdl, const float* audioData, - int audioDataLength, - float* freqData, - int freqDataLength) + int audioDataLength) { - static_cast(addon->toAddon->addonInstance) - ->AudioData(audioData, audioDataLength, freqData, freqDataLength); + static_cast(hdl)->AudioData(audioData, audioDataLength); } - inline static bool ADDON_IsDirty(const AddonInstance_Visualization* addon) + inline static bool ADDON_is_dirty(const KODI_ADDON_VISUALIZATION_HDL hdl) { - return static_cast(addon->toAddon->addonInstance)->IsDirty(); + return static_cast(hdl)->IsDirty(); } - inline static void ADDON_Render(const AddonInstance_Visualization* addon) + inline static void ADDON_render(const KODI_ADDON_VISUALIZATION_HDL hdl) { - CInstanceVisualization* thisClass = - static_cast(addon->toAddon->addonInstance); + CInstanceVisualization* thisClass = static_cast(hdl); if (!thisClass->m_renderHelper) return; thisClass->m_renderHelper->Begin(); @@ -890,90 +825,82 @@ class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance thisClass->m_renderHelper->End(); } - inline static void ADDON_GetInfo(const AddonInstance_Visualization* addon, VIS_INFO* info) + inline static int ADDON_get_sync_delay(const KODI_ADDON_VISUALIZATION_HDL hdl) { - static_cast(addon->toAddon->addonInstance) - ->GetInfo(info->bWantsFreq, info->iSyncDelay); + return static_cast(hdl)>GetSyncDelay(); } - inline static unsigned int ADDON_GetPresets(const AddonInstance_Visualization* addon) + inline static unsigned int ADDON_get_presets(const KODI_ADDON_VISUALIZATION_HDL hdl) { - CInstanceVisualization* thisClass = - static_cast(addon->toAddon->addonInstance); + CInstanceVisualization* thisClass = static_cast(hdl); std::vector presets; if (thisClass->GetPresets(presets)) { for (const auto& it : presets) - thisClass->m_instanceData->visualization->toKodi->transfer_preset( - addon->toKodi->kodiInstance, it.c_str()); + kodi_addon_visualization_transfer_preset(GetInfo().GetKodiHdl(), it.c_str()); } return static_cast(presets.size()); } - inline static int ADDON_GetActivePreset(const AddonInstance_Visualization* addon) + inline static int ADDON_get_active_preset(const KODI_ADDON_VISUALIZATION_HDL hdl) { - return static_cast(addon->toAddon->addonInstance)->GetActivePreset(); + return static_cast(hdl)->GetActivePreset(); } - inline static bool ADDON_PrevPreset(const AddonInstance_Visualization* addon) + inline static bool ADDON_prev_preset(const KODI_ADDON_VISUALIZATION_HDL hdl) { - return static_cast(addon->toAddon->addonInstance)->PrevPreset(); + return static_cast(hdl)->PrevPreset(); } - inline static bool ADDON_NextPreset(const AddonInstance_Visualization* addon) + inline static bool ADDON_next_preset(const KODI_ADDON_VISUALIZATION_HDL hdl) { - return static_cast(addon->toAddon->addonInstance)->NextPreset(); + return static_cast(hdl)->NextPreset(); } - inline static bool ADDON_LoadPreset(const AddonInstance_Visualization* addon, int select) - + inline static bool ADDON_load_preset(const KODI_ADDON_VISUALIZATION_HDL hdl, int select) { - return static_cast(addon->toAddon->addonInstance)->LoadPreset(select); + return static_cast(hdl)->LoadPreset(select); } - inline static bool ADDON_RandomPreset(const AddonInstance_Visualization* addon) + inline static bool ADDON_random_preset(const KODI_ADDON_VISUALIZATION_HDL hdl) { - return static_cast(addon->toAddon->addonInstance)->RandomPreset(); + return static_cast(hdl)->RandomPreset(); } - inline static bool ADDON_LockPreset(const AddonInstance_Visualization* addon) + inline static bool ADDON_lock_preset(const KODI_ADDON_VISUALIZATION_HDL hdl) { - CInstanceVisualization* thisClass = - static_cast(addon->toAddon->addonInstance); + CInstanceVisualization* thisClass = static_cast(hdl); thisClass->m_presetLockedByUser = !thisClass->m_presetLockedByUser; return thisClass->LockPreset(thisClass->m_presetLockedByUser); } - inline static bool ADDON_RatePreset(const AddonInstance_Visualization* addon, bool plus_minus) + inline static bool ADDON_rate_preset(const KODI_ADDON_VISUALIZATION_HDL hdl, bool plus_minus) { - return static_cast(addon->toAddon->addonInstance) - ->RatePreset(plus_minus); + return static_cast(hdl)->RatePreset(plus_minus); } - inline static bool ADDON_IsLocked(const AddonInstance_Visualization* addon) + inline static bool ADDON_is_locked(const KODI_ADDON_VISUALIZATION_HDL hdl) { - return static_cast(addon->toAddon->addonInstance)->IsLocked(); + return static_cast(hdl)->IsLocked(); } - inline static bool ADDON_UpdateAlbumart(const AddonInstance_Visualization* addon, + inline static bool ADDON_update_albumart(const KODI_ADDON_VISUALIZATION_HDL hdl, const char* albumart) { - return static_cast(addon->toAddon->addonInstance) - ->UpdateAlbumart(albumart); + return static_cast(hdl)->UpdateAlbumart(albumart); } - inline static bool ADDON_UpdateTrack(const AddonInstance_Visualization* addon, - const VIS_TRACK* track) + inline static bool ADDON_update_track(const KODI_ADDON_VISUALIZATION_HDL hdl, + const KODI_ADDON_VISUALIZATION_TRACK* track) { VisualizationTrack cppTrack(track); - return static_cast(addon->toAddon->addonInstance) - ->UpdateTrack(cppTrack); + return static_cast(hdl)->UpdateTrack(cppTrack); } std::shared_ptr m_renderHelper; - bool m_presetLockedByUser = false; - KODI_ADDON_INSTANCE_STRUCT* m_instanceData{nullptr}; + + KODI_ADDON_VISUALIZATION_PROPS m_props = {}; }; } /* namespace addon */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Web.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Web.h new file mode 100644 index 0000000000000..255c54ac7bdea --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Web.h @@ -0,0 +1,474 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "../AddonBase.h" +#include "../c-api/addon-instance/web.h" +#include "../gui/input/Action.h" + +#ifdef __cplusplus + +#include + +namespace kodi +{ +namespace addon +{ + +class CInstanceWeb; + +struct WEB_CONTROL_HANDLE +{ + KODI_ADDON_WEB_HDL kodi; + struct WEB_ADDON_GUI_PROPS props; + CInstanceWeb* addonWebBase; +}; + +class CWebControl; +class CInstanceWeb; + +using WebControlHdl = KODI_HANDLE; + +class ATTR_DLL_LOCAL WebKeyboardInputEvent + : public CStructHdl +{ + /*! \cond PRIVATE */ + friend class CWebControl; + friend class CInstanceWeb; + /*! \endcond */ + +public: + std::string GetControllerId() const { return m_cStructure->controller_id; } + std::string GetFeatureName() const { return m_cStructure->feature_name; } + bool GetPressed() const { return m_cStructure->pressed; } + uint32_t GetUnicode() const { return m_cStructure->unicode; } + WEB_KEY_MOD GetModifiers() const { return m_cStructure->modifiers; } + +private: + WebKeyboardInputEvent(const WEB_KEYBOARD_INPUT_EVENT* tag) : CStructHdl(tag) {} + WebKeyboardInputEvent(WEB_KEYBOARD_INPUT_EVENT* tag) : CStructHdl(tag) {} + WebKeyboardInputEvent() = delete; + WebKeyboardInputEvent(const WebKeyboardInputEvent& tag) = delete; +}; + +class ATTR_DLL_LOCAL CWebControl +{ +public: + CWebControl(kodi::addon::CInstanceWeb* instance, + const kodi::addon::WebControlHdl handle) + : m_instance(instance), m_handle(*static_cast(handle)) + { + } + + virtual ~CWebControl() = default; + + virtual bool RenderInit() { return false; } + virtual void RenderDeinit() {} + virtual void Render() {} + virtual bool Dirty() { return false; } + virtual bool OnInit() { return false; } + virtual bool OnAction(const gui::input::CAction& action, int& nextItem) { return false; } + virtual bool OnMouseEvent(int id, double x, double y, double offsetX, double offsetY, int state) + { + return false; + } + virtual bool OpenWebsite(const std::string& url) { return false; } + virtual bool GetHistory(std::vector& historyWebsiteNames, bool behindCurrent) + { + return false; + } + virtual void SearchText(const std::string& text, bool forward, bool matchCase, bool findNext) {} + virtual void StopSearch(bool clearSelection) {} + virtual void Reload() {} + virtual void StopLoad() {} + virtual void GoBack() {} + virtual void GoForward() {} + virtual void OpenOwnContextMenu() {} + virtual void ScreenSizeChange(float x, float y, float width, float height, bool fullscreen) {} + + inline void SetControlReady(bool ready) + { + kodi_addon_web_control_set_control_ready(m_handle.kodi, m_handle.props.pControlIdent, + ready); + } + + inline void SetOpenedAddress(const std::string& title) + { + kodi_addon_web_control_set_opened_address(m_handle.kodi, m_handle.props.pControlIdent, + title.c_str()); + } + + inline void SetOpenedTitle(const std::string& title) + { + kodi_addon_web_control_set_opened_title(m_handle.kodi, m_handle.props.pControlIdent, + title.c_str()); + } + + inline void SetIconURL(const std::string& icon) + { + kodi_addon_web_control_set_icon_url(m_handle.kodi, m_handle.props.pControlIdent, icon.c_str()); + } + + inline void SetFullscreen(bool fullscreen) + { + kodi_addon_web_control_set_fullscreen(m_handle.kodi, m_handle.props.pControlIdent, fullscreen); + } + + inline void SetLoadingState(bool isLoading, bool canGoBack, bool canGoForward) + { + kodi_addon_web_control_set_loading_state(m_handle.kodi, m_handle.props.pControlIdent, isLoading, + canGoBack, canGoForward); + } + + inline void SetTooltip(const std::string& tooltip) + { + kodi_addon_web_control_set_tooltip(m_handle.kodi, m_handle.props.pControlIdent, + tooltip.c_str()); + } + + inline void SetStatusMessage(const std::string& status) + { + kodi_addon_web_control_set_status_message(m_handle.kodi, m_handle.props.pControlIdent, + status.c_str()); + } + + inline void RequestOpenSiteInNewTab(const std::string& url) + { + kodi_addon_web_control_request_open_site_in_new_tab(m_handle.kodi, m_handle.props.pControlIdent, + url.c_str()); + } + + std::string GetName() const { return m_handle.props.strName; } + virtual void* GetDevice() const { return m_handle.props.pDevice; } + virtual float GetXPos() const { return m_handle.props.fXPos; } + virtual float GetYPos() const { return m_handle.props.fYPos; } + virtual float GetWidth() const { return m_handle.props.fWidth; } + virtual float GetHeight() const { return m_handle.props.fHeight; } + virtual float GetPixelRatio() const { return m_handle.props.fPixelRatio; } + virtual float GetFPS() const { return m_handle.props.fFPS; } + virtual float GetSkinXPos() const { return m_handle.props.fSkinXPos; } + virtual float GetSkinYPos() const { return m_handle.props.fSkinYPos; } + virtual float GetSkinWidth() const { return m_handle.props.fSkinWidth; } + virtual float GetSkinHeight() const { return m_handle.props.fSkinHeight; } + virtual bool UseTransparentBackground() const + { + return m_handle.props.bUseTransparentBackground; + } + virtual uint32_t GetBackgroundColorARGB() const { return m_handle.props.iBackgroundColorARGB; } + int GetGUIItemLeft() const { return m_handle.props.iGUIItemLeft; } + int GetGUIItemRight() const { return m_handle.props.iGUIItemRight; } + int GetGUIItemTop() const { return m_handle.props.iGUIItemTop; } + int GetGUIItemBottom() const { return m_handle.props.iGUIItemBottom; } + int GetGUIItemBack() const { return m_handle.props.iGUIItemBack; } + +private: + CInstanceWeb* m_instance{nullptr}; + + WEB_CONTROL_HANDLE m_handle; +}; + +class ATTR_DLL_LOCAL CInstanceWeb : public IAddonInstance +{ +public: + //========================================================================== + /// + /// @ingroup cpp_kodi_addon_web + /// @brief Web addon class constructor + /// + /// Used by an add-on that only supports web browser. + /// + CInstanceWeb() = default; + //-------------------------------------------------------------------------- + + CInstanceWeb(const kodi::addon::IInstanceInfo& instance) + : IAddonInstance(instance) + { + } + + virtual ~CInstanceWeb() = default; + + virtual bool MainInitialize() { return false; } + + virtual void MainLoop() {} + + virtual void MainShutdown() {} + + virtual WEB_ADDON_ERROR StartInstance() { return WEB_ADDON_ERROR_NO_ERROR; } + virtual void StopInstance() {} + + virtual void SetMute(bool mute) {} + virtual bool SetLanguage(const std::string& language) { return false; } + + inline void InhibitShutdown(bool inhibit) { kodi_addon_web_inhibit_shutdown(m_kodi, inhibit); } + + inline void InhibitScreensaver(bool inhibit) + { + kodi_addon_web_inhibit_screensaver(m_kodi, inhibit); + } + + virtual WEB_ADDON_ERROR CreateControl(const std::string& sourceName, + const std::string& startURL, + const kodi::addon::WebControlHdl controlHdl, + kodi::addon::CWebControl*& control) + { + return WEB_ADDON_ERROR_NOT_IMPLEMENTED; + } + + virtual enum WEB_ADDON_ERROR DestroyControl(kodi::addon::CWebControl* control, bool complete) { return WEB_ADDON_ERROR_NOT_IMPLEMENTED; } + + inline bool IsMuted() const { return kodi_addon_web_is_muted(m_kodi); } + +private: + void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance) override + { + instance->hdl = this; + instance->web->main_initialize = main_initialize; + instance->web->main_loop = main_loop; + instance->web->main_shutdown = main_shutdown; + instance->web->start_instance = start_instance; + instance->web->stop_instance = stop_instance; + instance->web->set_mute = set_mute; + instance->web->set_language = set_language; + instance->web->create_control = create_control; + instance->web->destroy_control = destroy_control; + instance->web->control_render_init = control_render_init; + instance->web->control_render_deinit = control_render_deinit; + instance->web->control_render = control_render; + instance->web->control_dirty = control_dirty; + instance->web->control_on_init = control_on_init; + instance->web->control_on_action = control_on_action; + instance->web->control_on_mouse_event = control_on_mouse_event; + instance->web->control_open_website = control_open_website; + instance->web->control_get_history = control_get_history; + instance->web->control_search_text = control_search_text; + instance->web->control_stop_search = control_stop_search; + instance->web->control_web_cmd_reload = control_web_cmd_reload; + instance->web->control_web_cmd_stop_load = control_web_cmd_stop_load; + instance->web->control_web_cmd_nav_back = control_web_cmd_nav_back; + instance->web->control_web_cmd_nav_forward = control_web_cmd_nav_forward; + instance->web->control_web_open_own_context_menu = control_web_open_own_context_menu; + instance->web->control_screen_size_change = control_screen_size_change; + } + + friend class CWebControl; + + inline static bool main_initialize(const KODI_ADDON_WEB_HDL hdl) + { + return static_cast(hdl)->MainInitialize(); + } + + inline static void main_loop(const KODI_ADDON_WEB_HDL hdl) + { + static_cast(hdl)->MainLoop(); + } + + inline static void main_shutdown(const KODI_ADDON_WEB_HDL hdl) + { + static_cast(hdl)->MainShutdown(); + } + + inline static WEB_ADDON_ERROR start_instance(const KODI_ADDON_WEB_HDL hdl) + { + return static_cast(hdl)->StartInstance(); + } + + inline static void stop_instance(const KODI_ADDON_WEB_HDL hdl) + { + static_cast(hdl)->StopInstance(); + } + + inline static void set_mute(const KODI_ADDON_WEB_HDL hdl, bool mute) + { + static_cast(hdl)->SetMute(mute); + } + + inline static bool set_language(const KODI_ADDON_WEB_HDL hdl, const char* language) + { + return static_cast(hdl)->SetLanguage(language); + } + + inline static WEB_ADDON_ERROR create_control(const KODI_ADDON_WEB_HDL hdl, + const WEB_ADDON_GUI_PROPS* props, + const char* start_url, + KODI_ADDON_WEB_CONTROL_HDL* handle) + { + CInstanceWeb* const instance = static_cast(hdl); + + WEB_CONTROL_HANDLE controlHandle; + controlHandle.kodi = instance->m_kodi; + controlHandle.props = *props; // Copy as can be deleted after this call + controlHandle.addonWebBase = instance; + + kodi::addon::CWebControl* control = nullptr; + WEB_ADDON_ERROR err = instance->CreateControl(props->strName, start_url, &controlHandle, control); + if ((err == WEB_ADDON_ERROR_NO_ERROR || err == WEB_ADDON_ERROR_NO_ERROR) && control == nullptr) + { + kodi::Log(ADDON_LOG_ERROR, "Failed to create web addon control instance"); + return WEB_ADDON_ERROR_PERMANENT_FAILED; + } + + *handle = control; + return err; + } + + inline static WEB_ADDON_ERROR destroy_control(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + bool complete) + { + return static_cast(hdl)->DestroyControl(static_cast(handle), + complete); + } + + inline static bool control_render_init(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) + { + return static_cast(handle)->RenderInit(); + } + + inline static void control_render_deinit(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) + { + static_cast(handle)->RenderDeinit(); + } + + inline static void control_render(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) + { + static_cast(handle)->Render(); + } + + inline static bool control_dirty(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) + { + return static_cast(handle)->Dirty(); + } + + inline static bool control_on_init(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle) + { + return static_cast(handle)->OnInit(); + } + + inline static bool control_on_action(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const KODI_ADDON_ACTION_DATA* action, + int* nextItem) + { + return static_cast(handle)->OnAction(action, *nextItem); + } + + inline static bool control_on_mouse_event(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + int id, + double x, + double y, + double offsetX, + double offsetY, + int state) + { + return static_cast(handle)->OnMouseEvent(id, x, y, offsetX, offsetY, state); + } + + inline static bool control_open_website(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* url) + { + return static_cast(handle)->OpenWebsite(url); + } + + inline static bool control_get_history(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + char*** list, + size_t* entries, + bool behind_current) + { + std::vector historyWebsiteNames; + bool ret = static_cast(handle)->GetHistory(historyWebsiteNames, behind_current); + if (ret) + { + *list = static_cast(malloc(historyWebsiteNames.size() * sizeof(char*))); + *entries = historyWebsiteNames.size(); + for (size_t i = 0; i < historyWebsiteNames.size(); ++i) +#ifdef WIN32 // To prevent warning C4996 + (*list)[i] = _strdup(historyWebsiteNames[i].c_str()); +#else + (*list)[i] = strdup(historyWebsiteNames[i].c_str()); +#endif + } + return ret; + } + + inline static void control_get_history_clear(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + char** list, + unsigned int entries) + { + for (unsigned int i = 0; i < entries; ++i) + free(list[i]); + free(list); + } + + inline static void control_search_text(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* text, + bool forward, + bool matchCase, + bool findNext) + { + static_cast(handle)->SearchText(text, forward, matchCase, findNext); + } + + inline static void control_stop_search(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + bool clearSelection) + { + static_cast(handle)->StopSearch(clearSelection); + } + + inline static void control_web_cmd_reload(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) + { + static_cast(handle)->Reload(); + } + + inline static void control_web_cmd_stop_load(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) + { + static_cast(handle)->StopLoad(); + } + + inline static void control_web_cmd_nav_back(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) + { + static_cast(handle)->GoBack(); + } + + inline static void control_web_cmd_nav_forward(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) + { + static_cast(handle)->GoForward(); + } + + inline static void control_web_open_own_context_menu(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) + { + static_cast(handle)->OpenOwnContextMenu(); + } + + inline static void control_screen_size_change(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + float x, + float y, + float width, + float height, + bool fullscreen) + { + static_cast(handle)->ScreenSizeChange(x, y, width, height, fullscreen); + } +}; + +} /* namespace addon */ +} /* namespace kodi */ + +#endif /* __cplusplus */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/CMakeLists.txt index ebbeeb7e6c3ea..f1319d512fac5 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/CMakeLists.txt +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/CMakeLists.txt @@ -2,11 +2,7 @@ # See xbmc/addons/kodi-dev-kit/tools/code-generator.py. set(HEADERS - DemuxPacket.h - StreamCodec.h - StreamConstants.h StreamCrypto.h - TimingConstants.h ) if(HEADERS) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/DemuxPacket.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/DemuxPacket.h deleted file mode 100644 index f965b9f64149f..0000000000000 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/DemuxPacket.h +++ /dev/null @@ -1,12 +0,0 @@ -/* - * Copyright (C) 2005-2020 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "TimingConstants.h" -#include "../../c-api/addon-instance/inputstream/demux_packet.h" diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamCodec.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamCodec.h deleted file mode 100644 index e80e2ca43b6ce..0000000000000 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamCodec.h +++ /dev/null @@ -1,11 +0,0 @@ -/* - * Copyright (C) 2005-2020 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "../../c-api/addon-instance/inputstream/stream_codec.h" diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamConstants.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamConstants.h deleted file mode 100644 index 200631b6f96f5..0000000000000 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamConstants.h +++ /dev/null @@ -1,11 +0,0 @@ -/* - * Copyright (C) 2005-2020 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "../../c-api/addon-instance/inputstream/stream_constants.h" diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/TimingConstants.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/TimingConstants.h deleted file mode 100644 index 22f8952577716..0000000000000 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/TimingConstants.h +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (C) 2005-2020 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "../../c-api/addon-instance/inputstream/timing_constants.h" - -#ifdef __cplusplus - -// Unset the on timing_constants.h given defines -#undef STREAM_TIME_TO_MSEC -#undef STREAM_SEC_TO_TIME -#undef STREAM_MSEC_TO_TIME - -/// @ingroup cpp_kodi_addon_inputstream_Defs_TimingConstants -/// @brief Converts a stream time to milliseconds as an integer value. -/// -/// @param[in] x Stream time -/// @return Milliseconds -/// -/// @note Within "C" code this is used as `#define`. -/// -constexpr int STREAM_TIME_TO_MSEC(double x) -{ - return static_cast(x * 1000 / STREAM_TIME_BASE); -} - -/// @ingroup cpp_kodi_addon_inputstream_Defs_TimingConstants -/// @brief Converts a time in seconds to the used stream time format. -/// -/// @param[in] x Seconds -/// @return Stream time -/// -/// @note Within "C" code this is used as `#define`. -/// -constexpr double STREAM_SEC_TO_TIME(double x) -{ - return x * STREAM_TIME_BASE; -} - -/// @ingroup cpp_kodi_addon_inputstream_Defs_TimingConstants -/// @brief Converts a time in milliseconds to the used stream time format. -/// -/// @param[in] x Milliseconds -/// @return Stream time -/// -/// @note Within "C" code this is used as `#define`. -/// -constexpr double STREAM_MSEC_TO_TIME(double x) -{ - return x * STREAM_TIME_BASE / 1000; -} - -#endif /* __cplusplus */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/peripheral/PeripheralUtils.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/peripheral/PeripheralUtils.h index bedd7cb801c60..a02575001a96c 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/peripheral/PeripheralUtils.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/peripheral/PeripheralUtils.h @@ -99,11 +99,11 @@ class PeripheralVector } } - static void FreeStructs(unsigned int structCount, THE_STRUCT* structs) + static void FreeStructs(THE_STRUCT* structs, size_t structCount) { if (structs) { - for (unsigned int i = 0; i < structCount; i++) + for (size_t i = 0; i < structCount; i++) THE_CLASS::FreeStruct(structs[i]); } PERIPHERAL_SAFE_DELETE_ARRAY(structs); diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/CMakeLists.txt index 1690c398fb937..8766f858791ef 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/CMakeLists.txt +++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/CMakeLists.txt @@ -4,13 +4,9 @@ set(HEADERS ChannelGroups.h Channels.h - EDL.h EPG.h - General.h - MenuHook.h Providers.h Recordings.h - Stream.h Timers.h ) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/EDL.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/EDL.h deleted file mode 100644 index 34c7c413bf93e..0000000000000 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/EDL.h +++ /dev/null @@ -1,90 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "../../AddonBase.h" -#include "../../c-api/addon-instance/pvr/pvr_edl.h" - -//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ -// "C++" Definitions group 8 - PVR Edit definition list (EDL) -#ifdef __cplusplus - -namespace kodi -{ -namespace addon -{ - -//============================================================================== -/// @defgroup cpp_kodi_addon_pvr_Defs_EDLEntry_PVREDLEntry class PVREDLEntry -/// @ingroup cpp_kodi_addon_pvr_Defs_EDLEntry -/// @brief **Edit definition list (EDL) entry**\n -/// Time places and type of related fields. -/// -/// This used within @ref cpp_kodi_addon_pvr_EPGTag "EPG" and -/// @ref cpp_kodi_addon_pvr_Recordings "recordings". -/// -/// ---------------------------------------------------------------------------- -/// -/// @copydetails cpp_kodi_addon_pvr_Defs_EDLEntry_PVREDLEntry_Help -/// -///@{ -class PVREDLEntry : public CStructHdl -{ - friend class CInstancePVRClient; - -public: - /*! \cond PRIVATE */ - PVREDLEntry() { memset(m_cStructure, 0, sizeof(PVR_EDL_ENTRY)); } - PVREDLEntry(const PVREDLEntry& type) : CStructHdl(type) {} - /*! \endcond */ - - /// @defgroup cpp_kodi_addon_pvr_Defs_EDLEntry_PVREDLEntry_Help Value Help - /// @ingroup cpp_kodi_addon_pvr_Defs_EDLEntry_PVREDLEntry - /// - /// The following table contains values that can be set with @ref cpp_kodi_addon_pvr_Defs_EDLEntry_PVREDLEntry : - /// | Name | Type | Set call | Get call | Usage - /// |------|------|----------|----------|----------- - /// | **Start time** | `int64_t` | @ref PVREDLEntry::SetStart "SetStart" | @ref PVREDLEntry::GetStart "GetStart" | *required to set* - /// | **End time** | `int64_t` | @ref PVREDLEntry::SetEnd "SetEnd" | @ref PVREDLEntry::GetEnd "GetEnd" | *required to set* - /// | **Type** | @ref PVR_EDL_TYPE | @ref PVREDLEntry::SetType "SetType" | @ref PVREDLEntry::GetType "GetType" | *required to set* - /// - - /// @addtogroup cpp_kodi_addon_pvr_Defs_EDLEntry_PVREDLEntry - ///@{ - - /// @brief Start time in milliseconds. - void SetStart(int64_t start) { m_cStructure->start = start; } - - /// @brief To get with @ref SetStart() changed values. - int64_t GetStart() const { return m_cStructure->start; } - - /// @brief End time in milliseconds. - void SetEnd(int64_t end) { m_cStructure->end = end; } - - /// @brief To get with @ref SetEnd() changed values. - int64_t GetEnd() const { return m_cStructure->end; } - - /// @brief The with @ref PVR_EDL_TYPE used definition list type. - void SetType(PVR_EDL_TYPE type) { m_cStructure->type = type; } - - /// @brief To get with @ref SetType() changed values. - PVR_EDL_TYPE GetType() const { return m_cStructure->type; } - ///@} - -private: - PVREDLEntry(const PVR_EDL_ENTRY* type) : CStructHdl(type) {} - PVREDLEntry(PVR_EDL_ENTRY* type) : CStructHdl(type) {} -}; -///@} -//------------------------------------------------------------------------------ - -} /* namespace addon */ -} /* namespace kodi */ - -#endif /* __cplusplus */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/General.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/General.h deleted file mode 100644 index 758feedd903b1..0000000000000 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/General.h +++ /dev/null @@ -1,536 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "../../AddonBase.h" -#include "../../c-api/addon-instance/pvr/pvr_general.h" - -//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ -// "C++" Definitions group 1 - General PVR -#ifdef __cplusplus - -namespace kodi -{ -namespace addon -{ - -//============================================================================== -/// @defgroup cpp_kodi_addon_pvr_Defs_PVRTypeIntValue class PVRTypeIntValue -/// @ingroup cpp_kodi_addon_pvr_Defs_General -/// @brief **PVR add-on type value**\n -/// Representation of a `` event related value. -/// -/// ---------------------------------------------------------------------------- -/// -/// @copydetails cpp_kodi_addon_pvr_Defs_PVRTypeIntValue_Help -/// -///@{ -class PVRTypeIntValue : public CStructHdl -{ - friend class CInstancePVRClient; - -public: - /*! \cond PRIVATE */ - PVRTypeIntValue(const PVRTypeIntValue& data) : CStructHdl(data) {} - /*! \endcond */ - - /// @defgroup cpp_kodi_addon_pvr_Defs_PVRTypeIntValue_Help Value Help - /// @ingroup cpp_kodi_addon_pvr_Defs_PVRTypeIntValue - /// - /// The following table contains values that can be set with @ref cpp_kodi_addon_pvr_Defs_PVRTypeIntValue : - /// | Name | Type | Set call | Get call - /// |------|------|----------|---------- - /// | **Value** | `int` | @ref PVRTypeIntValue::SetValue "SetValue" | @ref PVRTypeIntValue::GetValue "GetValue" - /// | **Description** | `std::string` | @ref PVRTypeIntValue::SetDescription "SetDescription" | @ref PVRTypeIntValue::GetDescription "GetDescription" - /// - /// @remark Further can there be used his class constructor to set values. - - /// @addtogroup cpp_kodi_addon_pvr_Defs_PVRTypeIntValue - ///@{ - - /// @brief Default class constructor. - /// - /// @note Values must be set afterwards. - PVRTypeIntValue() = default; - - /// @brief Class constructor with integrated value set. - /// - /// @param[in] value Type identification value - /// @param[in] description Type description text - PVRTypeIntValue(int value, const std::string& description) - { - SetValue(value); - SetDescription(description); - } - - /// @brief To set with the identification value. - void SetValue(int value) { m_cStructure->iValue = value; } - - /// @brief To get with the identification value. - int GetValue() const { return m_cStructure->iValue; } - - /// @brief To set with the description text of the value. - void SetDescription(const std::string& description) - { - strncpy(m_cStructure->strDescription, description.c_str(), - sizeof(m_cStructure->strDescription) - 1); - } - - /// @brief To get with the description text of the value. - std::string GetDescription() const { return m_cStructure->strDescription; } - ///@} - -private: - PVRTypeIntValue(const PVR_ATTRIBUTE_INT_VALUE* data) : CStructHdl(data) {} - PVRTypeIntValue(PVR_ATTRIBUTE_INT_VALUE* data) : CStructHdl(data) {} -}; -///@} -//------------------------------------------------------------------------------ - -//============================================================================== -/// @defgroup cpp_kodi_addon_pvr_Defs_PVRCapabilities class PVRCapabilities -/// @ingroup cpp_kodi_addon_pvr_Defs_General -/// @brief **PVR add-on capabilities**\n -/// This class is needed to tell Kodi which options are supported on the addon. -/// -/// If a capability is set to **true**, then the corresponding methods from -/// @ref cpp_kodi_addon_pvr "kodi::addon::CInstancePVRClient" need to be -/// implemented. -/// -/// As default them all set to **false**. -/// -/// Used on @ref kodi::addon::CInstancePVRClient::GetCapabilities(). -/// -/// ---------------------------------------------------------------------------- -/// -/// @copydetails cpp_kodi_addon_pvr_Defs_PVRCapabilities_Help -/// -///@{ -class PVRCapabilities -{ - friend class CInstancePVRClient; - -public: - /*! \cond PRIVATE */ - explicit PVRCapabilities() = delete; - /*! \endcond */ - - /// @defgroup cpp_kodi_addon_pvr_Defs_PVRCapabilities_Help Value Help - /// @ingroup cpp_kodi_addon_pvr_Defs_PVRCapabilities - /// ---------------------------------------------------------------------------- - /// - /// The following table contains values that can be set with @ref cpp_kodi_addon_pvr_Defs_PVRCapabilities : - /// | Name | Type | Set call | Get call - /// |------|------|----------|---------- - /// | **Supports EPG** | `boolean` | @ref PVRCapabilities::SetSupportsEPG "SetSupportsEPG" | @ref PVRCapabilities::GetSupportsEPG "GetSupportsEPG" - /// | **Supports EPG EDL** | `boolean` | @ref PVRCapabilities::SetSupportsEPGEdl "SetSupportsEPGEdl" | @ref PVRCapabilities::GetSupportsEPGEdl "GetSupportsEPGEdl" - /// | **Supports TV** | `boolean` | @ref PVRCapabilities::SetSupportsTV "SetSupportsTV" | @ref PVRCapabilities::GetSupportsTV "GetSupportsTV" - /// | **Supports radio** | `boolean` | @ref PVRCapabilities::SetSupportsRadio "SetSupportsRadio" | @ref PVRCapabilities::GetSupportsRadio "GetSupportsRadio" - /// | **Supports recordings** | `boolean` | @ref PVRCapabilities::SetSupportsRecordings "SetSupportsRecordings" | @ref PVRCapabilities::GetSupportsRecordings "GetSupportsRecordings" - /// | **Supports recordings undelete** | `boolean` | @ref PVRCapabilities::SetSupportsRecordingsUndelete "SetSupportsRecordingsUndelete" | @ref PVRCapabilities::GetSupportsRecordingsUndelete "SetSupportsRecordingsUndelete" - /// | **Supports timers** | `boolean` | @ref PVRCapabilities::SetSupportsTimers "SetSupportsTimers" | @ref PVRCapabilities::GetSupportsTimers "GetSupportsTimers" - /// | **Supports providers** | `boolean` | @ref PVRCapabilities::SetSupportsProviders "SetSupportsProviders" | @ref PVRCapabilities::GetSupportsProviders "GetSupportsProviders" - /// | **Supports channel groups** | `boolean` | @ref PVRCapabilities::SetSupportsChannelGroups "SetSupportsChannelGroups" | @ref PVRCapabilities::GetSupportsChannelGroups "GetSupportsChannelGroups" - /// | **Supports channel scan** | `boolean` | @ref PVRCapabilities::SetSupportsChannelScan "SetSupportsChannelScan" | @ref PVRCapabilities::GetSupportsChannelScan "GetSupportsChannelScan" - /// | **Supports channel settings** | `boolean` | @ref PVRCapabilities::SetSupportsChannelSettings "SetSupportsChannelSettings" | @ref PVRCapabilities::GetSupportsChannelSettings "GetSupportsChannelSettings" - /// | **Handles input stream** | `boolean` | @ref PVRCapabilities::SetHandlesInputStream "SetHandlesInputStream" | @ref PVRCapabilities::GetHandlesInputStream "GetHandlesInputStream" - /// | **Handles demuxing** | `boolean` | @ref PVRCapabilities::SetHandlesDemuxing "SetHandlesDemuxing" | @ref PVRCapabilities::GetHandlesDemuxing "GetHandlesDemuxing" - /// | **Supports recording play count** | `boolean` | @ref PVRCapabilities::SetSupportsRecordingPlayCount "SetSupportsRecordingPlayCount" | @ref PVRCapabilities::GetSupportsRecordingPlayCount "GetSupportsRecordingPlayCount" - /// | **Supports last played position** | `boolean` | @ref PVRCapabilities::SetSupportsLastPlayedPosition "SetSupportsLastPlayedPosition" | @ref PVRCapabilities::GetSupportsLastPlayedPosition "GetSupportsLastPlayedPosition" - /// | **Supports recording EDL** | `boolean` | @ref PVRCapabilities::SetSupportsRecordingEdl "SetSupportsRecordingEdl" | @ref PVRCapabilities::GetSupportsRecordingEdl "GetSupportsRecordingEdl" - /// | **Supports recordings rename** | `boolean` | @ref PVRCapabilities::SetSupportsRecordingsRename "SetSupportsRecordingsRename" | @ref PVRCapabilities::GetSupportsRecordingsRename "GetSupportsRecordingsRename" - /// | **Supports recordings lifetime change** | `boolean` | @ref PVRCapabilities::SetSupportsRecordingsLifetimeChange "SetSupportsRecordingsLifetimeChange" | @ref PVRCapabilities::GetSupportsRecordingsLifetimeChange "GetSupportsRecordingsLifetimeChange" - /// | **Supports descramble info** | `boolean` | @ref PVRCapabilities::SetSupportsDescrambleInfo "SetSupportsDescrambleInfo" | @ref PVRCapabilities::GetSupportsDescrambleInfo "GetSupportsDescrambleInfo" - /// | **Supports async EPG transfer** | `boolean` | @ref PVRCapabilities::SetSupportsAsyncEPGTransfer "SetSupportsAsyncEPGTransfer" | @ref PVRCapabilities::GetSupportsAsyncEPGTransfer "GetSupportsAsyncEPGTransfer" - /// | **Supports recording size** | `boolean` | @ref PVRCapabilities::SetSupportsRecordingSize "SetSupportsRecordingSize" | @ref PVRCapabilities::GetSupportsRecordingSize "GetSupportsRecordingSize" - /// | **Supports recordings delete** | `boolean` | @ref PVRCapabilities::SetSupportsRecordingsDelete "SetSupportsRecordingsDelete" | @ref PVRCapabilities::GetSupportsRecordingsDelete "SetSupportsRecordingsDelete" - /// | **Recordings lifetime values** | @ref cpp_kodi_addon_pvr_Defs_PVRTypeIntValue "PVRTypeIntValue" | @ref PVRCapabilities::SetRecordingsLifetimeValues "SetRecordingsLifetimeValues" | @ref PVRCapabilities::GetRecordingsLifetimeValues "GetRecordingsLifetimeValues" - /// - /// @warning This class can not be used outside of @ref kodi::addon::CInstancePVRClient::GetCapabilities() - /// - - /// @addtogroup cpp_kodi_addon_pvr_Defs_PVRCapabilities - ///@{ - - /// @brief Set **true** if the add-on provides EPG information. - void SetSupportsEPG(bool supportsEPG) { m_capabilities->bSupportsEPG = supportsEPG; } - - /// @brief To get with @ref SetSupportsEPG changed values. - bool GetSupportsEPG() const { return m_capabilities->bSupportsEPG; } - - /// @brief Set **true** if the backend supports retrieving an edit decision - /// list for an EPG tag. - void SetSupportsEPGEdl(bool supportsEPGEdl) { m_capabilities->bSupportsEPGEdl = supportsEPGEdl; } - - /// @brief To get with @ref SetSupportsEPGEdl changed values. - bool GetSupportsEPGEdl() const { return m_capabilities->bSupportsEPGEdl; } - - /// @brief Set **true** if this add-on provides TV channels. - void SetSupportsTV(bool supportsTV) { m_capabilities->bSupportsTV = supportsTV; } - - /// @brief To get with @ref SetSupportsTV changed values. - bool GetSupportsTV() const { return m_capabilities->bSupportsTV; } - - /// @brief Set **true** if this add-on provides TV channels. - void SetSupportsRadio(bool supportsRadio) { m_capabilities->bSupportsRadio = supportsRadio; } - - /// @brief To get with @ref SetSupportsRadio changed values. - bool GetSupportsRadio() const { return m_capabilities->bSupportsRadio; } - - /// @brief **true** if this add-on supports playback of recordings stored on - /// the backend. - void SetSupportsRecordings(bool supportsRecordings) - { - m_capabilities->bSupportsRecordings = supportsRecordings; - } - - /// @brief To get with @ref SetSupportsRecordings changed values. - bool GetSupportsRecordings() const { return m_capabilities->bSupportsRecordings; } - - /// @brief Set **true** if this add-on supports undelete of recordings stored - /// on the backend. - void SetSupportsRecordingsUndelete(bool supportsRecordingsUndelete) - { - m_capabilities->bSupportsRecordingsUndelete = supportsRecordingsUndelete; - } - - /// @brief To get with @ref SetSupportsRecordings changed values. - bool GetSupportsRecordingsUndelete() const { return m_capabilities->bSupportsRecordingsUndelete; } - - /// @brief Set **true** if this add-on supports the creation and editing of - /// timers. - void SetSupportsTimers(bool supportsTimers) { m_capabilities->bSupportsTimers = supportsTimers; } - - /// @brief To get with @ref SetSupportsTimers changed values. - bool GetSupportsTimers() const { return m_capabilities->bSupportsTimers; } - - /// @brief Set **true** if this add-on supports providers. - /// - /// It uses the following functions: - /// - @ref kodi::addon::CInstancePVRClient::GetProvidersAmount() - /// - @ref kodi::addon::CInstancePVRClient::GetProviders() - void SetSupportsProviders(bool supportsProviders) - { - m_capabilities->bSupportsProviders = supportsProviders; - } - - /// @brief To get with @ref SetSupportsProviders changed values. - bool GetSupportsProviders() const { return m_capabilities->bSupportsProviders; } - - /// @brief Set **true** if this add-on supports channel groups. - /// - /// It use the following functions: - /// - @ref kodi::addon::CInstancePVRClient::GetChannelGroupsAmount() - /// - @ref kodi::addon::CInstancePVRClient::GetChannelGroups() - /// - @ref kodi::addon::CInstancePVRClient::GetChannelGroupMembers() - void SetSupportsChannelGroups(bool supportsChannelGroups) - { - m_capabilities->bSupportsChannelGroups = supportsChannelGroups; - } - - /// @brief To get with @ref SetSupportsChannelGroups changed values. - bool GetSupportsChannelGroups() const { return m_capabilities->bSupportsChannelGroups; } - - /// @brief Set **true** if this add-on support scanning for new channels on - /// the backend. - /// - /// It use the following function: - /// - @ref kodi::addon::CInstancePVRClient::OpenDialogChannelScan() - void SetSupportsChannelScan(bool supportsChannelScan) - { - m_capabilities->bSupportsChannelScan = supportsChannelScan; - } - - /// @brief To get with @ref SetSupportsChannelScan changed values. - bool GetSupportsChannelScan() const { return m_capabilities->bSupportsChannelScan; } - - /// @brief Set **true** if this add-on supports channel edit. - /// - /// It use the following functions: - /// - @ref kodi::addon::CInstancePVRClient::DeleteChannel() - /// - @ref kodi::addon::CInstancePVRClient::RenameChannel() - /// - @ref kodi::addon::CInstancePVRClient::OpenDialogChannelSettings() - /// - @ref kodi::addon::CInstancePVRClient::OpenDialogChannelAdd() - void SetSupportsChannelSettings(bool supportsChannelSettings) - { - m_capabilities->bSupportsChannelSettings = supportsChannelSettings; - } - - /// @brief To get with @ref SetSupportsChannelSettings changed values. - bool GetSupportsChannelSettings() const { return m_capabilities->bSupportsChannelSettings; } - - /// @brief Set **true** if this add-on provides an input stream. false if Kodi - /// handles the stream. - void SetHandlesInputStream(bool handlesInputStream) - { - m_capabilities->bHandlesInputStream = handlesInputStream; - } - - /// @brief To get with @ref SetHandlesInputStream changed values. - bool GetHandlesInputStream() const { return m_capabilities->bHandlesInputStream; } - - /// @brief Set **true** if this add-on demultiplexes packets. - void SetHandlesDemuxing(bool handlesDemuxing) - { - m_capabilities->bHandlesDemuxing = handlesDemuxing; - } - - /// @brief To get with @ref SetHandlesDemuxing changed values. - bool GetHandlesDemuxing() const { return m_capabilities->bHandlesDemuxing; } - - /// @brief Set **true** if the backend supports play count for recordings. - void SetSupportsRecordingPlayCount(bool supportsRecordingPlayCount) - { - m_capabilities->bSupportsRecordingPlayCount = supportsRecordingPlayCount; - } - - /// @brief To get with @ref SetSupportsRecordingPlayCount changed values. - bool GetSupportsRecordingPlayCount() const { return m_capabilities->bSupportsRecordingPlayCount; } - - /// @brief Set **true** if the backend supports store/retrieve of last played - /// position for recordings. - void SetSupportsLastPlayedPosition(bool supportsLastPlayedPosition) - { - m_capabilities->bSupportsLastPlayedPosition = supportsLastPlayedPosition; - } - - /// @brief To get with @ref SetSupportsLastPlayedPosition changed values. - bool GetSupportsLastPlayedPosition() const { return m_capabilities->bSupportsLastPlayedPosition; } - - /// @brief Set **true** if the backend supports retrieving an edit decision - /// list for recordings. - void SetSupportsRecordingEdl(bool supportsRecordingEdl) - { - m_capabilities->bSupportsRecordingEdl = supportsRecordingEdl; - } - - /// @brief To get with @ref SetSupportsRecordingEdl changed values. - bool GetSupportsRecordingEdl() const { return m_capabilities->bSupportsRecordingEdl; } - - /// @brief Set **true** if the backend supports renaming recordings. - void SetSupportsRecordingsRename(bool supportsRecordingsRename) - { - m_capabilities->bSupportsRecordingsRename = supportsRecordingsRename; - } - - /// @brief To get with @ref SetSupportsRecordingsRename changed values. - bool GetSupportsRecordingsRename() const { return m_capabilities->bSupportsRecordingsRename; } - - /// @brief Set **true** if the backend supports changing lifetime for - /// recordings. - void SetSupportsRecordingsLifetimeChange(bool supportsRecordingsLifetimeChange) - { - m_capabilities->bSupportsRecordingsLifetimeChange = supportsRecordingsLifetimeChange; - } - - /// @brief To get with @ref SetSupportsRecordingsLifetimeChange changed - /// values. - bool GetSupportsRecordingsLifetimeChange() const - { - return m_capabilities->bSupportsRecordingsLifetimeChange; - } - - /// @brief Set **true** if the backend supports descramble information for - /// playing channels. - void SetSupportsDescrambleInfo(bool supportsDescrambleInfo) - { - m_capabilities->bSupportsDescrambleInfo = supportsDescrambleInfo; - } - - /// @brief To get with @ref SetSupportsDescrambleInfo changed values. - bool GetSupportsDescrambleInfo() const { return m_capabilities->bSupportsDescrambleInfo; } - - /// @brief Set **true** if this addon-on supports asynchronous transfer of epg - /// events to Kodi using the callback function - /// @ref kodi::addon::CInstancePVRClient::EpgEventStateChange(). - void SetSupportsAsyncEPGTransfer(bool supportsAsyncEPGTransfer) - { - m_capabilities->bSupportsAsyncEPGTransfer = supportsAsyncEPGTransfer; - } - - /// @brief To get with @ref SetSupportsAsyncEPGTransfer changed values. - bool GetSupportsAsyncEPGTransfer() const { return m_capabilities->bSupportsAsyncEPGTransfer; } - - /// @brief Set **true** if this addon-on supports retrieving size of recordings. - void SetSupportsRecordingSize(bool supportsRecordingSize) - { - m_capabilities->bSupportsRecordingSize = supportsRecordingSize; - } - - /// @brief To get with @ref SetSupportsRecordingSize changed values. - bool GetSupportsRecordingSize() const { return m_capabilities->bSupportsRecordingSize; } - - /// @brief Set **true** if this add-on supports delete of recordings stored - /// on the backend. - void SetSupportsRecordingsDelete(bool supportsRecordingsDelete) - { - m_capabilities->bSupportsRecordingsDelete = supportsRecordingsDelete; - } - - /// @brief To get with @ref SetSupportsRecordingsDelete changed values. - bool GetSupportsRecordingsDelete() const { return m_capabilities->bSupportsRecordingsDelete; } - - /// @brief **optional**\n - /// Set array containing the possible values for @ref PVRRecording::SetLifetime(). - /// - /// -------------------------------------------------------------------------- - /// - /// @copydetails cpp_kodi_addon_pvr_Defs_PVRTypeIntValue_Help - void SetRecordingsLifetimeValues( - const std::vector& recordingsLifetimeValues) - { - m_capabilities->iRecordingsLifetimesSize = 0; - for (unsigned int i = 0; i < recordingsLifetimeValues.size() && - i < sizeof(m_capabilities->recordingsLifetimeValues); - ++i) - { - m_capabilities->recordingsLifetimeValues[i].iValue = - recordingsLifetimeValues[i].GetCStructure()->iValue; - strncpy(m_capabilities->recordingsLifetimeValues[i].strDescription, - recordingsLifetimeValues[i].GetCStructure()->strDescription, - sizeof(m_capabilities->recordingsLifetimeValues[i].strDescription) - 1); - ++m_capabilities->iRecordingsLifetimesSize; - } - } - - /// @brief To get with @ref SetRecordingsLifetimeValues changed values. - std::vector GetRecordingsLifetimeValues() const - { - std::vector recordingsLifetimeValues; - for (unsigned int i = 0; i < m_capabilities->iRecordingsLifetimesSize; ++i) - recordingsLifetimeValues.emplace_back( - m_capabilities->recordingsLifetimeValues[i].iValue, - m_capabilities->recordingsLifetimeValues[i].strDescription); - return recordingsLifetimeValues; - } - ///@} - -private: - PVRCapabilities(PVR_ADDON_CAPABILITIES* capabilities) : m_capabilities(capabilities) {} - - PVR_ADDON_CAPABILITIES* m_capabilities; -}; -///@} -//------------------------------------------------------------------------------ - -//============================================================================== -/// @defgroup cpp_kodi_addon_pvr_Defs_General_Inputstream_PVRStreamProperty class PVRStreamProperty -/// @ingroup cpp_kodi_addon_pvr_Defs_General_Inputstream -/// @brief **PVR stream property value handler**\n -/// To set for Kodi wanted stream properties. -/// -/// ---------------------------------------------------------------------------- -/// -/// @copydetails cpp_kodi_addon_pvr_Defs_General_Inputstream_PVRStreamProperty_Help -/// -///--------------------------------------------------------------------------- -/// -/// **Example:** -/// ~~~~~~~~~~~~~{.cpp} -/// ... -/// -/// PVR_ERROR CMyPVRInstance::GetChannelStreamProperties(const kodi::addon::PVRChannel& channel, -/// std::vector& properties) -/// { -/// ... -/// properties.emplace_back(PVR_STREAM_PROPERTY_INPUTSTREAM, "inputstream.adaptive"); -/// return PVR_ERROR_NO_ERROR; -/// } -/// -/// ... -/// ~~~~~~~~~~~~~ -/// -/// -/// **Example 2:** -/// ~~~~~~~~~~~~~{.cpp} -/// ... -/// -/// PVR_ERROR CMyPVRInstance::GetChannelStreamProperties(const kodi::addon::PVRChannel& channel, -/// std::vector& properties) -/// { -/// ... -/// kodi::addon::PVRStreamProperty property; -/// property.SetName(PVR_STREAM_PROPERTY_INPUTSTREAM); -/// property.SetValue("inputstream.adaptive"); -/// properties.emplace_back(property); -/// return PVR_ERROR_NO_ERROR; -/// } -/// -/// ... -/// ~~~~~~~~~~~~~ -/// -///@{ -class PVRStreamProperty : public CStructHdl -{ - friend class CInstancePVRClient; - -public: - /*! \cond PRIVATE */ - PVRStreamProperty(const PVRStreamProperty& data) : CStructHdl(data) {} - /*! \endcond */ - - /// @defgroup cpp_kodi_addon_pvr_Defs_General_Inputstream_PVRStreamProperty_Help Value Help - /// @ingroup cpp_kodi_addon_pvr_Defs_General_Inputstream_PVRStreamProperty - /// - /// The following table contains values that can be set with @ref cpp_kodi_addon_pvr_Defs_General_Inputstream_PVRStreamProperty : - /// | Name | Type | Set call | Get call - /// |------|------|----------|---------- - /// | **Name** | `int` | @ref PVRStreamProperty::SetValue "SetName" | @ref PVRStreamProperty::GetName "GetName" - /// | **Value** | `std::string` | @ref PVRStreamProperty::SetValue "SetValue" | @ref PVRStreamProperty::GetValue "GetValue" - /// - /// @remark Further can there be used his class constructor to set values. - - /// @addtogroup cpp_kodi_addon_pvr_Defs_General_Inputstream_PVRStreamProperty - ///@{ - - /// @brief Default class constructor. - /// - /// @note Values must be set afterwards. - PVRStreamProperty() = default; - - /// @brief Class constructor with integrated value set. - /// - /// @param[in] name Type identification - /// @param[in] value Type used property value - PVRStreamProperty(const std::string& name, const std::string& value) - { - SetName(name); - SetValue(value); - } - - /// @brief To set with the identification name. - void SetName(const std::string& name) - { - strncpy(m_cStructure->strName, name.c_str(), sizeof(m_cStructure->strName) - 1); - } - - /// @brief To get with the identification name. - std::string GetName() const { return m_cStructure->strName; } - - /// @brief To set with the used property value. - void SetValue(const std::string& value) - { - strncpy(m_cStructure->strValue, value.c_str(), sizeof(m_cStructure->strValue) - 1); - } - - /// @brief To get with the used property value. - std::string GetValue() const { return m_cStructure->strValue; } - ///@} - -private: - PVRStreamProperty(const PVR_NAMED_VALUE* data) : CStructHdl(data) {} - PVRStreamProperty(PVR_NAMED_VALUE* data) : CStructHdl(data) {} -}; -///@} -//------------------------------------------------------------------------------ - -} /* namespace addon */ -} /* namespace kodi */ - -#endif /* __cplusplus */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/MenuHook.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/MenuHook.h deleted file mode 100644 index 053a4d5cf1269..0000000000000 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/MenuHook.h +++ /dev/null @@ -1,130 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "../../AddonBase.h" -#include "../../c-api/addon-instance/pvr/pvr_menu_hook.h" - -//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ -// "C++" Definitions group 7 - Menu hook -#ifdef __cplusplus - -namespace kodi -{ -namespace addon -{ - -//============================================================================== -/// @defgroup cpp_kodi_addon_pvr_Defs_Menuhook_PVRMenuhook class PVRMenuhook -/// @ingroup cpp_kodi_addon_pvr_Defs_Menuhook -/// @brief **Context menu hook**\n -/// Menu hooks that are available in the context menus while playing a stream via this add-on. -/// And in the Live TV settings dialog. -/// -/// Possible menu's given to Kodi. -/// -/// This can be becomes used on this, if @ref kodi::addon::CInstancePVRClient::AddMenuHook() -/// was set to related type: -/// - @ref kodi::addon::CInstancePVRClient::CallSettingsMenuHook() -/// - @ref kodi::addon::CInstancePVRClient::CallChannelMenuHook() -/// - @ref kodi::addon::CInstancePVRClient::CallEPGMenuHook() -/// - @ref kodi::addon::CInstancePVRClient::CallRecordingMenuHook() -/// - @ref kodi::addon::CInstancePVRClient::CallTimerMenuHook() -/// -/// ---------------------------------------------------------------------------- -/// -/// @copydetails cpp_kodi_addon_pvr_Defs_Menuhook_PVRMenuhook_Help -/// -///@{ -class PVRMenuhook : public CStructHdl -{ - friend class CInstancePVRClient; - -public: - /// @addtogroup cpp_kodi_addon_pvr_Defs_Menuhook_PVRMenuhook - /// @brief Optional class constructor with value set. - /// - /// @param[in] hookId This hook's identifier - /// @param[in] localizedStringId Localized string identifier - /// @param[in] category Category of menu hook, defined with @ref PVR_MENUHOOK_CAT - /// - /// - /// -------------------------------------------------------------------------- - /// - /// Example: - /// ~~~~~~~~~~~~~{.cpp} - /// AddMenuHook(kodi::addon::PVRMenuhook(1, 30001, PVR_MENUHOOK_CHANNEL)); - /// ~~~~~~~~~~~~~ - /// - PVRMenuhook(unsigned int hookId, unsigned int localizedStringId, PVR_MENUHOOK_CAT category) - { - m_cStructure->iHookId = hookId; - m_cStructure->iLocalizedStringId = localizedStringId; - m_cStructure->category = category; - } - - /*! \cond PRIVATE */ - PVRMenuhook() - { - m_cStructure->iHookId = 0; - m_cStructure->iLocalizedStringId = 0; - m_cStructure->category = PVR_MENUHOOK_UNKNOWN; - } - PVRMenuhook(const PVRMenuhook& data) : CStructHdl(data) {} - /*! \endcond */ - - /// @defgroup cpp_kodi_addon_pvr_Defs_Menuhook_PVRMenuhook_Help Value Help - /// @ingroup cpp_kodi_addon_pvr_Defs_Menuhook_PVRMenuhook - /// - /// The following table contains values that can be set with @ref cpp_kodi_addon_pvr_Defs_Menuhook_PVRMenuhook : - /// | Name | Type | Set call | Get call | Usage - /// |------|------|----------|----------|----------- - /// | **This hook's identifier** | `unsigned int` | @ref PVRMenuhook::SetHookId "SetHookId" | @ref PVRMenuhook::GetHookId "GetHookId" | *required to set* - /// | **Localized string Identifier** | `unsigned int` | @ref PVRMenuhook::SetLocalizedStringId "SetLocalizedStringId" | @ref PVRMenuhook::GetLocalizedStringId "GetLocalizedStringId" | *required to set* - /// | **Category of menu hook** | @ref PVR_MENUHOOK_CAT | @ref PVRMenuhook::SetCategory "SetCategory" | @ref PVRMenuhook::GetCategory "GetCategory" | *required to set* - - /// @addtogroup cpp_kodi_addon_pvr_Defs_Menuhook_PVRMenuhook - ///@{ - - /// @brief **required**\n - /// This hook's identifier. - void SetHookId(unsigned int hookId) { m_cStructure->iHookId = hookId; } - - /// @brief To get with @ref SetHookId() changed values. - unsigned int GetHookId() const { return m_cStructure->iHookId; } - - /// @brief **required**\n - /// The id of the label for this hook in @ref kodi::GetLocalizedString(). - void SetLocalizedStringId(unsigned int localizedStringId) - { - m_cStructure->iLocalizedStringId = localizedStringId; - } - - /// @brief To get with @ref SetLocalizedStringId() changed values. - unsigned int GetLocalizedStringId() const { return m_cStructure->iLocalizedStringId; } - - /// @brief **required**\n - /// Category of menu hook. - void SetCategory(PVR_MENUHOOK_CAT category) { m_cStructure->category = category; } - - /// @brief To get with @ref SetCategory() changed values. - PVR_MENUHOOK_CAT GetCategory() const { return m_cStructure->category; } - ///@} - -private: - PVRMenuhook(const PVR_MENUHOOK* data) : CStructHdl(data) {} - PVRMenuhook(PVR_MENUHOOK* data) : CStructHdl(data) {} -}; -///@} -//------------------------------------------------------------------------------ - -} /* namespace addon */ -} /* namespace kodi */ - -#endif /* __cplusplus */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/Stream.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/Stream.h deleted file mode 100644 index 4241c233f5be8..0000000000000 --- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/Stream.h +++ /dev/null @@ -1,330 +0,0 @@ -/* - * Copyright (C) 2005-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#include "../../AddonBase.h" -#include "../../c-api/addon-instance/pvr/pvr_stream.h" - -//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ -// "C++" Definitions group 9 - PVR stream definitions (NOTE: Becomes replaced -// in future by inputstream addon instance way) - -#ifdef __cplusplus - -namespace kodi -{ -namespace addon -{ - -//============================================================================== -/// @defgroup cpp_kodi_addon_pvr_Defs_Stream_PVRCodec class PVRCodec -/// @ingroup cpp_kodi_addon_pvr_Defs_Stream -/// @brief **PVR codec identifier**\n -/// Used to exchange the desired codec type between Kodi and addon. -/// -/// @ref kodi::addon::CInstancePVRClient::GetCodecByName is used to get this data. -/// -/// ---------------------------------------------------------------------------- -/// -/// @copydetails cpp_kodi_addon_pvr_Defs_Stream_PVRCodec_Help -/// -///@{ -class PVRCodec : public CStructHdl -{ - friend class CInstancePVRClient; - -public: - /*! \cond PRIVATE */ - PVRCodec() - { - m_cStructure->codec_type = PVR_CODEC_TYPE_UNKNOWN; - m_cStructure->codec_id = PVR_INVALID_CODEC_ID; - } - PVRCodec(const PVRCodec& type) : CStructHdl(type) {} - /*! \endcond */ - - /// @defgroup cpp_kodi_addon_pvr_Defs_Stream_PVRCodec_Help Value Help - /// @ingroup cpp_kodi_addon_pvr_Defs_Stream_PVRCodec - /// - /// The following table contains values that can be set with @ref cpp_kodi_addon_pvr_Defs_Stream_PVRCodec : - /// | Name | Type | Set call | Get call - /// |------|------|----------|---------- - /// | **Codec type** | @ref PVR_CODEC_TYPE | @ref PVRCodec::SetCodecType "SetCodecType" | @ref PVRCodec::GetCodecType "GetCodecType" - /// | **Codec identifier** | `unsigned int` | @ref PVRCodec::SetCodecId "SetCodecId" | @ref PVRCodec::GetCodecId "GetCodecId" - /// - - /// @addtogroup cpp_kodi_addon_pvr_Defs_Stream_PVRCodec - ///@{ - - /// @brief Codec type. - void SetCodecType(PVR_CODEC_TYPE codecType) { m_cStructure->codec_type = codecType; } - - /// @brief To get with @ref SetCodecType() changed values. - PVR_CODEC_TYPE GetCodecType() const { return m_cStructure->codec_type; } - - /// @brief Codec id. - /// - /// Related codec identifier, normally match the ffmpeg id's. - void SetCodecId(unsigned int codecId) { m_cStructure->codec_id = codecId; } - - /// @brief To get with @ref SetCodecId() changed values. - unsigned int GetCodecId() const { return m_cStructure->codec_id; } - ///@} - -private: - PVRCodec(const PVR_CODEC& type) : CStructHdl(&type) {} - PVRCodec(const PVR_CODEC* type) : CStructHdl(type) {} - PVRCodec(PVR_CODEC* type) : CStructHdl(type) {} -}; -///@} -//------------------------------------------------------------------------------ - -//============================================================================== -/// @defgroup cpp_kodi_addon_pvr_Defs_Stream_PVRStreamProperties class PVRStreamProperties -/// @ingroup cpp_kodi_addon_pvr_Defs_Stream -/// @brief **PVR stream properties**\n -/// All information about a respective stream is stored in this, so that Kodi -/// can process the data given by the addon after demux. -/// -/// ---------------------------------------------------------------------------- -/// -/// @copydetails cpp_kodi_addon_pvr_Defs_Stream_PVRStreamProperties_Help -/// -///@{ -class PVRStreamProperties - : public CStructHdl -{ - friend class CInstancePVRClient; - -public: - /*! \cond PRIVATE */ - PVRStreamProperties() { memset(m_cStructure, 0, sizeof(PVR_STREAM_PROPERTIES::PVR_STREAM)); } - PVRStreamProperties(const PVRStreamProperties& type) : CStructHdl(type) {} - /*! \endcond */ - - /// @defgroup cpp_kodi_addon_pvr_Defs_Stream_PVRStreamProperties_Help Value Help - /// @ingroup cpp_kodi_addon_pvr_Defs_Stream_PVRStreamProperties - /// ---------------------------------------------------------------------------- - /// - /// The following table contains values that can be set with @ref cpp_kodi_addon_pvr_Defs_Stream_PVRStreamProperties : - /// | Name | Type | Set call | Get call - /// |------|------|----------|---------- - /// | **PID** | `unsigned int` | @ref PVRStreamProperties::SetPID "SetPID" | @ref PVRStreamProperties::GetPID "GetPID" - /// | **Codec type** | @ref PVR_CODEC_TYPE | @ref PVRStreamProperties::SetCodecType "SetCodecType" | @ref PVRStreamProperties::GetCodecType "GetCodecType" - /// | **Codec identifier** | `unsigned int` | @ref PVRStreamProperties::SetCodecId "SetCodecId" | @ref PVRStreamProperties::GetCodecId "GetCodecId" - /// | **Language** | `std::string` | @ref PVRStreamProperties::SetLanguage "SetLanguage" | @ref PVRStreamProperties::GetLanguage "GetLanguage" - /// | **Subtitle info** | `int` | @ref PVRStreamProperties::SetSubtitleInfo "SetSubtitleInfo" | @ref PVRStreamProperties::GetSubtitleInfo "GetSubtitleInfo" - /// | **FPS scale** | `int` | @ref PVRStreamProperties::SetFPSScale "SetFPSScale" | @ref PVRStreamProperties::GetFPSScale "GetFPSScale" - /// | **FPS rate** | `int` | @ref PVRStreamProperties::SetFPSRate "SetFPSRate" | @ref PVRStreamProperties::GetFPSRate "GetFPSRate" - /// | **Height** | `int` | @ref PVRStreamProperties::SetHeight "SetHeight" | @ref PVRStreamProperties::GetHeight "GetHeight" - /// | **Width** | `int` | @ref PVRStreamProperties::SetWidth "SetWidth" | @ref PVRStreamProperties::GetWidth "GetWidth" - /// | **Aspect ratio** | `float` | @ref PVRStreamProperties::SetAspect "SetAspect" | @ref PVRStreamProperties::GetAspect "GetAspect" - /// | **Channels** | `int` | @ref PVRStreamProperties::SetChannels "SetChannels" | @ref PVRStreamProperties::GetChannels "GetChannels" - /// | **Samplerate** | `int` | @ref PVRStreamProperties::SetSampleRate "SetSampleRate" | @ref PVRStreamProperties::GetSampleRate "GetSampleRate" - /// | **Block align** | `int` | @ref PVRStreamProperties::SetBlockAlign "SetBlockAlign" | @ref PVRStreamProperties::GetBlockAlign "GetBlockAlign" - /// | **Bit rate** | `int` | @ref PVRStreamProperties::SetBitRate "SetBitRate" | @ref PVRStreamProperties::GetBitRate "GetBitRate" - /// | **Bits per sample** | `int` | @ref PVRStreamProperties::SetBitsPerSample "SetBitsPerSample" | @ref PVRStreamProperties::GetBitsPerSample "GetBitsPerSample" - /// - - /// @addtogroup cpp_kodi_addon_pvr_Defs_Stream_PVRStreamProperties - ///@{ - - /// @brief PID. - void SetPID(unsigned int pid) { m_cStructure->iPID = pid; } - - /// @brief To get with @ref SetPID() changed values. - unsigned int GetPID() const { return m_cStructure->iPID; } - - /// @brief Codec type this stream. - void SetCodecType(PVR_CODEC_TYPE codecType) { m_cStructure->iCodecType = codecType; } - - /// @brief To get with @ref SetCodecType() changed values. - PVR_CODEC_TYPE GetCodecType() const { return m_cStructure->iCodecType; } - - /// @brief Codec id of this stream. - void SetCodecId(unsigned int codecId) { m_cStructure->iCodecId = codecId; } - - /// @brief To get with @ref SetCodecId() changed values. - unsigned int GetCodecId() const { return m_cStructure->iCodecId; } - - /// @brief 3 letter language id. - void SetLanguage(const std::string& language) - { - if (language.size() > 3) - { - kodi::Log(ADDON_LOG_ERROR, - "PVRStreamProperties::%s: Language string size '%li' higher as needed 3", __func__, - language.size()); - return; - } - m_cStructure->strLanguage[0] = language[0]; - m_cStructure->strLanguage[1] = language[1]; - m_cStructure->strLanguage[2] = language[2]; - m_cStructure->strLanguage[3] = 0; - } - - /// @brief To get with @ref SetLanguage() changed values. - std::string GetLanguage() const { return m_cStructure->strLanguage; } - - /// @brief Subtitle Info - void SetSubtitleInfo(int subtitleInfo) { m_cStructure->iSubtitleInfo = subtitleInfo; } - - /// @brief To get with @ref SetSubtitleInfo() changed values. - int GetSubtitleInfo() const { return m_cStructure->iSubtitleInfo; } - - /// @brief To set scale of 1000 and a rate of 29970 will result in 29.97 fps. - void SetFPSScale(int fpsScale) { m_cStructure->iFPSScale = fpsScale; } - - /// @brief To get with @ref SetFPSScale() changed values. - int GetFPSScale() const { return m_cStructure->iFPSScale; } - - /// @brief FPS rate - void SetFPSRate(int fpsRate) { m_cStructure->iFPSRate = fpsRate; } - - /// @brief To get with @ref SetFPSRate() changed values. - int GetFPSRate() const { return m_cStructure->iFPSRate; } - - /// @brief Height of the stream reported by the demuxer - void SetHeight(int height) { m_cStructure->iHeight = height; } - - /// @brief To get with @ref SetHeight() changed values. - int GetHeight() const { return m_cStructure->iHeight; } - - /// @brief Width of the stream reported by the demuxer. - void SetWidth(int width) { m_cStructure->iWidth = width; } - - /// @brief To get with @ref SetWidth() changed values. - int GetWidth() const { return m_cStructure->iWidth; } - - /// @brief Display aspect ratio of the stream. - void SetAspect(float aspect) { m_cStructure->fAspect = aspect; } - - /// @brief To get with @ref SetAspect() changed values. - float GetAspect() const { return m_cStructure->fAspect; } - - /// @brief Amount of channels. - void SetChannels(int channels) { m_cStructure->iChannels = channels; } - - /// @brief To get with @ref SetChannels() changed values. - int GetChannels() const { return m_cStructure->iChannels; } - - /// @brief Sample rate. - void SetSampleRate(int sampleRate) { m_cStructure->iSampleRate = sampleRate; } - - /// @brief To get with @ref SetSampleRate() changed values. - int GetSampleRate() const { return m_cStructure->iSampleRate; } - - /// @brief Block alignment - void SetBlockAlign(int blockAlign) { m_cStructure->iBlockAlign = blockAlign; } - - /// @brief To get with @ref SetBlockAlign() changed values. - int GetBlockAlign() const { return m_cStructure->iBlockAlign; } - - /// @brief Bit rate. - void SetBitRate(int bitRate) { m_cStructure->iBitRate = bitRate; } - - /// @brief To get with @ref SetBitRate() changed values. - int GetBitRate() const { return m_cStructure->iBitRate; } - - /// @brief Bits per sample. - void SetBitsPerSample(int bitsPerSample) { m_cStructure->iBitsPerSample = bitsPerSample; } - - /// @brief To get with @ref SetBitsPerSample() changed values. - int GetBitsPerSample() const { return m_cStructure->iBitsPerSample; } - ///@} - -private: - PVRStreamProperties(const PVR_STREAM_PROPERTIES::PVR_STREAM* type) : CStructHdl(type) {} - PVRStreamProperties(PVR_STREAM_PROPERTIES::PVR_STREAM* type) : CStructHdl(type) {} -}; -///@} -//------------------------------------------------------------------------------ - -//============================================================================== -/// @defgroup cpp_kodi_addon_pvr_Defs_Stream_PVRStreamTimes class PVRStreamTimes -/// @ingroup cpp_kodi_addon_pvr_Defs_Stream -/// @brief **Times of playing stream (Live TV and recordings)**\n -/// This class is used to transfer the necessary data when -/// @ref kodi::addon::PVRStreamProperties::GetStreamTimes is called. -/// -/// ---------------------------------------------------------------------------- -/// -/// @copydetails cpp_kodi_addon_pvr_Defs_Stream_PVRStreamTimes_Help -/// -///@{ -class PVRStreamTimes : public CStructHdl -{ - friend class CInstancePVRClient; - -public: - /*! \cond PRIVATE */ - PVRStreamTimes() { memset(m_cStructure, 0, sizeof(PVR_STREAM_TIMES)); } - PVRStreamTimes(const PVRStreamTimes& type) : CStructHdl(type) {} - /*! \endcond */ - - /// @defgroup cpp_kodi_addon_pvr_Defs_Stream_PVRStreamTimes_Help Value Help - /// @ingroup cpp_kodi_addon_pvr_Defs_Stream_PVRStreamTimes - /// ---------------------------------------------------------------------------- - /// - /// The following table contains values that can be set with @ref cpp_kodi_addon_pvr_Defs_Stream_PVRStreamTimes : - /// | Name | Type | Set call | Get call - /// |------|------|----------|---------- - /// | **Start time** | `time_t` | @ref PVRStreamTimes::SetStartTime "SetStartTime" | @ref PVRStreamTimes::GetStartTime "GetStartTime" - /// | **PTS start** | `int64_t` | @ref PVRStreamTimes::SetPTSStart "SetPTSStart" | @ref PVRStreamTimes::GetPTSStart "GetPTSStart" - /// | **PTS begin** | `int64_t` | @ref PVRStreamTimes::SetPTSBegin "SetPTSBegin" | @ref PVRStreamTimes::GetPTSBegin "GetPTSBegin" - /// | **PTS end** | `int64_t` | @ref PVRStreamTimes::SetPTSEnd "SetPTSEnd" | @ref PVRStreamTimes::GetPTSEnd "GetPTSEnd" - /// - - /// @addtogroup cpp_kodi_addon_pvr_Defs_Stream_PVRStreamTimes - ///@{ - - /// @brief For recordings, this must be zero. For Live TV, this is a reference - /// time in units of time_t (UTC) from which time elapsed starts. Ideally start - /// of tv show, but can be any other value. - void SetStartTime(time_t startTime) { m_cStructure->startTime = startTime; } - - /// @brief To get with @ref SetStartTime() changed values. - time_t GetStartTime() const { return m_cStructure->startTime; } - - /// @brief The pts of startTime. - void SetPTSStart(int64_t ptsStart) { m_cStructure->ptsStart = ptsStart; } - - /// @brief To get with @ref SetPTSStart() changed values. - int64_t GetPTSStart() const { return m_cStructure->ptsStart; } - - /// @brief Earliest pts player can seek back. Value is in micro seconds, - /// relative to PTS start. For recordings, this must be zero. For Live TV, this - /// must be zero if not timeshifting and must point to begin of the timeshift - /// buffer, otherwise. - void SetPTSBegin(int64_t ptsBegin) { m_cStructure->ptsBegin = ptsBegin; } - - /// @brief To get with @ref SetPTSBegin() changed values. - int64_t GetPTSBegin() const { return m_cStructure->ptsBegin; } - - /// @brief Latest pts player can seek forward. Value is in micro seconds, - /// relative to PTS start. For recordings, this must be the total length. For - /// Live TV, this must be zero if not timeshifting and must point to end of - /// the timeshift buffer, otherwise. - void SetPTSEnd(int64_t ptsEnd) { m_cStructure->ptsEnd = ptsEnd; } - - /// @brief To get with @ref SetPTSEnd() changed values. - int64_t GetPTSEnd() const { return m_cStructure->ptsEnd; } - ///@} - -private: - PVRStreamTimes(const PVR_STREAM_TIMES* type) : CStructHdl(type) {} - PVRStreamTimes(PVR_STREAM_TIMES* type) : CStructHdl(type) {} -}; -///@} -//------------------------------------------------------------------------------ - -} /* namespace addon */ -} /* namespace kodi */ - -#endif /* __cplusplus */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/CMakeLists.txt index a7dd1d336ba8d..13ddea8d7d6f1 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/CMakeLists.txt +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/CMakeLists.txt @@ -6,7 +6,9 @@ set(HEADERS audio_engine.h filesystem.h general.h + monitor.h network.h + version.h ) if(HEADERS) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/CMakeLists.txt index 52670ebfbd36b..81a13a11be347 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/CMakeLists.txt +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/CMakeLists.txt @@ -11,8 +11,9 @@ set(HEADERS pvr.h screensaver.h vfs.h - video_codec.h + videocodec.h visualization.h + web.h ) if(HEADERS) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/audiodecoder.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/audiodecoder.h index 6eb5520792236..fba322af6249f 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/audiodecoder.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/audiodecoder.h @@ -45,10 +45,12 @@ extern "C" { #endif /* __cplusplus */ - typedef void* KODI_ADDON_AUDIODECODER_HDL; +#if __KODI_API__ >= 1 + + typedef KODI_ADDON_INSTANCE_HDL KODI_ADDON_AUDIODECODER_HDL; //============================================================================ - /// @defgroup cpp_kodi_addon_audiodecoder_Defs_AUDIODECODER_READ_RETURN enum AUDIODECODER_READ_RETURN + /// @defgroup cpp_kodi_addon_audiodecoder_Defs_KODI_ADDON_AUDIODECODER_READ_RETURN enum KODI_ADDON_AUDIODECODER_READ_RETURN /// @ingroup cpp_kodi_addon_audiodecoder_Defs /// @brief **Return value about** @ref kodi::addon::CInstanceAudioDecoder::ReadPCM() /// @@ -60,7 +62,7 @@ extern "C" /// | 1 | @ref AUDIODECODER_READ_ERROR | on failure /// ///@{ - typedef enum AUDIODECODER_READ_RETURN + typedef enum KODI_ADDON_AUDIODECODER_READ_RETURN { /// @brief On end of stream AUDIODECODER_READ_EOF = -1, @@ -70,7 +72,7 @@ extern "C" /// @brief On failure AUDIODECODER_READ_ERROR = 1 - } AUDIODECODER_READ_RETURN; + } KODI_ADDON_AUDIODECODER_READ_RETURN; ///@} //---------------------------------------------------------------------------- @@ -123,26 +125,19 @@ extern "C" typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_TRACK_COUNT_V1)( const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file); - typedef struct AddonToKodiFuncTable_AudioDecoder - { - KODI_HANDLE kodiInstance; - } AddonToKodiFuncTable_AudioDecoder; - - typedef struct KodiToAddonFuncTable_AudioDecoder + typedef struct KODI_ADDON_AUDIODECODER_FUNC { + PFN_KODI_ADDON_INSTANCE_CREATE_V1 create; + PFN_KODI_ADDON_INSTANCE_DESTROY_V1 destroy; PFN_KODI_ADDON_AUDIODECODER_SUPPORTS_FILE_V1 supports_file; PFN_KODI_ADDON_AUDIODECODER_INIT_V1 init; PFN_KODI_ADDON_AUDIODECODER_READ_PCM_V1 read_pcm; PFN_KODI_ADDON_AUDIODECODER_SEEK_V1 seek; PFN_KODI_ADDON_AUDIODECODER_READ_TAG_V1 read_tag; PFN_KODI_ADDON_AUDIODECODER_TRACK_COUNT_V1 track_count; - } KodiToAddonFuncTable_AudioDecoder; + } KODI_ADDON_AUDIODECODER_FUNC; - typedef struct AddonInstance_AudioDecoder - { - struct AddonToKodiFuncTable_AudioDecoder* toKodi; - struct KodiToAddonFuncTable_AudioDecoder* toAddon; - } AddonInstance_AudioDecoder; +#endif /* __KODI_API__ >= 1 */ #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/audioencoder.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/audioencoder.h index d00ced6e736eb..1ff269f960d68 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/audioencoder.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/audioencoder.h @@ -6,17 +6,21 @@ * See LICENSES/README.md for more information. */ -#ifndef C_API_ADDONINSTANCE_AUDIO_ENCODER_H -#define C_API_ADDONINSTANCE_AUDIO_ENCODER_H +#ifndef C_API_ADDONINSTANCE_AUDIOENCODER_H +#define C_API_ADDONINSTANCE_AUDIOENCODER_H #include "../addon_base.h" +#include + #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef void* KODI_ADDON_AUDIOENCODER_HDL; +#if __KODI_API__ >= 1 + + typedef KODI_ADDON_INSTANCE_HDL KODI_ADDON_AUDIOENCODER_HDL; struct KODI_ADDON_AUDIOENCODER_INFO_TAG { @@ -47,28 +51,26 @@ extern "C" typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIOENCODER_FINISH_V1)( KODI_ADDON_AUDIOENCODER_HDL hdl); - typedef struct AddonToKodiFuncTable_AudioEncoder - { - KODI_HANDLE kodiInstance; - ssize_t (*write)(KODI_HANDLE kodiInstance, const uint8_t* data, size_t len); - ssize_t (*seek)(KODI_HANDLE kodiInstance, ssize_t pos, int whence); - } AddonToKodiFuncTable_AudioEncoder; - - typedef struct KodiToAddonFuncTable_AudioEncoder + typedef struct KODI_ADDON_AUDIOENCODER_FUNC { + PFN_KODI_ADDON_INSTANCE_CREATE_V1 create; + PFN_KODI_ADDON_INSTANCE_DESTROY_V1 destroy; PFN_KODI_ADDON_AUDIOENCODER_START_V1 start; PFN_KODI_ADDON_AUDIOENCODER_ENCODE_V1 encode; PFN_KODI_ADDON_AUDIOENCODER_FINISH_V1 finish; - } KodiToAddonFuncTable_AudioEncoder; + } KODI_ADDON_AUDIOENCODER_FUNC; - typedef struct AddonInstance_AudioEncoder - { - struct AddonToKodiFuncTable_AudioEncoder* toKodi; - struct KodiToAddonFuncTable_AudioEncoder* toAddon; - } AddonInstance_AudioEncoder; + ATTR_DLL_EXPORT ssize_t kodi_addon_audioencoder_write(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const uint8_t* data, + size_t len) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT ssize_t kodi_addon_audioencoder_seek(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + ssize_t pos, + int whence) __INTRODUCED_IN_KODI(1); + +#endif /* __KODI_API__ >= 1 */ #ifdef __cplusplus } /* extern "C" */ #endif /* __cplusplus */ -#endif /* !C_API_ADDONINSTANCE_AUDIO_ENCODER_H */ +#endif /* !C_API_ADDONINSTANCE_AUDIOENCODER_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/game.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/game.h index e0bbf94664677..3c602e1b2d043 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/game.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/game.h @@ -1,17 +1,20 @@ /* - * Copyright (C) 2014-2020 Team Kodi + * Copyright (C) 2005-2018 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later * See LICENSES/README.md for more information. */ +/*---AUTO_GEN_PARSE---*/ + #ifndef C_API_ADDONINSTANCE_GAME_H #define C_API_ADDONINSTANCE_GAME_H #include "../addon_base.h" -#include /* size_t */ +#include +#include //============================================================================== /// @ingroup cpp_kodi_addon_game_Defs @@ -24,526 +27,200 @@ extern "C" { #endif /* __cplusplus */ - //============================================================================ - /// @ingroup cpp_kodi_addon_game_Defs - /// @brief **Game add-on error codes** - /// - /// Used as return values on most Game related functions. - /// + typedef void* KODI_ADDON_GAME_HDL; + typedef enum GAME_ERROR { - /// @brief no error occurred GAME_ERROR_NO_ERROR, - - /// @brief an unknown error occurred GAME_ERROR_UNKNOWN, - - /// @brief the method that the frontend called is not implemented GAME_ERROR_NOT_IMPLEMENTED, - - /// @brief the command was rejected by the game client GAME_ERROR_REJECTED, - - /// @brief the parameters of the method that was called are invalid for this operation GAME_ERROR_INVALID_PARAMETERS, - - /// @brief the command failed GAME_ERROR_FAILED, - - /// @brief no game is loaded GAME_ERROR_NOT_LOADED, - - /// @brief game requires restricted resources GAME_ERROR_RESTRICTED, } GAME_ERROR; - //---------------------------------------------------------------------------- - - //--==----==----==----==----==----==----==----==----==----==----==----==----==-- - /// @defgroup cpp_kodi_addon_game_Defs_AudioStream 1. Audio stream - /// @ingroup cpp_kodi_addon_game_Defs - /// @brief **The for Audio stream used data system** - /// - /// Used to give Addon currently used audio stream configuration on Kodi and - /// arrays to give related data to Kodi on callbacks. - /// - ///@{ - //============================================================================ - /// @brief **Stream Format** - /// - /// From Kodi requested specified audio sample format. - /// typedef enum GAME_PCM_FORMAT { GAME_PCM_FORMAT_UNKNOWN, - - /// @brief S16NE sample format GAME_PCM_FORMAT_S16NE, } GAME_PCM_FORMAT; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Audio channel** - /// - /// Channel identification flags. - /// typedef enum GAME_AUDIO_CHANNEL { - /// @brief Channel list terminator GAME_CH_NULL, - - /// @brief Channel front left GAME_CH_FL, - - /// @brief Channel front right GAME_CH_FR, - - /// @brief Channel front center GAME_CH_FC, - - /// @brief Channel Low Frequency Effects / Subwoofer GAME_CH_LFE, - - /// @brief Channel back left GAME_CH_BL, - - /// @brief Channel back right GAME_CH_BR, - - /// @brief Channel front left over center GAME_CH_FLOC, - - /// @brief Channel front right over center GAME_CH_FROC, - - /// @brief Channel back center GAME_CH_BC, - - /// @brief Channel surround/side left GAME_CH_SL, - - /// @brief Channel surround/side right GAME_CH_SR, - - /// @brief Channel top front left GAME_CH_TFL, - - /// @brief Channel top front right GAME_CH_TFR, - - /// @brief Channel top front center GAME_CH_TFC, - - /// @brief Channel top center GAME_CH_TC, - - /// @brief Channel top back left GAME_CH_TBL, - - /// @brief Channel top back right GAME_CH_TBR, - - /// @brief Channel top back center GAME_CH_TBC, - - /// @brief Channel bacl left over center GAME_CH_BLOC, - - /// @brief Channel back right over center GAME_CH_BROC, } GAME_AUDIO_CHANNEL; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Game audio stream properties** - /// - /// Used by Kodi to pass the currently required audio stream settings to the addon - /// typedef struct game_stream_audio_properties { - GAME_PCM_FORMAT format; - const GAME_AUDIO_CHANNEL* channel_map; - } ATTR_PACKED game_stream_audio_properties; + enum GAME_PCM_FORMAT format; + const enum GAME_AUDIO_CHANNEL* channel_map; + } game_stream_audio_properties; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Audio stream packet** - /// - /// This packet contains audio stream data passed to Kodi. - /// typedef struct game_stream_audio_packet { - /// @brief Pointer for audio stream data given to Kodi const uint8_t* data; - - /// @brief Size of data array size_t size; - } ATTR_PACKED game_stream_audio_packet; + } game_stream_audio_packet; //---------------------------------------------------------------------------- ///@} - //--==----==----==----==----==----==----==----==----==----==----==----==----==-- - /// @defgroup cpp_kodi_addon_game_Defs_VideoStream 2. Video stream - /// @ingroup cpp_kodi_addon_game_Defs - /// @brief **The for Video stream used data system** - /// - /// Used to give Addon currently used video stream configuration on Kodi and - /// arrays to give related data to Kodi on callbacks. - /// - ///@{ - - //============================================================================ - /// @brief **Pixel format** - /// - /// From Kodi requested specified video RGB color model format. - /// typedef enum GAME_PIXEL_FORMAT { GAME_PIXEL_FORMAT_UNKNOWN, - - /// @brief 0RGB8888 Format GAME_PIXEL_FORMAT_0RGB8888, - - /// @brief RGB565 Format GAME_PIXEL_FORMAT_RGB565, - - /// @brief 0RGB1555 Format GAME_PIXEL_FORMAT_0RGB1555, } GAME_PIXEL_FORMAT; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Video rotation position** - /// - /// To define position how video becomes shown. - /// typedef enum GAME_VIDEO_ROTATION { - /// @brief 0° and Without rotation GAME_VIDEO_ROTATION_0, - - /// @brief rotate 90° counterclockwise GAME_VIDEO_ROTATION_90_CCW, - - /// @brief rotate 180° counterclockwise GAME_VIDEO_ROTATION_180_CCW, - - /// @brief rotate 270° counterclockwise GAME_VIDEO_ROTATION_270_CCW, } GAME_VIDEO_ROTATION; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Game video stream properties** - /// - /// Used by Kodi to pass the currently required video stream settings to the addon - /// typedef struct game_stream_video_properties { - /// @brief The stream's pixel format - GAME_PIXEL_FORMAT format; - - /// @brief The nominal used width + enum GAME_PIXEL_FORMAT format; unsigned int nominal_width; - - /// @brief The nominal used height unsigned int nominal_height; - - /// @brief The maximal used width unsigned int max_width; - - /// @brief The maximal used height unsigned int max_height; - - /// @brief On video stream used aspect ration - /// - /// @note If aspect_ratio is <= 0.0, an aspect ratio of nominal_width / nominal_height is assumed float aspect_ratio; - } ATTR_PACKED game_stream_video_properties; + } game_stream_video_properties; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Video stream packet** - /// - /// This packet contains video stream data passed to Kodi. - /// typedef struct game_stream_video_packet { - /// @brief Video height unsigned int width; - - /// @brief Video width unsigned int height; - - /// @brief Width @ref GAME_VIDEO_ROTATION defined rotation angle. - GAME_VIDEO_ROTATION rotation; - - /// @brief Pointer for video stream data given to Kodi + enum GAME_VIDEO_ROTATION rotation; const uint8_t* data; - - /// @brief Size of data array size_t size; - } ATTR_PACKED game_stream_video_packet; + } game_stream_video_packet; //---------------------------------------------------------------------------- ///@} - //--==----==----==----==----==----==----==----==----==----==----==----==----==-- - /// @defgroup cpp_kodi_addon_game_Defs_HardwareFramebuffer 3. Hardware framebuffer stream - /// @ingroup cpp_kodi_addon_game_Defs - /// @brief **Hardware framebuffer stream data** - /// - ///@{ - - //============================================================================ - /// @brief **Hardware framebuffer type** - /// typedef enum GAME_HW_CONTEXT_TYPE { - /// @brief None context GAME_HW_CONTEXT_NONE, - - /// @brief OpenGL 2.x. Driver can choose to use latest compatibility context GAME_HW_CONTEXT_OPENGL, - - /// @brief OpenGL ES 2.0 GAME_HW_CONTEXT_OPENGLES2, - - /// @brief Modern desktop core GL context. Use major/minor fields to set GL version GAME_HW_CONTEXT_OPENGL_CORE, - - /// @brief OpenGL ES 3.0 GAME_HW_CONTEXT_OPENGLES3, - - /// @brief OpenGL ES 3.1+. Set major/minor fields. GAME_HW_CONTEXT_OPENGLES_VERSION, - - /// @brief Vulkan GAME_HW_CONTEXT_VULKAN } GAME_HW_CONTEXT_TYPE; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Hardware framebuffer properties** - /// typedef struct game_stream_hw_framebuffer_properties { - /// @brief The API to use. - /// - GAME_HW_CONTEXT_TYPE context_type; - - /// @brief Set if render buffers should have depth component attached. - /// - /// @todo: Obsolete - /// + enum GAME_HW_CONTEXT_TYPE context_type; bool depth; - - /// @brief Set if stencil buffers should be attached. - /// - /// If depth and stencil are true, a packed 24/8 buffer will be added. - /// Only attaching stencil is invalid and will be ignored. - /// - /// @todo: Obsolete. - /// bool stencil; - - /// @brief Use conventional bottom-left origin convention. - /// - /// If false, standard top-left origin semantics are used. - /// - /// @todo: Move to GL specific interface - /// bool bottom_left_origin; - - /// @brief Major version number for core GL context or GLES 3.1+. unsigned int version_major; - - /// @brief Minor version number for core GL context or GLES 3.1+. unsigned int version_minor; - - /// @brief If this is true, the frontend will go very far to avoid resetting context - /// in scenarios like toggling fullscreen, etc. - /// - /// @todo: Obsolete? Maybe frontend should just always assume this... - /// - /// The reset callback might still be called in extreme situations such as if - /// the context is lost beyond recovery. - /// - /// For optimal stability, set this to false, and allow context to be reset at - /// any time. - /// bool cache_context; - - /// @brief Creates a debug context. bool debug_context; - } ATTR_PACKED game_stream_hw_framebuffer_properties; + } game_stream_hw_framebuffer_properties; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Hardware framebuffer buffer** - /// typedef struct game_stream_hw_framebuffer_buffer { - /// @brief uintptr_t framebuffer; - } ATTR_PACKED game_stream_hw_framebuffer_buffer; + } game_stream_hw_framebuffer_buffer; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Hardware framebuffer packet** - /// typedef struct game_stream_hw_framebuffer_packet { - /// @brief uintptr_t framebuffer; - } ATTR_PACKED game_stream_hw_framebuffer_packet; + } game_stream_hw_framebuffer_packet; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Hardware framebuffer process function address** - /// typedef void (*game_proc_address_t)(void); - //---------------------------------------------------------------------------- - ///@} - - //--==----==----==----==----==----==----==----==----==----==----==----==----==-- - /// @defgroup cpp_kodi_addon_game_Defs_SoftwareFramebuffer 4. Software framebuffer stream - /// @ingroup cpp_kodi_addon_game_Defs - /// @brief **Software framebuffer stream data** - /// - ///@{ - - //============================================================================ - /// @brief **Game video stream properties** - /// - /// Used by Kodi to pass the currently required video stream settings to the addon - /// typedef game_stream_video_properties game_stream_sw_framebuffer_properties; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Hardware framebuffer type** - /// typedef struct game_stream_sw_framebuffer_buffer { - GAME_PIXEL_FORMAT format; + enum GAME_PIXEL_FORMAT format; uint8_t* data; size_t size; - } ATTR_PACKED game_stream_sw_framebuffer_buffer; + } game_stream_sw_framebuffer_buffer; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Video stream packet** - /// - /// This packet contains video stream data passed to Kodi. - /// typedef game_stream_video_packet game_stream_sw_framebuffer_packet; - //---------------------------------------------------------------------------- - - ///@} - - //--==----==----==----==----==----==----==----==----==----==----==----==----==-- - /// @defgroup cpp_kodi_addon_game_Defs_StreamTypes 5. Stream types - /// @ingroup cpp_kodi_addon_game_Defs - /// @brief **Stream types data** - /// - ///@{ - //============================================================================ - /// @brief **Game stream types** - /// typedef enum GAME_STREAM_TYPE { - /// @brief Unknown GAME_STREAM_UNKNOWN, - - /// @brief Audio stream GAME_STREAM_AUDIO, - - /// @brief Video stream GAME_STREAM_VIDEO, - - /// @brief Hardware framebuffer GAME_STREAM_HW_FRAMEBUFFER, - - /// @brief Software framebuffer GAME_STREAM_SW_FRAMEBUFFER, } GAME_STREAM_TYPE; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Immutable stream metadata** - /// - /// This metadata is provided when the stream is opened. If any stream - /// properties change, a new stream must be opened. - /// typedef struct game_stream_properties { - /// @brief - GAME_STREAM_TYPE type; + enum GAME_STREAM_TYPE type; union { - /// @brief game_stream_audio_properties audio; - - /// @brief game_stream_video_properties video; - - /// @brief game_stream_hw_framebuffer_properties hw_framebuffer; - - /// @brief game_stream_sw_framebuffer_properties sw_framebuffer; }; - } ATTR_PACKED game_stream_properties; + } game_stream_properties; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Stream buffers for hardware rendering and zero-copy support** - /// typedef struct game_stream_buffer { - /// @brief GAME_STREAM_TYPE type; union { - /// @brief game_stream_hw_framebuffer_buffer hw_framebuffer; - - /// @brief game_stream_sw_framebuffer_buffer sw_framebuffer; }; - } ATTR_PACKED game_stream_buffer; + } game_stream_buffer; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Stream packet and ephemeral metadata** - /// - /// This packet contains stream data and accompanying metadata. The metadata - /// is ephemeral, meaning it only applies to the current packet and can change - /// from packet to packet in the same stream. - /// typedef struct game_stream_packet { - /// @brief GAME_STREAM_TYPE type; union { - /// @brief game_stream_audio_packet audio; - - /// @brief game_stream_video_packet video; - - /// @brief game_stream_hw_framebuffer_packet hw_framebuffer; - - /// @brief game_stream_sw_framebuffer_packet sw_framebuffer; }; - } ATTR_PACKED game_stream_packet; + } game_stream_packet; //---------------------------------------------------------------------------- ///@} @@ -555,240 +232,88 @@ extern "C" /// ///@{ - //============================================================================ - /// @brief **Game reguin definition** - /// - /// Returned from game_get_region() typedef enum GAME_REGION { - /// @brief Game region unknown GAME_REGION_UNKNOWN, - - /// @brief Game region NTSC GAME_REGION_NTSC, - - /// @brief Game region PAL GAME_REGION_PAL, } GAME_REGION; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Special game types passed into game_load_game_special().** - /// - /// @remark Only used when multiple ROMs are required. - /// typedef enum SPECIAL_GAME_TYPE { - /// @brief Game Type BSX SPECIAL_GAME_TYPE_BSX, - - /// @brief Game Type BSX slotted SPECIAL_GAME_TYPE_BSX_SLOTTED, - - /// @brief Game Type sufami turbo SPECIAL_GAME_TYPE_SUFAMI_TURBO, - - /// @brief Game Type super game boy SPECIAL_GAME_TYPE_SUPER_GAME_BOY, } SPECIAL_GAME_TYPE; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **Game Memory** - /// typedef enum GAME_MEMORY { - /// @brief Passed to game_get_memory_data/size(). If the memory type doesn't apply - /// to the implementation NULL/0 can be returned. GAME_MEMORY_MASK = 0xff, - - /// @brief Regular save ram. - /// - /// This ram is usually found on a game cartridge, backed - /// up by a battery. If save game data is too complex for a single memory - /// buffer, the SYSTEM_DIRECTORY environment callback can be used. GAME_MEMORY_SAVE_RAM = 0, - - /// @brief Some games have a built-in clock to keep track of time. - /// - /// This memory is usually just a couple of bytes to keep track of time. GAME_MEMORY_RTC = 1, - - /// @brief System ram lets a frontend peek into a game systems main RAM GAME_MEMORY_SYSTEM_RAM = 2, - - /// @brief Video ram lets a frontend peek into a game systems video RAM (VRAM) GAME_MEMORY_VIDEO_RAM = 3, - - /// @brief Special memory type GAME_MEMORY_SNES_BSX_RAM = ((1 << 8) | GAME_MEMORY_SAVE_RAM), - - /// @brief Special memory type GAME_MEMORY_SNES_BSX_PRAM = ((2 << 8) | GAME_MEMORY_SAVE_RAM), - - /// @brief Special memory type GAME_MEMORY_SNES_SUFAMI_TURBO_A_RAM = ((3 << 8) | GAME_MEMORY_SAVE_RAM), - - /// @brief Special memory type GAME_MEMORY_SNES_SUFAMI_TURBO_B_RAM = ((4 << 8) | GAME_MEMORY_SAVE_RAM), - - /// @brief Special memory type GAME_MEMORY_SNES_GAME_BOY_RAM = ((5 << 8) | GAME_MEMORY_SAVE_RAM), - - /// @brief Special memory type GAME_MEMORY_SNES_GAME_BOY_RTC = ((6 << 8) | GAME_MEMORY_RTC), } GAME_MEMORY; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief **ID values for SIMD CPU features** typedef enum GAME_SIMD { - /// @brief SIMD CPU SSE GAME_SIMD_SSE = (1 << 0), - - /// @brief SIMD CPU SSE2 GAME_SIMD_SSE2 = (1 << 1), - - /// @brief SIMD CPU VMX GAME_SIMD_VMX = (1 << 2), - - /// @brief SIMD CPU VMX128 GAME_SIMD_VMX128 = (1 << 3), - - /// @brief SIMD CPU AVX GAME_SIMD_AVX = (1 << 4), - - /// @brief SIMD CPU NEON GAME_SIMD_NEON = (1 << 5), - - /// @brief SIMD CPU SSE3 GAME_SIMD_SSE3 = (1 << 6), - - /// @brief SIMD CPU SSSE3 GAME_SIMD_SSSE3 = (1 << 7), - - /// @brief SIMD CPU MMX GAME_SIMD_MMX = (1 << 8), - - /// @brief SIMD CPU MMXEXT GAME_SIMD_MMXEXT = (1 << 9), - - /// @brief SIMD CPU SSE4 GAME_SIMD_SSE4 = (1 << 10), - - /// @brief SIMD CPU SSE42 GAME_SIMD_SSE42 = (1 << 11), - - /// @brief SIMD CPU AVX2 GAME_SIMD_AVX2 = (1 << 12), - - /// @brief SIMD CPU VFPU GAME_SIMD_VFPU = (1 << 13), } GAME_SIMD; - //---------------------------------------------------------------------------- - - ///@} - - //--==----==----==----==----==----==----==----==----==----==----==----==----==-- - /// @defgroup cpp_kodi_addon_game_Defs_InputTypes 7. Input types - /// @ingroup cpp_kodi_addon_game_Defs - /// @brief **Input types** - /// - ///@{ - //============================================================================ - /// @brief typedef enum GAME_INPUT_EVENT_SOURCE { - /// @brief GAME_INPUT_EVENT_DIGITAL_BUTTON, - - /// @brief GAME_INPUT_EVENT_ANALOG_BUTTON, - - /// @brief GAME_INPUT_EVENT_AXIS, - - /// @brief GAME_INPUT_EVENT_ANALOG_STICK, - - /// @brief GAME_INPUT_EVENT_ACCELEROMETER, - - /// @brief GAME_INPUT_EVENT_KEY, - - /// @brief GAME_INPUT_EVENT_RELATIVE_POINTER, - - /// @brief GAME_INPUT_EVENT_ABSOLUTE_POINTER, - - /// @brief GAME_INPUT_EVENT_MOTOR, } GAME_INPUT_EVENT_SOURCE; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief typedef enum GAME_KEY_MOD { - /// @brief GAME_KEY_MOD_NONE = 0x0000, - - /// @brief GAME_KEY_MOD_SHIFT = 0x0001, - - /// @brief GAME_KEY_MOD_CTRL = 0x0002, - - /// @brief GAME_KEY_MOD_ALT = 0x0004, - - /// @brief GAME_KEY_MOD_META = 0x0008, - - /// @brief GAME_KEY_MOD_SUPER = 0x0010, - - /// @brief GAME_KEY_MOD_NUMLOCK = 0x0100, - - /// @brief GAME_KEY_MOD_CAPSLOCK = 0x0200, - - /// @brief GAME_KEY_MOD_SCROLLOCK = 0x0400, } GAME_KEY_MOD; - //---------------------------------------------------------------------------- - //============================================================================ - /// @brief Type of port on the virtual game console typedef enum GAME_PORT_TYPE { - /// @brief Game port unknown GAME_PORT_UNKNOWN, - - /// @brief Game port Keyboard GAME_PORT_KEYBOARD, - - /// @brief Game port mouse GAME_PORT_MOUSE, - - /// @brief Game port controller GAME_PORT_CONTROLLER, } GAME_PORT_TYPE; - //---------------------------------------------------------------------------- - /*! @cond PRIVATE */ - /*! - * @brief "C" Game add-on controller layout. - * - * Structure used to interface in "C" between Kodi and Addon. - * - * See @ref AddonGameControllerLayout for description of values. - */ typedef struct game_controller_layout { char* controller_id; @@ -809,42 +334,23 @@ extern "C" unsigned int abs_pointer_count; char** motors; unsigned int motor_count; - } ATTR_PACKED game_controller_layout; + } game_controller_layout; /*! @endcond */ struct game_input_port; - //============================================================================ - /// @brief Device that can provide input typedef struct game_input_device { - /// @brief ID used in the Kodi controller API const char* controller_id; - - /// @brief const char* port_address; - - /// @brief struct game_input_port* available_ports; - - /// @brief unsigned int port_count; - } ATTR_PACKED game_input_device; + } game_input_device; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief Port that can provide input - /// - /// Ports can accept multiple devices and devices can have multiple ports, so - /// the topology of possible configurations is a tree structure of alternating - /// port and device nodes. - /// typedef struct game_input_port { - /// @brief - GAME_PORT_TYPE type; - - /// @brief Required for GAME_PORT_CONTROLLER type + enum GAME_PORT_TYPE type; const char* port_id; /// @brief Flag to prevent a port from being disconnected @@ -855,190 +361,107 @@ extern "C" bool force_connected; /// @brief - game_input_device* accepted_devices; + struct game_input_device* accepted_devices; /// @brief unsigned int device_count; - } ATTR_PACKED game_input_port; + } game_input_port; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief The input topology is the possible ways to connect input devices - /// - /// This represents the logical topology, which is the possible connections that - /// the game client's logic can handle. It is strictly a subset of the physical - /// topology. Loops are not allowed. - /// typedef struct game_input_topology { - /// @brief The list of ports on the virtual game console - game_input_port* ports; - - /// @brief The number of ports + struct game_input_port* ports; unsigned int port_count; - - /// @brief A limit on the number of input-providing devices, or -1 for no limit int player_limit; - } ATTR_PACKED game_input_topology; + } game_input_topology; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief typedef struct game_digital_button_event { - /// @brief bool pressed; - } ATTR_PACKED game_digital_button_event; + } game_digital_button_event; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief typedef struct game_analog_button_event { - /// @brief float magnitude; - } ATTR_PACKED game_analog_button_event; + } game_analog_button_event; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief typedef struct game_axis_event { /// @brief float position; - } ATTR_PACKED game_axis_event; + } game_axis_event; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief typedef struct game_analog_stick_event { - /// @brief float x; - - /// @brief float y; - } ATTR_PACKED game_analog_stick_event; + } game_analog_stick_event; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief typedef struct game_accelerometer_event { - /// @brief float x; - - /// @brief float y; - - /// @brief float z; - } ATTR_PACKED game_accelerometer_event; + } game_accelerometer_event; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief typedef struct game_key_event { - /// @brief bool pressed; - - /// @brief If the keypress generates a printing character - /// - /// The unicode value contains the character generated. If the key is a - /// non-printing character, e.g. a function or arrow key, the unicode value - /// is zero. uint32_t unicode; - /// @brief - GAME_KEY_MOD modifiers; - } ATTR_PACKED game_key_event; + enum GAME_KEY_MOD modifiers; + } game_key_event; //---------------------------------------------------------------------------- //============================================================================ /// @brief typedef struct game_rel_pointer_event { - /// @brief int x; - - /// @brief int y; - } ATTR_PACKED game_rel_pointer_event; + } game_rel_pointer_event; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief typedef struct game_abs_pointer_event { - /// @brief bool pressed; - - /// @brief float x; - - /// @brief float y; - } ATTR_PACKED game_abs_pointer_event; + } game_abs_pointer_event; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief typedef struct game_motor_event { - /// @brief float magnitude; - } ATTR_PACKED game_motor_event; + } game_motor_event; //---------------------------------------------------------------------------- - //============================================================================ - /// @brief typedef struct game_input_event { - /// @brief - GAME_INPUT_EVENT_SOURCE type; - - /// @brief + enum GAME_INPUT_EVENT_SOURCE type; const char* controller_id; - - /// @brief - GAME_PORT_TYPE port_type; - - /// @brief + enum GAME_PORT_TYPE port_type; const char* port_address; - - /// @brief const char* feature_name; union { - /// @brief struct game_digital_button_event digital_button; - - /// @brief struct game_analog_button_event analog_button; - - /// @brief struct game_axis_event axis; - - /// @brief struct game_analog_stick_event analog_stick; - - /// @brief struct game_accelerometer_event accelerometer; - - /// @brief struct game_key_event key; - - /// @brief struct game_rel_pointer_event rel_pointer; - - /// @brief struct game_abs_pointer_event abs_pointer; - - /// @brief struct game_motor_event motor; }; - } ATTR_PACKED game_input_event; + } game_input_event; //---------------------------------------------------------------------------- ///@} @@ -1050,186 +473,173 @@ extern "C" /// ///@{ - //============================================================================ - /// @brief Game system timing - /// struct game_system_timing { - /// @brief FPS of video content. double fps; - - /// @brief Sampling rate of audio. double sample_rate; }; - //---------------------------------------------------------------------------- - - ///@} - - //--==----==----==----==----==----==----==----==----==----==----==----==----==-- - - /*! - * @brief Game properties - * - * Not to be used outside this header. - */ - typedef struct AddonProps_Game + struct GAME_PROPS { - /*! - * The path of the game client being loaded. - */ const char* game_client_dll_path; - - /*! - * Paths to proxy DLLs used to load the game client. - */ const char** proxy_dll_paths; - - /*! - * Number of proxy DLL paths provided. - */ unsigned int proxy_dll_count; - - /*! - * The "system" directories of the frontend. These directories can be used to - * store system-specific ROMs such as BIOSes, configuration data, etc. - */ const char** resource_directories; - - /*! - * Number of resource directories provided - */ unsigned int resource_directory_count; - - /*! - * The writable directory of the frontend. This directory can be used to store - * SRAM, memory cards, high scores, etc, if the game client cannot use the - * regular memory interface, GetMemoryData(). - */ const char* profile_directory; - - /*! - * The value of the property from addon.xml - */ bool supports_vfs; - - /*! - * The extensions in the property from addon.xml - */ const char** extensions; - - /*! - * Number of extensions provided - */ unsigned int extension_count; - } AddonProps_Game; - - typedef void* KODI_GAME_STREAM_HANDLE; + }; - /*! Structure to transfer the methods from kodi_game_dll.h to Kodi */ + typedef KODI_ADDON_GAME_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_CREATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_DESTROY_V1)(KODI_ADDON_GAME_HDL hdl); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_LOAD_GAME_V1)( + const KODI_ADDON_GAME_HDL hdl, const char* url); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_LOAD_GAME_SPECIAL_V1)( + const KODI_ADDON_GAME_HDL hdl, + enum SPECIAL_GAME_TYPE type, + const char** urls, + size_t urlCount); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_LOAD_STANDALONE_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_UNLOAD_GAME_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_GET_GAME_TIMING_V1)( + const KODI_ADDON_GAME_HDL hdl, struct game_system_timing* timing_info); + typedef enum GAME_REGION(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_GET_REGION_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_REQUIRES_GAME_LOOP_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RUN_FRAME_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RESET_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_HW_CONTEXT_RESET_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_HW_CONTEXT_DESTROY_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_HAS_FEATURE_V1)(const KODI_ADDON_GAME_HDL hdl, + const char* controller_id, + const char* feature_name); + typedef struct game_input_topology*(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_GET_TOPOLOGY_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_FREE_TOPOLOGY_V1)( + const KODI_ADDON_GAME_HDL hdl, struct game_input_topology* topology); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_SET_CONTROLLER_LAYOUTS_V1)( + const KODI_ADDON_GAME_HDL hdl, + const struct game_controller_layout* controllers, + size_t controller_count); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_ENABLE_KEYBOARD_V1)(const KODI_ADDON_GAME_HDL hdl, + bool enable, + const char* controller_id); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_ENABLE_MOUSE_V1)(const KODI_ADDON_GAME_HDL hdl, + bool enable, + const char* controller_id); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_CONNECT_CONTROLLER_V1)( + const KODI_ADDON_GAME_HDL hdl, + bool connect, + const char* port_address, + const char* controller_id); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_INPUT_EVENT_V1)( + const KODI_ADDON_GAME_HDL hdl, const struct game_input_event* event); + typedef size_t(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_SERIALIZE_SIZE_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_SERIALIZE_V1)( + const KODI_ADDON_GAME_HDL hdl, uint8_t* data, size_t size); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_DESERIALIZE_V1)( + const KODI_ADDON_GAME_HDL hdl, const uint8_t* data, size_t size); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_CHEAT_RESET_V1)( + const KODI_ADDON_GAME_HDL hdl); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_GET_MEMORY_V1)( + const KODI_ADDON_GAME_HDL hdl, enum GAME_MEMORY type, uint8_t** data, size_t* size); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_SET_CHEAT_V1)( + const KODI_ADDON_GAME_HDL hdl, unsigned int index, bool enabled, const char* code); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_GENERATE_HASH_FROM_FILE_V1)(const KODI_ADDON_GAME_HDL hdl, char** hash, unsigned int console_id, const char* file_path); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_GET_GAME_ID_URL_V1)(const KODI_ADDON_GAME_HDL hdl, char** url, const char* hash); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_GET_PATCH_FILE_URL_V1)(const KODI_ADDON_GAME_HDL hdl, char** url, const char* username, const char* token, unsigned int game_id); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_POST_RICH_PRESENCE_URL_V1)(const KODI_ADDON_GAME_HDL hdl, + char** url, + char** post_data, + const char* username, + const char* token, + unsigned int game_id, + const char* rich_presence); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_ENABLE_RICH_PRESENCE_V1)(const KODI_ADDON_GAME_HDL hdl, const char* script); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_GET_RICH_PRESENCE_EVALUATION_V1)(const KODI_ADDON_GAME_HDL hdl, char** evaluation, unsigned int console_id); + typedef enum GAME_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_GAME_RC_RESET_RUNTIME_V1)(const KODI_ADDON_GAME_HDL hdl); + + typedef struct KODI_ADDON_GAME_FUNC + { + PFN_KODI_ADDON_GAME_CREATE_V1 create; + PFN_KODI_ADDON_GAME_DESTROY_V1 destroy; + PFN_KODI_ADDON_GAME_LOAD_GAME_V1 load_game; + PFN_KODI_ADDON_GAME_LOAD_GAME_SPECIAL_V1 load_game_special; + PFN_KODI_ADDON_GAME_LOAD_STANDALONE_V1 load_standalone; + PFN_KODI_ADDON_GAME_UNLOAD_GAME_V1 unload_game; + PFN_KODI_ADDON_GAME_GET_GAME_TIMING_V1 get_game_timing; + PFN_KODI_ADDON_GAME_GET_REGION_V1 get_region; + PFN_KODI_ADDON_GAME_REQUIRES_GAME_LOOP_V1 requires_game_loop; + PFN_KODI_ADDON_GAME_RUN_FRAME_V1 run_frame; + PFN_KODI_ADDON_GAME_RESET_V1 reset; + PFN_KODI_ADDON_GAME_HW_CONTEXT_RESET_V1 hw_context_reset; + PFN_KODI_ADDON_GAME_HW_CONTEXT_DESTROY_V1 hw_context_destroy; + PFN_KODI_ADDON_GAME_HAS_FEATURE_V1 has_feature; + PFN_KODI_ADDON_GAME_GET_TOPOLOGY_V1 get_topology; + PFN_KODI_ADDON_GAME_FREE_TOPOLOGY_V1 free_topology; + PFN_KODI_ADDON_GAME_SET_CONTROLLER_LAYOUTS_V1 set_controller_layouts; + PFN_KODI_ADDON_GAME_ENABLE_KEYBOARD_V1 enable_keyboard; + PFN_KODI_ADDON_GAME_ENABLE_MOUSE_V1 enable_mouse; + PFN_KODI_ADDON_GAME_CONNECT_CONTROLLER_V1 connect_controller; + PFN_KODI_ADDON_GAME_INPUT_EVENT_V1 input_event; + PFN_KODI_ADDON_GAME_SERIALIZE_SIZE_V1 serialize_size; + PFN_KODI_ADDON_GAME_SERIALIZE_V1 serialize; + PFN_KODI_ADDON_GAME_DESERIALIZE_V1 deserialize; + PFN_KODI_ADDON_GAME_CHEAT_RESET_V1 cheat_reset; + PFN_KODI_ADDON_GAME_GET_MEMORY_V1 get_memory; + PFN_KODI_ADDON_GAME_SET_CHEAT_V1 set_cheat; + PFN_KODI_ADDON_GAME_RC_GENERATE_HASH_FROM_FILE_V1 rc_generate_hash_from_file; + PFN_KODI_ADDON_GAME_RC_GET_GAME_ID_URL_V1 rc_get_game_id_url; + PFN_KODI_ADDON_GAME_RC_GET_PATCH_FILE_URL_V1 rc_get_patch_file_url; + PFN_KODI_ADDON_GAME_RC_POST_RICH_PRESENCE_URL_V1 rc_post_rich_presence_url; + PFN_KODI_ADDON_GAME_RC_ENABLE_RICH_PRESENCE_V1 rc_enable_rich_presence; + PFN_KODI_ADDON_GAME_RC_GET_RICH_PRESENCE_EVALUATION_V1 rc_get_rich_presence_evaluation; + PFN_KODI_ADDON_GAME_RC_RESET_RUNTIME_V1 rc_reset_runtime; + } KODI_ADDON_GAME_FUNC; - struct AddonInstance_Game; + typedef void* KODI_GAME_STREAM_HANDLE; - /*! - * @brief Game callbacks - * - * Not to be used outside this header. - */ - typedef struct AddonToKodiFuncTable_Game - { - KODI_HANDLE kodiInstance; - - void (*CloseGame)(KODI_HANDLE kodiInstance); - KODI_GAME_STREAM_HANDLE (*OpenStream)(KODI_HANDLE, const struct game_stream_properties*); - bool (*GetStreamBuffer)(KODI_HANDLE, - KODI_GAME_STREAM_HANDLE, - unsigned int, - unsigned int, - struct game_stream_buffer*); - void (*AddStreamData)(KODI_HANDLE, KODI_GAME_STREAM_HANDLE, const struct game_stream_packet*); - void (*ReleaseStreamBuffer)(KODI_HANDLE, KODI_GAME_STREAM_HANDLE, struct game_stream_buffer*); - void (*CloseStream)(KODI_HANDLE, KODI_GAME_STREAM_HANDLE); - game_proc_address_t (*HwGetProcAddress)(KODI_HANDLE kodiInstance, const char* symbol); - bool (*InputEvent)(KODI_HANDLE kodiInstance, const struct game_input_event* event); - } AddonToKodiFuncTable_Game; - - /*! - * @brief Game function hooks - * - * Not to be used outside this header. - */ - typedef struct KodiToAddonFuncTable_Game - { - KODI_HANDLE addonInstance; - - GAME_ERROR(__cdecl* LoadGame)(const struct AddonInstance_Game*, const char*); - GAME_ERROR(__cdecl* LoadGameSpecial) - (const struct AddonInstance_Game*, enum SPECIAL_GAME_TYPE, const char**, size_t); - GAME_ERROR(__cdecl* LoadStandalone)(const struct AddonInstance_Game*); - GAME_ERROR(__cdecl* UnloadGame)(const struct AddonInstance_Game*); - GAME_ERROR(__cdecl* GetGameTiming) - (const struct AddonInstance_Game*, struct game_system_timing*); - GAME_REGION(__cdecl* GetRegion)(const struct AddonInstance_Game*); - bool(__cdecl* RequiresGameLoop)(const struct AddonInstance_Game*); - GAME_ERROR(__cdecl* RunFrame)(const struct AddonInstance_Game*); - GAME_ERROR(__cdecl* Reset)(const struct AddonInstance_Game*); - GAME_ERROR(__cdecl* HwContextReset)(const struct AddonInstance_Game*); - GAME_ERROR(__cdecl* HwContextDestroy)(const struct AddonInstance_Game*); - bool(__cdecl* HasFeature)(const struct AddonInstance_Game*, const char*, const char*); - game_input_topology*(__cdecl* GetTopology)(const struct AddonInstance_Game*); - void(__cdecl* FreeTopology)(const struct AddonInstance_Game*, struct game_input_topology*); - void(__cdecl* SetControllerLayouts)(const struct AddonInstance_Game*, - const struct game_controller_layout*, - unsigned int); - bool(__cdecl* EnableKeyboard)(const struct AddonInstance_Game*, bool, const char*); - bool(__cdecl* EnableMouse)(const struct AddonInstance_Game*, bool, const char*); - bool(__cdecl* ConnectController)(const struct AddonInstance_Game*, - bool, - const char*, - const char*); - bool(__cdecl* InputEvent)(const struct AddonInstance_Game*, const struct game_input_event*); - size_t(__cdecl* SerializeSize)(const struct AddonInstance_Game*); - GAME_ERROR(__cdecl* Serialize)(const struct AddonInstance_Game*, uint8_t*, size_t); - GAME_ERROR(__cdecl* Deserialize)(const struct AddonInstance_Game*, const uint8_t*, size_t); - GAME_ERROR(__cdecl* CheatReset)(const struct AddonInstance_Game*); - GAME_ERROR(__cdecl* GetMemory) - (const struct AddonInstance_Game*, enum GAME_MEMORY, uint8_t**, size_t*); - GAME_ERROR(__cdecl* SetCheat) - (const struct AddonInstance_Game*, unsigned int, bool, const char*); - GAME_ERROR(__cdecl* RCGenerateHashFromFile) - (const AddonInstance_Game*, char**, unsigned int, const char*); - GAME_ERROR(__cdecl* RCGetGameIDUrl)(const AddonInstance_Game*, char**, const char*); - GAME_ERROR(__cdecl* RCGetPatchFileUrl) - (const AddonInstance_Game*, char**, const char*, const char*, unsigned int); - GAME_ERROR(__cdecl* RCPostRichPresenceUrl) - (const AddonInstance_Game*, - char**, - char**, - const char*, - const char*, - unsigned int, - const char*); - GAME_ERROR(__cdecl* RCEnableRichPresence)(const AddonInstance_Game*, const char*); - GAME_ERROR(__cdecl* RCGetRichPresenceEvaluation) - (const AddonInstance_Game*, char**, unsigned int); - GAME_ERROR(__cdecl* RCResetRuntime)(const AddonInstance_Game*); - void(__cdecl* FreeString)(const AddonInstance_Game*, char*); - } KodiToAddonFuncTable_Game; - - /*! - * @brief Game instance - * - * Not to be used outside this header. - */ - typedef struct AddonInstance_Game - { - struct AddonProps_Game* props; - struct AddonToKodiFuncTable_Game* toKodi; - struct KodiToAddonFuncTable_Game* toAddon; - } AddonInstance_Game; + ATTR_DLL_EXPORT void kodi_addon_game_close(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GAME_STREAM_HANDLE kodi_addon_game_open_stream( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const struct game_stream_properties* properties) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_game_get_stream_buffer(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + unsigned int width, + unsigned int height, + struct game_stream_buffer* buffer) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_game_add_stream_data(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + const struct game_stream_packet* packet) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_game_release_stream_buffer(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + struct game_stream_buffer* buffer) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_game_close_stream(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT game_proc_address_t kodi_addon_game_hw_get_proc_address( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* symbol) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_game_input_event(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const struct game_input_event* event) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus -} +} /* extern "C" */ #endif /* __cplusplus */ #endif /* !C_API_ADDONINSTANCE_GAME_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/imagedecoder.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/imagedecoder.h index bc74e8aed03e5..819bdfc537acd 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/imagedecoder.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/imagedecoder.h @@ -6,16 +6,20 @@ * See LICENSES/README.md for more information. */ -#ifndef C_API_ADDONINSTANCE_IMAGE_DECODER_H -#define C_API_ADDONINSTANCE_IMAGE_DECODER_H +#ifndef C_API_ADDONINSTANCE_IMAGEDECODER_H +#define C_API_ADDONINSTANCE_IMAGEDECODER_H #include "../addon_base.h" +#include + #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ +#if __KODI_API__ >= 1 + typedef void* KODI_ADDON_IMAGEDECODER_HDL; //============================================================================ @@ -371,21 +375,21 @@ extern "C" int width; int height; float distance; - ADDON_IMG_ORIENTATION orientation; - ADDON_IMG_COLOR color; - ADDON_IMG_METERING_MODE metering_mode; + enum ADDON_IMG_ORIENTATION orientation; + enum ADDON_IMG_COLOR color; + enum ADDON_IMG_METERING_MODE metering_mode; float exposure_time; float exposure_bias; - ADDON_IMG_EXPOSURE_PROGRAM exposure_program; - ADDON_IMG_EXPOSURE_MODE exposure_mode; + enum ADDON_IMG_EXPOSURE_PROGRAM exposure_program; + enum ADDON_IMG_EXPOSURE_MODE exposure_mode; time_t time_created; float aperture_f_number; - ADDON_IMG_FLASH_TYPE flash_used; + enum ADDON_IMG_FLASH_TYPE flash_used; int focal_length; int focal_length_in_35mm_format; float digital_zoom_ratio; float iso_speed; - ADDON_IMG_LIGHT_SOURCE light_source; + enum ADDON_IMG_LIGHT_SOURCE light_source; bool gps_info_present; char latitude_ref; @@ -424,27 +428,20 @@ extern "C" unsigned int pitch, enum ADDON_IMG_FMT format); - typedef struct KodiToAddonFuncTable_ImageDecoder + struct KODI_ADDON_IMAGEDECODER_FUNC { + PFN_KODI_ADDON_INSTANCE_CREATE_V1 create; + PFN_KODI_ADDON_INSTANCE_DESTROY_V1 destroy; PFN_KODI_ADDON_IMAGEDECODER_SUPPORTS_FILE_V1 supports_file; PFN_KODI_ADDON_IMAGEDECODER_READ_TAG_V1 read_tag; PFN_KODI_ADDON_IMAGEDECODER_LOAD_IMAGE_FROM_MEMORY_V1 load_image_from_memory; PFN_KODI_ADDON_IMAGEDECODER_DECODE_V1 decode; - } KodiToAddonFuncTable_ImageDecoder; - - typedef struct AddonToKodiFuncTable_ImageDecoder - { - KODI_HANDLE kodi_instance; - } AddonToKodiFuncTable_ImageDecoder; + }; - typedef struct AddonInstance_ImageDecoder - { - struct AddonToKodiFuncTable_ImageDecoder* toKodi; - struct KodiToAddonFuncTable_ImageDecoder* toAddon; - } AddonInstance_ImageDecoder; +#endif /* __KODI_API__ >= 1 */ #ifdef __cplusplus } /* extern "C" */ #endif /* __cplusplus */ -#endif /* !C_API_ADDONINSTANCE_IMAGE_DECODER_H */ +#endif /* !C_API_ADDONINSTANCE_IMAGEDECODER_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/inputstream.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/inputstream.h index 58047a6cf024a..a16dae0dc16e4 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/inputstream.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/inputstream.h @@ -6,6 +6,8 @@ * See LICENSES/README.md for more information. */ +/*---AUTO_GEN_PARSE---*/ + #ifndef C_API_ADDONINSTANCE_INPUTSTREAM_H #define C_API_ADDONINSTANCE_INPUTSTREAM_H @@ -32,6 +34,8 @@ extern "C" { #endif /* __cplusplus */ + typedef void* KODI_ADDON_INPUTSTREAM_HDL; + //============================================================================== /// @ingroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamCapabilities /// @brief **Capability types of inputstream addon.**\n @@ -597,104 +601,147 @@ extern "C" double ptsEnd; }; - /*! - * @brief "C" ABI Structures to transfer the methods from this to Kodi - */ - - // this are properties given to the addon on create - // at this time we have no parameters for the addon - typedef struct AddonProps_InputStream /* internal */ + typedef KODI_ADDON_INSTANCE_BACKEND_HDL (*PFN_CB_KODI_ADDON_INPUTSTREAM_TRANSFER_STREAM)( + KODI_ADDON_INSTANCE_BACKEND_HDL handle, int streamId, struct INPUTSTREAM_INFO* stream); + + typedef KODI_ADDON_INPUTSTREAM_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_CREATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DESTROY_V1)( + KODI_ADDON_INPUTSTREAM_HDL hdl); + + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_OPEN_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_PROPERTY* props); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_CLOSE_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef const char*(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_PATH_LIST_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_CAPABILITIES_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_CAPABILITIES* capabilities); + + // IDemux + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_STREAM_IDS_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_IDS* ids); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_STREAM_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int streamid, + struct INPUTSTREAM_INFO* info, + KODI_OWN_HDL* demuxStream, + PFN_CB_KODI_ADDON_INPUTSTREAM_TRANSFER_STREAM transfer_stream); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_ENABLE_STREAM_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int streamid, bool enable); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_OPEN_STREAM_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int streamid); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_RESET_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_ABORT_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_FLUSH_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef struct DEMUX_PACKET*(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_READ_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_SEEK_TIME_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, double time, bool backwards, double* startpts); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_DEMUX_SET_SPEED_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int speed); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_SET_VIDEO_RESOLUTION_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int width, int height); + + // IDisplayTime + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_TOTAL_TIME_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_TIME_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + + // ITime + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_TIMES_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, struct INPUTSTREAM_TIMES* times); + + // IPosTime + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_POS_TIME_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int ms); + + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_READ_STREAM_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, uint8_t* buffer, unsigned int bufferSize); + typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_SEEK_STREAM_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int64_t position, int whence); + typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_POSITION_STREAM_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_LENGTH_STREAM_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_IS_REAL_TIME_STREAM_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + + // IChapter + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_COUNT_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + typedef const char*(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_NAME_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch); + typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_POS_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_SEEK_CHAPTER_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch); + + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_BLOCK_SIZE_STREAM_V1)( + const KODI_ADDON_INPUTSTREAM_HDL hdl); + + typedef struct KODI_ADDON_INPUTSTREAM_FUNC { - int dummy; - } AddonProps_InputStream; + PFN_KODI_ADDON_INPUTSTREAM_CREATE_V1 create; + PFN_KODI_ADDON_INPUTSTREAM_DESTROY_V1 destroy; - typedef struct AddonToKodiFuncTable_InputStream /* internal */ - { - KODI_HANDLE kodiInstance; - struct DEMUX_PACKET* (*allocate_demux_packet)(void* kodiInstance, int data_size); - struct DEMUX_PACKET* (*allocate_encrypted_demux_packet)(void* kodiInstance, - unsigned int data_size, - unsigned int encrypted_subsample_count); - void (*free_demux_packet)(void* kodiInstance, struct DEMUX_PACKET* packet); - } AddonToKodiFuncTable_InputStream; - - struct AddonInstance_InputStream; - typedef struct KodiToAddonFuncTable_InputStream /* internal */ - { - KODI_HANDLE addonInstance; - - bool(__cdecl* open)(const struct AddonInstance_InputStream* instance, - struct INPUTSTREAM_PROPERTY* props); - void(__cdecl* close)(const struct AddonInstance_InputStream* instance); - const char*(__cdecl* get_path_list)(const struct AddonInstance_InputStream* instance); - void(__cdecl* get_capabilities)(const struct AddonInstance_InputStream* instance, - struct INPUTSTREAM_CAPABILITIES* capabilities); + PFN_KODI_ADDON_INPUTSTREAM_OPEN_V1 open; + PFN_KODI_ADDON_INPUTSTREAM_CLOSE_V1 close; + PFN_KODI_ADDON_INPUTSTREAM_GET_PATH_LIST_V1 get_path_list; + PFN_KODI_ADDON_INPUTSTREAM_GET_CAPABILITIES_V1 get_capabilities; // IDemux - bool(__cdecl* get_stream_ids)(const struct AddonInstance_InputStream* instance, - struct INPUTSTREAM_IDS* ids); - bool(__cdecl* get_stream)(const struct AddonInstance_InputStream* instance, - int streamid, - struct INPUTSTREAM_INFO* info, - KODI_HANDLE* demuxStream, - KODI_HANDLE (*transfer_stream)(KODI_HANDLE handle, - int streamId, - struct INPUTSTREAM_INFO* stream)); - void(__cdecl* enable_stream)(const struct AddonInstance_InputStream* instance, - int streamid, - bool enable); - bool(__cdecl* open_stream)(const struct AddonInstance_InputStream* instance, int streamid); - void(__cdecl* demux_reset)(const struct AddonInstance_InputStream* instance); - void(__cdecl* demux_abort)(const struct AddonInstance_InputStream* instance); - void(__cdecl* demux_flush)(const struct AddonInstance_InputStream* instance); - struct DEMUX_PACKET*(__cdecl* demux_read)(const struct AddonInstance_InputStream* instance); - bool(__cdecl* demux_seek_time)(const struct AddonInstance_InputStream* instance, - double time, - bool backwards, - double* startpts); - void(__cdecl* demux_set_speed)(const struct AddonInstance_InputStream* instance, int speed); - void(__cdecl* set_video_resolution)(const struct AddonInstance_InputStream* instance, - int width, - int height); + PFN_KODI_ADDON_INPUTSTREAM_GET_STREAM_IDS_V1 get_stream_ids; + PFN_KODI_ADDON_INPUTSTREAM_GET_STREAM_V1 get_stream; + PFN_KODI_ADDON_INPUTSTREAM_ENABLE_STREAM_V1 enable_stream; + PFN_KODI_ADDON_INPUTSTREAM_OPEN_STREAM_V1 open_stream; + PFN_KODI_ADDON_INPUTSTREAM_DEMUX_RESET_V1 demux_reset; + PFN_KODI_ADDON_INPUTSTREAM_DEMUX_ABORT_V1 demux_abort; + PFN_KODI_ADDON_INPUTSTREAM_DEMUX_FLUSH_V1 demux_flush; + PFN_KODI_ADDON_INPUTSTREAM_DEMUX_READ_V1 demux_read; + PFN_KODI_ADDON_INPUTSTREAM_DEMUX_SEEK_TIME_V1 demux_seek_time; + PFN_KODI_ADDON_INPUTSTREAM_DEMUX_SET_SPEED_V1 demux_set_speed; + PFN_KODI_ADDON_INPUTSTREAM_SET_VIDEO_RESOLUTION_V1 set_video_resolution; // IDisplayTime - int(__cdecl* get_total_time)(const struct AddonInstance_InputStream* instance); - int(__cdecl* get_time)(const struct AddonInstance_InputStream* instance); + PFN_KODI_ADDON_INPUTSTREAM_GET_TOTAL_TIME_V1 get_total_time; + PFN_KODI_ADDON_INPUTSTREAM_GET_TIME_V1 get_time; // ITime - bool(__cdecl* get_times)(const struct AddonInstance_InputStream* instance, - struct INPUTSTREAM_TIMES* times); + PFN_KODI_ADDON_INPUTSTREAM_GET_TIMES_V1 get_times; // IPosTime - bool(__cdecl* pos_time)(const struct AddonInstance_InputStream* instance, int ms); - - int(__cdecl* read_stream)(const struct AddonInstance_InputStream* instance, - uint8_t* buffer, - unsigned int bufferSize); - int64_t(__cdecl* seek_stream)(const struct AddonInstance_InputStream* instance, - int64_t position, - int whence); - int64_t(__cdecl* position_stream)(const struct AddonInstance_InputStream* instance); - int64_t(__cdecl* length_stream)(const struct AddonInstance_InputStream* instance); - bool(__cdecl* is_real_time_stream)(const struct AddonInstance_InputStream* instance); + PFN_KODI_ADDON_INPUTSTREAM_POS_TIME_V1 pos_time; + PFN_KODI_ADDON_INPUTSTREAM_READ_STREAM_V1 read_stream; + PFN_KODI_ADDON_INPUTSTREAM_SEEK_STREAM_V1 seek_stream; + PFN_KODI_ADDON_INPUTSTREAM_POSITION_STREAM_V1 position_stream; + PFN_KODI_ADDON_INPUTSTREAM_LENGTH_STREAM_V1 length_stream; + PFN_KODI_ADDON_INPUTSTREAM_IS_REAL_TIME_STREAM_V1 is_real_time_stream; // IChapter - int(__cdecl* get_chapter)(const struct AddonInstance_InputStream* instance); - int(__cdecl* get_chapter_count)(const struct AddonInstance_InputStream* instance); - const char*(__cdecl* get_chapter_name)(const struct AddonInstance_InputStream* instance, - int ch); - int64_t(__cdecl* get_chapter_pos)(const struct AddonInstance_InputStream* instance, int ch); - bool(__cdecl* seek_chapter)(const struct AddonInstance_InputStream* instance, int ch); - - int(__cdecl* block_size_stream)(const struct AddonInstance_InputStream* instance); - } KodiToAddonFuncTable_InputStream; - - typedef struct AddonInstance_InputStream /* internal */ - { - struct AddonProps_InputStream* props; - struct AddonToKodiFuncTable_InputStream* toKodi; - struct KodiToAddonFuncTable_InputStream* toAddon; - } AddonInstance_InputStream; + PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_V1 get_chapter; + PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_COUNT_V1 get_chapter_count; + PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_NAME_V1 get_chapter_name; + PFN_KODI_ADDON_INPUTSTREAM_GET_CHAPTER_POS_V1 get_chapter_pos; + PFN_KODI_ADDON_INPUTSTREAM_SEEK_CHAPTER_V1 seek_chapter; + PFN_KODI_ADDON_INPUTSTREAM_BLOCK_SIZE_STREAM_V1 block_size_stream; + } KODI_ADDON_INPUTSTREAM_FUNC; + + ATTR_DLL_EXPORT struct DEMUX_PACKET* kodi_addon_inputstream_allocate_demux_packet( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, int data_size) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT struct DEMUX_PACKET* kodi_addon_inputstream_allocate_encrypted_demux_packet( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + unsigned int data_size, + unsigned int encrypted_subsample_count) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_inputstream_free_demux_packet(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct DEMUX_PACKET* packet) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/peripheral.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/peripheral.h index d5e1d2b63e25c..852036091c48d 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/peripheral.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/peripheral.h @@ -1,16 +1,20 @@ /* - * Copyright (C) 2014-2018 Team Kodi + * Copyright (C) 2005-2018 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later * See LICENSES/README.md for more information. */ +/*---AUTO_GEN_PARSE---*/ + #ifndef C_API_ADDONINSTANCE_PERIPHERAL_H #define C_API_ADDONINSTANCE_PERIPHERAL_H #include "../addon_base.h" +#include + /* indicates a joystick has no preference for port number */ #define NO_PORT_REQUESTED (-1) @@ -22,6 +26,8 @@ extern "C" { #endif /* __cplusplus */ + typedef void* KODI_ADDON_PERIPHERAL_HDL; + //============================================================================ /// @defgroup cpp_kodi_addon_peripheral_Defs_General_PERIPHERAL_ERROR enum PERIPHERAL_ERROR /// @ingroup cpp_kodi_addon_peripheral_Defs_General @@ -84,25 +90,25 @@ extern "C" /*! * @brief Information shared between peripherals */ - typedef struct PERIPHERAL_INFO + struct PERIPHERAL_INFO { - PERIPHERAL_TYPE type; /*!< type of peripheral */ + enum PERIPHERAL_TYPE type; /*!< type of peripheral */ char* name; /*!< name of peripheral */ uint16_t vendor_id; /*!< vendor ID of peripheral, 0x0000 if unknown */ uint16_t product_id; /*!< product ID of peripheral, 0x0000 if unknown */ unsigned int index; /*!< the order in which the add-on identified this peripheral */ - } ATTR_PACKED PERIPHERAL_INFO; + }; /*! * @brief Peripheral add-on capabilities. */ - typedef struct PERIPHERAL_CAPABILITIES + struct PERIPHERAL_CAPABILITIES { bool provides_joysticks; /*!< true if the add-on provides joysticks */ bool provides_joystick_rumble; bool provides_joystick_power_off; bool provides_buttonmaps; /*!< true if the add-on provides button maps */ - } ATTR_PACKED PERIPHERAL_CAPABILITIES; + }; //} @@ -210,22 +216,22 @@ extern "C" /*! * @brief Event information */ - typedef struct PERIPHERAL_EVENT + struct PERIPHERAL_EVENT { /*! @brief Index of the peripheral handling/receiving the event */ unsigned int peripheral_index; /*! @brief Type of the event used to determine which enum field to access below */ - PERIPHERAL_EVENT_TYPE type; + enum PERIPHERAL_EVENT_TYPE type; /*! @brief The index of the event source */ unsigned int driver_index; - JOYSTICK_STATE_BUTTON driver_button_state; - JOYSTICK_STATE_HAT driver_hat_state; + enum JOYSTICK_STATE_BUTTON driver_button_state; + enum JOYSTICK_STATE_HAT driver_hat_state; JOYSTICK_STATE_AXIS driver_axis_state; JOYSTICK_STATE_MOTOR motor_state; - } ATTR_PACKED PERIPHERAL_EVENT; + }; //} @@ -235,9 +241,9 @@ extern "C" /*! * @brief Info specific to joystick peripherals */ - typedef struct JOYSTICK_INFO + struct JOYSTICK_INFO { - PERIPHERAL_INFO peripheral; /*!< @brief peripheral info for this joystick */ + struct PERIPHERAL_INFO peripheral; /*!< @brief peripheral info for this joystick */ char* provider; /*!< @brief name of the driver or interface providing the joystick */ int requested_port; /*!< @brief requested port number (such as for 360 controllers), or NO_PORT_REQUESTED */ unsigned int button_count; /*!< @brief number of buttons reported by the driver */ @@ -245,7 +251,7 @@ extern "C" unsigned int axis_count; /*!< @brief number of axes reported by the driver */ unsigned int motor_count; /*!< @brief number of motors reported by the driver */ bool supports_poweroff; /*!< @brief whether the joystick supports being powered off */ - } ATTR_PACKED JOYSTICK_INFO; + }; //============================================================================ /// @defgroup cpp_kodi_addon_peripheral_Defs_Joystick_JOYSTICK_DRIVER_PRIMITIVE_TYPE enum JOYSTICK_DRIVER_PRIMITIVE_TYPE @@ -292,10 +298,10 @@ extern "C" /*! * @brief Button primitive */ - typedef struct JOYSTICK_DRIVER_BUTTON + struct JOYSTICK_DRIVER_BUTTON { int index; - } ATTR_PACKED JOYSTICK_DRIVER_BUTTON; + }; //============================================================================ /// @defgroup cpp_kodi_addon_peripheral_Defs_Joystick_JOYSTICK_DRIVER_HAT_DIRECTION enum JOYSTICK_DRIVER_HAT_DIRECTION @@ -326,11 +332,11 @@ extern "C" /*! * @brief Hat direction primitive */ - typedef struct JOYSTICK_DRIVER_HAT + struct JOYSTICK_DRIVER_HAT { int index; - JOYSTICK_DRIVER_HAT_DIRECTION direction; - } ATTR_PACKED JOYSTICK_DRIVER_HAT; + enum JOYSTICK_DRIVER_HAT_DIRECTION direction; + }; //============================================================================ /// @defgroup cpp_kodi_addon_peripheral_Defs_Joystick_JOYSTICK_DRIVER_SEMIAXIS_DIRECTION enum JOYSTICK_DRIVER_SEMIAXIS_DIRECTION @@ -355,29 +361,29 @@ extern "C" /*! * @brief Semiaxis primitive */ - typedef struct JOYSTICK_DRIVER_SEMIAXIS + struct JOYSTICK_DRIVER_SEMIAXIS { int index; int center; - JOYSTICK_DRIVER_SEMIAXIS_DIRECTION direction; + enum JOYSTICK_DRIVER_SEMIAXIS_DIRECTION direction; unsigned int range; - } ATTR_PACKED JOYSTICK_DRIVER_SEMIAXIS; + }; /*! * @brief Motor primitive */ - typedef struct JOYSTICK_DRIVER_MOTOR + struct JOYSTICK_DRIVER_MOTOR { int index; - } ATTR_PACKED JOYSTICK_DRIVER_MOTOR; + }; /*! * @brief Keyboard key primitive */ - typedef struct JOYSTICK_DRIVER_KEY + struct JOYSTICK_DRIVER_KEY { char keycode[16]; - } ATTR_PACKED JOYSTICK_DRIVER_KEY; + }; //============================================================================ /// @defgroup cpp_kodi_addon_peripheral_Defs_Joystick_JOYSTICK_DRIVER_MOUSE_INDEX enum JOYSTICK_DRIVER_MOUSE_INDEX @@ -423,10 +429,10 @@ extern "C" /*! * @brief Mouse button primitive */ - typedef struct JOYSTICK_DRIVER_MOUSE_BUTTON + struct JOYSTICK_DRIVER_MOUSE_BUTTON { - JOYSTICK_DRIVER_MOUSE_INDEX button; - } ATTR_PACKED JOYSTICK_DRIVER_MOUSE_BUTTON; + enum JOYSTICK_DRIVER_MOUSE_INDEX button; + }; //============================================================================ /// @defgroup cpp_kodi_addon_peripheral_Defs_Joystick_JOYSTICK_DRIVER_RELPOINTER_DIRECTION enum JOYSTICK_DRIVER_RELPOINTER_DIRECTION @@ -457,17 +463,17 @@ extern "C" /*! * @brief Relative pointer direction primitive */ - typedef struct JOYSTICK_DRIVER_RELPOINTER + struct JOYSTICK_DRIVER_RELPOINTER { - JOYSTICK_DRIVER_RELPOINTER_DIRECTION direction; - } ATTR_PACKED JOYSTICK_DRIVER_RELPOINTER; + enum JOYSTICK_DRIVER_RELPOINTER_DIRECTION direction; + }; /*! * @brief Driver primitive struct */ - typedef struct JOYSTICK_DRIVER_PRIMITIVE + struct JOYSTICK_DRIVER_PRIMITIVE { - JOYSTICK_DRIVER_PRIMITIVE_TYPE type; + enum JOYSTICK_DRIVER_PRIMITIVE_TYPE type; union { struct JOYSTICK_DRIVER_BUTTON button; @@ -478,7 +484,7 @@ extern "C" struct JOYSTICK_DRIVER_MOUSE_BUTTON mouse; struct JOYSTICK_DRIVER_RELPOINTER relpointer; }; - } ATTR_PACKED JOYSTICK_DRIVER_PRIMITIVE; + }; //============================================================================ /// @defgroup cpp_kodi_addon_peripheral_Defs_Joystick_JOYSTICK_FEATURE_TYPE enum JOYSTICK_FEATURE_TYPE @@ -590,115 +596,119 @@ extern "C" /*! * @brief Mapping between higher-level controller feature and its driver primitives */ - typedef struct JOYSTICK_FEATURE + struct JOYSTICK_FEATURE { char* name; - JOYSTICK_FEATURE_TYPE type; + enum JOYSTICK_FEATURE_TYPE type; struct JOYSTICK_DRIVER_PRIMITIVE primitives[JOYSTICK_PRIMITIVE_MAX]; - } ATTR_PACKED JOYSTICK_FEATURE; - //} - - typedef struct AddonProps_Peripheral - { - const char* user_path; /*!< @brief path to the user profile */ - const char* addon_path; /*!< @brief path to this add-on */ - } ATTR_PACKED AddonProps_Peripheral; - - struct AddonInstance_Peripheral; - - typedef struct AddonToKodiFuncTable_Peripheral - { - KODI_HANDLE kodiInstance; - void (*trigger_scan)(void* kodiInstance); - void (*refresh_button_maps)(void* kodiInstance, - const char* device_name, - const char* controller_id); - unsigned int (*feature_count)(void* kodiInstance, - const char* controller_id, - JOYSTICK_FEATURE_TYPE type); - JOYSTICK_FEATURE_TYPE(*feature_type) - (void* kodiInstance, const char* controller_id, const char* feature_name); - } AddonToKodiFuncTable_Peripheral; - - //! @todo Mouse, light gun, multitouch - - typedef struct KodiToAddonFuncTable_Peripheral - { - KODI_HANDLE addonInstance; - - void(__cdecl* get_capabilities)(const struct AddonInstance_Peripheral* addonInstance, - struct PERIPHERAL_CAPABILITIES* capabilities); - PERIPHERAL_ERROR(__cdecl* perform_device_scan) - (const struct AddonInstance_Peripheral* addonInstance, - unsigned int* peripheral_count, - struct PERIPHERAL_INFO** scan_results); - void(__cdecl* free_scan_results)(const struct AddonInstance_Peripheral* addonInstance, - unsigned int peripheral_count, - struct PERIPHERAL_INFO* scan_results); - PERIPHERAL_ERROR(__cdecl* get_events) - (const struct AddonInstance_Peripheral* addonInstance, - unsigned int* event_count, - struct PERIPHERAL_EVENT** events); - void(__cdecl* free_events)(const struct AddonInstance_Peripheral* addonInstance, - unsigned int event_count, - struct PERIPHERAL_EVENT* events); - bool(__cdecl* send_event)(const struct AddonInstance_Peripheral* addonInstance, - const struct PERIPHERAL_EVENT* event); - - /// @name Joystick operations - ///{ - PERIPHERAL_ERROR(__cdecl* get_joystick_info) - (const struct AddonInstance_Peripheral* addonInstance, - unsigned int index, - struct JOYSTICK_INFO* info); - void(__cdecl* free_joystick_info)(const struct AddonInstance_Peripheral* addonInstance, - struct JOYSTICK_INFO* info); - PERIPHERAL_ERROR(__cdecl* get_features) - (const struct AddonInstance_Peripheral* addonInstance, - const struct JOYSTICK_INFO* joystick, - const char* controller_id, - unsigned int* feature_count, - struct JOYSTICK_FEATURE** features); - void(__cdecl* free_features)(const struct AddonInstance_Peripheral* addonInstance, - unsigned int feature_count, - struct JOYSTICK_FEATURE* features); - PERIPHERAL_ERROR(__cdecl* map_features) - (const struct AddonInstance_Peripheral* addonInstance, - const struct JOYSTICK_INFO* joystick, - const char* controller_id, - unsigned int feature_count, - const struct JOYSTICK_FEATURE* features); - PERIPHERAL_ERROR(__cdecl* get_ignored_primitives) - (const struct AddonInstance_Peripheral* addonInstance, - const struct JOYSTICK_INFO* joystick, - unsigned int* feature_count, - struct JOYSTICK_DRIVER_PRIMITIVE** primitives); - void(__cdecl* free_primitives)(const struct AddonInstance_Peripheral* addonInstance, - unsigned int, - struct JOYSTICK_DRIVER_PRIMITIVE* primitives); - PERIPHERAL_ERROR(__cdecl* set_ignored_primitives) - (const struct AddonInstance_Peripheral* addonInstance, - const struct JOYSTICK_INFO* joystick, - unsigned int primitive_count, - const struct JOYSTICK_DRIVER_PRIMITIVE* primitives); - void(__cdecl* save_button_map)(const struct AddonInstance_Peripheral* addonInstance, - const struct JOYSTICK_INFO* joystick); - void(__cdecl* revert_button_map)(const struct AddonInstance_Peripheral* addonInstance, - const struct JOYSTICK_INFO* joystick); - void(__cdecl* reset_button_map)(const struct AddonInstance_Peripheral* addonInstance, - const struct JOYSTICK_INFO* joystick, - const char* controller_id); - void(__cdecl* power_off_joystick)(const struct AddonInstance_Peripheral* addonInstance, - unsigned int index); - ///} - } KodiToAddonFuncTable_Peripheral; - - typedef struct AddonInstance_Peripheral + }; + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // General interface functions + typedef KODI_ADDON_PERIPHERAL_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_CREATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_DESTROY_V1)(KODI_ADDON_PERIPHERAL_HDL hdl); + + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_GET_CAPABILITIES_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_CAPABILITIES* capabilities); + typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_PERFORM_DEVICE_SCAN_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_INFO** scan_results, + size_t* peripheral_count); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FREE_SCAN_RESULTS_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_INFO* scan_results, size_t peripheral_count); + typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_GET_EVENTS_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_EVENT** events, size_t* event_count); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FREE_EVENTS_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, struct PERIPHERAL_EVENT* events, size_t event_count); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_SEND_EVENT_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, const struct PERIPHERAL_EVENT* event); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Joystick operations + typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_GET_JOYSTICK_INFO_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, unsigned int index, struct JOYSTICK_INFO* info); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FREE_JOYSTICK_INFO_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, struct JOYSTICK_INFO* info); + typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_GET_FEATURES_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id, + struct JOYSTICK_FEATURE** features, + size_t* feature_count); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FREE_FEATURES_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, struct JOYSTICK_FEATURE* features, size_t feature_count); + typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_MAP_FEATURES_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id, + const struct JOYSTICK_FEATURE* features, + size_t feature_count); + typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_GET_IGNORED_PRIMITIVES_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + struct JOYSTICK_DRIVER_PRIMITIVE** primitives, + size_t* primitive_count); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FREE_PRIMITIVES_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count); + typedef enum PERIPHERAL_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_SET_IGNORED_PRIMITIVES_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const struct JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_SAVE_BUTTON_MAP_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_REVERT_BUTTON_MAP_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, const struct JOYSTICK_INFO* joystick); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_RESET_BUTTON_MAP_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_POWER_OFF_JOYSTICK_V1)( + KODI_ADDON_PERIPHERAL_HDL hdl, unsigned int index); + + typedef struct KODI_ADDON_PERIPHERAL_FUNC { - struct AddonProps_Peripheral* props; - struct AddonToKodiFuncTable_Peripheral* toKodi; - struct KodiToAddonFuncTable_Peripheral* toAddon; - } AddonInstance_Peripheral; + PFN_KODI_ADDON_PERIPHERAL_CREATE_V1 create; + PFN_KODI_ADDON_PERIPHERAL_DESTROY_V1 destroy; + + PFN_KODI_ADDON_PERIPHERAL_GET_CAPABILITIES_V1 get_capabilities; + PFN_KODI_ADDON_PERIPHERAL_PERFORM_DEVICE_SCAN_V1 perform_device_scan; + PFN_KODI_ADDON_PERIPHERAL_FREE_SCAN_RESULTS_V1 free_scan_results; + PFN_KODI_ADDON_PERIPHERAL_GET_EVENTS_V1 get_events; + PFN_KODI_ADDON_PERIPHERAL_FREE_EVENTS_V1 free_events; + PFN_KODI_ADDON_PERIPHERAL_SEND_EVENT_V1 send_event; + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Joystick operations + PFN_KODI_ADDON_PERIPHERAL_GET_JOYSTICK_INFO_V1 get_joystick_info; + PFN_KODI_ADDON_PERIPHERAL_FREE_JOYSTICK_INFO_V1 free_joystick_info; + PFN_KODI_ADDON_PERIPHERAL_GET_FEATURES_V1 get_features; + PFN_KODI_ADDON_PERIPHERAL_FREE_FEATURES_V1 free_features; + PFN_KODI_ADDON_PERIPHERAL_MAP_FEATURES_V1 map_features; + PFN_KODI_ADDON_PERIPHERAL_GET_IGNORED_PRIMITIVES_V1 get_ignored_primitives; + PFN_KODI_ADDON_PERIPHERAL_FREE_PRIMITIVES_V1 free_primitives; + PFN_KODI_ADDON_PERIPHERAL_SET_IGNORED_PRIMITIVES_V1 set_ignored_primitives; + PFN_KODI_ADDON_PERIPHERAL_SAVE_BUTTON_MAP_V1 save_button_map; + PFN_KODI_ADDON_PERIPHERAL_REVERT_BUTTON_MAP_V1 revert_button_map; + PFN_KODI_ADDON_PERIPHERAL_RESET_BUTTON_MAP_V1 reset_button_map; + PFN_KODI_ADDON_PERIPHERAL_POWER_OFF_JOYSTICK_V1 power_off_joystick; + } KODI_ADDON_PERIPHERAL_FUNC; + + ATTR_DLL_EXPORT void kodi_addon_peripheral_trigger_scan(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_peripheral_refresh_button_maps( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* device_name, const char* controller_id) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT unsigned int kodi_addon_peripheral_feature_count( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* controller_id, + enum JOYSTICK_FEATURE_TYPE type) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT enum JOYSTICK_FEATURE_TYPE kodi_addon_peripheral_feature_type( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* controller_id, const char* feature_name) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr.h index 96e1eea9710a7..3843c789bf6ec 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/pvr.h @@ -9,7 +9,7 @@ #ifndef C_API_ADDONINSTANCE_PVR_H #define C_API_ADDONINSTANCE_PVR_H -#include "../../AddonBase.h" +#include "../addon_base.h" #include "pvr/pvr_channel_groups.h" #include "pvr/pvr_channels.h" #include "pvr/pvr_defines.h" @@ -22,319 +22,328 @@ #include "pvr/pvr_stream.h" #include "pvr/pvr_timers.h" -//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ -// "C" main interface function tables between Kodi and addon -// -// Values related to all parts and not used direct on addon, are to define here. -// #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - /*! - * @internal - * @brief PVR "C" basis API interface - * - * This field contains things that are exchanged between Kodi and Addon - * and is the basis of the PVR-side "C" API. - * - * @warning Care should be taken when making changes in this fields!\n - * Changes can destroy API in addons that have already been created. If a - * necessary change or new feature is added, the version of the PVR - * at @ref ADDON_INSTANCE_VERSION_PVR_MIN must be increased too.\n - * \n - * Conditional changes can be made in some places, without min PVR version - * increase. The add-on should then use CreateInstanceEx and add partial tests - * for this in the C++ header. - * - * Have by add of new parts a look about **Doxygen** `\\ingroup`, so that - * added parts included in documentation. - * - * If you add addon side related documentation, where his dev need know, - * use `///`. For parts only for Kodi make it like here. - * - * @endinternal - */ - - struct AddonInstance_PVR; - - /*! - * @brief Structure to define typical standard values - */ - typedef struct AddonProperties_PVR - { - const char* strUserPath; - const char* strClientPath; - int iEpgMaxFutureDays; - int iEpgMaxPastDays; - } AddonProperties_PVR; - - /*! - * @brief Structure to transfer the methods from Kodi to addon - */ - typedef struct AddonToKodiFuncTable_PVR + typedef void* KODI_ADDON_PVR_HDL; + typedef void* KODI_ADDON_PVR_TRANSFER_HDL; + + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CAPABILITIES_V1)( + KODI_ADDON_PVR_HDL hdl, struct PVR_ADDON_CAPABILITIES* capabilities); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_BACKEND_NAME_V1)( + KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_BACKEND_VERSION_V1)( + KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_BACKEND_HOSTNAME_V1)( + KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CONNECTION_STRING_V1)( + KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_DRIVE_SPACE_V1)( + KODI_ADDON_PVR_HDL hdl, uint64_t* total, uint64_t* used); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_SETTINGS_MENU_HOOK_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Channel interface functions + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNELS_AMOUNT_V1)( + KODI_ADDON_PVR_HDL hdl, int* amount); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNELS_V1)( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool radio); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_STREAM_PROPERTIES_V1)( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_SIGNAL_STATUS_V1)( + KODI_ADDON_PVR_HDL hdl, int channel_uid, struct PVR_SIGNAL_STATUS* signal_status); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_DESCRAMBLE_INFO_V1)( + KODI_ADDON_PVR_HDL hdl, int channel_uid, struct PVR_DESCRAMBLE_INFO* descramble_info); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Provider interface functions + + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_PROVIDERS_AMOUNT_V1)( + KODI_ADDON_PVR_HDL hdl, int* amount); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_PROVIDERS_V1)( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Channel group interface functions + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUPS_AMOUNT_V1)( + KODI_ADDON_PVR_HDL hdl, int* amount); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUPS_V1)( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool radio); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUP_MEMBERS_V1)( + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP* group); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Channel edit interface functions + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_CHANNEL_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_RENAME_CHANNEL_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_SETTINGS_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_ADD_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_SCAN_V1)( + KODI_ADDON_PVR_HDL hdl); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_CHANNEL_MENU_HOOK_V1)( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_CHANNEL* channel); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // EPG interface functions + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_FOR_CHANNEL_V1)( + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + int channel_uid, + time_t start, + time_t end); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_IS_EPG_TAG_RECORDABLE_V1)( + KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, bool* is_recordable); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_IS_EPG_TAG_PLAYABLE_V1)( + KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, bool* is_playable); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_TAG_EDL_V1)( + KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, struct PVR_EDL_ENTRY edl[], size_t* size); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_TAG_STREAM_PROPERTIES_V1)( + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_EPG_MAX_PAST_DAYS_V1)( + KODI_ADDON_PVR_HDL hdl, int past_days); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_EPG_MAX_FUTURE_DAYS_V1)( + KODI_ADDON_PVR_HDL hdl, int future_days); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_EPG_MENU_HOOK_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct EPG_TAG* tag); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Recording interface functions + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDINGS_AMOUNT_V1)( + KODI_ADDON_PVR_HDL hdl, bool deleted, int* amount); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDINGS_V1)( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool deleted); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_RECORDING_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_UNDELETE_RECORDING_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_ALL_RECORDINGS_FROM_TRASH_V1)( + KODI_ADDON_PVR_HDL hdl); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_RENAME_RECORDING_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_RECORDING_LIFETIME_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_RECORDING_PLAY_COUNT_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int count); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_RECORDING_LAST_PLAYED_POSITION_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int last_played_position); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_LAST_PLAYED_POSITION_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int* last_played_position); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_EDL_V1)( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + struct PVR_EDL_ENTRY edl[], + size_t* size); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_SIZE_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int64_t* size); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_STREAM_PROPERTIES_V1)( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_RECORDING_MENU_HOOK_V1)( + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_RECORDING* recording); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Timer interface functions + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_TIMER_TYPES_V1)( + KODI_ADDON_PVR_HDL hdl, struct PVR_TIMER_TYPE types[], size_t* types_count); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_TIMERS_AMOUNT_V1)( + KODI_ADDON_PVR_HDL hdl, int* amount); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_TIMERS_V1)( + KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ADD_TIMER_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_TIMER_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer, bool force_delete); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_UPDATE_TIMER_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_TIMER_MENU_HOOK_V1)( + KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct PVR_TIMER* timer); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Powersaving interface functions + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_SYSTEM_SLEEP_V1)( + KODI_ADDON_PVR_HDL hdl); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_SYSTEM_WAKE_V1)( + KODI_ADDON_PVR_HDL hdl); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_POWER_SAVING_ACTIVATED_V1)( + KODI_ADDON_PVR_HDL hdl); + typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_POWER_SAVING_DEACTIVATED_V1)( + KODI_ADDON_PVR_HDL hdl); + + typedef struct KODI_ADDON_PVR_FUNC { - // Pointer inside Kodi where used from him to find his class - KODI_HANDLE kodiInstance; - - //--==----==----==----==----==----==----==----==----==----==----==----==----== - // General callback functions - void (*AddMenuHook)(void* kodiInstance, const struct PVR_MENUHOOK* hook); - void (*RecordingNotification)(void* kodiInstance, - const char* name, - const char* fileName, - bool on); - void (*ConnectionStateChange)(void* kodiInstance, - const char* strConnectionString, - enum PVR_CONNECTION_STATE newState, - const char* strMessage); - void (*EpgEventStateChange)(void* kodiInstance, - struct EPG_TAG* tag, - enum EPG_EVENT_STATE newState); - - //--==----==----==----==----==----==----==----==----==----==----==----==----== - // Transfer functions where give data back to Kodi, e.g. GetChannels calls TransferChannelEntry - void (*TransferChannelEntry)(void* kodiInstance, - const PVR_HANDLE handle, - const struct PVR_CHANNEL* chan); - void (*TransferProviderEntry)(void* kodiInstance, - const PVR_HANDLE handle, - const struct PVR_PROVIDER* chanProvider); - void (*TransferChannelGroup)(void* kodiInstance, - const PVR_HANDLE handle, - const struct PVR_CHANNEL_GROUP* group); - void (*TransferChannelGroupMember)(void* kodiInstance, - const PVR_HANDLE handle, - const struct PVR_CHANNEL_GROUP_MEMBER* member); - void (*TransferEpgEntry)(void* kodiInstance, - const PVR_HANDLE handle, - const struct EPG_TAG* epgentry); - void (*TransferRecordingEntry)(void* kodiInstance, - const PVR_HANDLE handle, - const struct PVR_RECORDING* recording); - void (*TransferTimerEntry)(void* kodiInstance, - const PVR_HANDLE handle, - const struct PVR_TIMER* timer); - - //--==----==----==----==----==----==----==----==----==----==----==----==----== - // Kodi inform interface functions - void (*TriggerChannelUpdate)(void* kodiInstance); - void (*TriggerProvidersUpdate)(void* kodiInstance); - void (*TriggerChannelGroupsUpdate)(void* kodiInstance); - void (*TriggerEpgUpdate)(void* kodiInstance, unsigned int iChannelUid); - void (*TriggerRecordingUpdate)(void* kodiInstance); - void (*TriggerTimerUpdate)(void* kodiInstance); - - //--==----==----==----==----==----==----==----==----==----==----==----==----== - // Stream demux interface functions - void (*FreeDemuxPacket)(void* kodiInstance, struct DEMUX_PACKET* pPacket); - struct DEMUX_PACKET* (*AllocateDemuxPacket)(void* kodiInstance, int iDataSize); - struct PVR_CODEC (*GetCodecByName)(const void* kodiInstance, const char* strCodecName); - - //--==----==----==----==----==----==----==----==----==----==----==----==----== - // New functions becomes added below and can be on another API change (where - // breaks min API version) moved up. - } AddonToKodiFuncTable_PVR; - - /*! - * @brief Structure to transfer the methods from addon to Kodi - */ - typedef struct KodiToAddonFuncTable_PVR - { - // Pointer inside addon where used on them to find his instance class (currently unused!) - KODI_HANDLE addonInstance; - //--==----==----==----==----==----==----==----==----==----==----==----==----== // General interface functions - enum PVR_ERROR(__cdecl* GetCapabilities)(const struct AddonInstance_PVR*, - struct PVR_ADDON_CAPABILITIES*); - enum PVR_ERROR(__cdecl* GetBackendName)(const struct AddonInstance_PVR*, char*, int); - enum PVR_ERROR(__cdecl* GetBackendVersion)(const struct AddonInstance_PVR*, char*, int); - enum PVR_ERROR(__cdecl* GetBackendHostname)(const struct AddonInstance_PVR*, char*, int); - enum PVR_ERROR(__cdecl* GetConnectionString)(const struct AddonInstance_PVR*, char*, int); - enum PVR_ERROR(__cdecl* GetDriveSpace)(const struct AddonInstance_PVR*, uint64_t*, uint64_t*); - enum PVR_ERROR(__cdecl* CallSettingsMenuHook)(const struct AddonInstance_PVR*, - const struct PVR_MENUHOOK*); + PFN_KODI_ADDON_PVR_GET_CAPABILITIES_V1 get_capabilities; + PFN_KODI_ADDON_PVR_GET_BACKEND_NAME_V1 get_backend_name; + PFN_KODI_ADDON_PVR_GET_BACKEND_VERSION_V1 get_backend_version; + PFN_KODI_ADDON_PVR_GET_BACKEND_HOSTNAME_V1 get_backend_hostname; + PFN_KODI_ADDON_PVR_GET_CONNECTION_STRING_V1 get_connection_string; + PFN_KODI_ADDON_PVR_GET_DRIVE_SPACE_V1 get_drive_space; + PFN_KODI_ADDON_PVR_CALL_SETTINGS_MENU_HOOK_V1 call_settings_menu_hook; //--==----==----==----==----==----==----==----==----==----==----==----==----== // Channel interface functions - - enum PVR_ERROR(__cdecl* GetChannelsAmount)(const struct AddonInstance_PVR*, int*); - enum PVR_ERROR(__cdecl* GetChannels)(const struct AddonInstance_PVR*, PVR_HANDLE, bool); - enum PVR_ERROR(__cdecl* GetChannelStreamProperties)(const struct AddonInstance_PVR*, - const struct PVR_CHANNEL*, - struct PVR_NAMED_VALUE*, - unsigned int*); - enum PVR_ERROR(__cdecl* GetSignalStatus)(const struct AddonInstance_PVR*, - int, - struct PVR_SIGNAL_STATUS*); - enum PVR_ERROR(__cdecl* GetDescrambleInfo)(const struct AddonInstance_PVR*, - int, - struct PVR_DESCRAMBLE_INFO*); + PFN_KODI_ADDON_PVR_GET_CHANNELS_AMOUNT_V1 get_channels_amount; + PFN_KODI_ADDON_PVR_GET_CHANNELS_V1 get_channels; + PFN_KODI_ADDON_PVR_GET_CHANNEL_STREAM_PROPERTIES_V1 get_channel_stream_properties; + PFN_KODI_ADDON_PVR_GET_SIGNAL_STATUS_V1 get_signal_status; + PFN_KODI_ADDON_PVR_GET_DESCRAMBLE_INFO_V1 get_descramble_info; //--==----==----==----==----==----==----==----==----==----==----==----==----== // Provider interface functions - - enum PVR_ERROR(__cdecl* GetProvidersAmount)(const struct AddonInstance_PVR*, int*); - enum PVR_ERROR(__cdecl* GetProviders)(const struct AddonInstance_PVR*, PVR_HANDLE); + PFN_KODI_ADDON_PVR_GET_PROVIDERS_AMOUNT_V1 get_providers_amount; + PFN_KODI_ADDON_PVR_GET_PROVIDERS_V1 get_providers; //--==----==----==----==----==----==----==----==----==----==----==----==----== // Channel group interface functions - enum PVR_ERROR(__cdecl* GetChannelGroupsAmount)(const struct AddonInstance_PVR*, int*); - enum PVR_ERROR(__cdecl* GetChannelGroups)(const struct AddonInstance_PVR*, PVR_HANDLE, bool); - enum PVR_ERROR(__cdecl* GetChannelGroupMembers)(const struct AddonInstance_PVR*, - PVR_HANDLE, - const struct PVR_CHANNEL_GROUP*); + PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUPS_AMOUNT_V1 get_channel_groups_amount; + PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUPS_V1 get_channel_groups; + PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUP_MEMBERS_V1 get_channel_group_members; //--==----==----==----==----==----==----==----==----==----==----==----==----== // Channel edit interface functions - enum PVR_ERROR(__cdecl* DeleteChannel)(const struct AddonInstance_PVR*, - const struct PVR_CHANNEL*); - enum PVR_ERROR(__cdecl* RenameChannel)(const struct AddonInstance_PVR*, - const struct PVR_CHANNEL*); - enum PVR_ERROR(__cdecl* OpenDialogChannelSettings)(const struct AddonInstance_PVR*, - const struct PVR_CHANNEL*); - enum PVR_ERROR(__cdecl* OpenDialogChannelAdd)(const struct AddonInstance_PVR*, - const struct PVR_CHANNEL*); - enum PVR_ERROR(__cdecl* OpenDialogChannelScan)(const struct AddonInstance_PVR*); - enum PVR_ERROR(__cdecl* CallChannelMenuHook)(const struct AddonInstance_PVR*, - const PVR_MENUHOOK*, - const PVR_CHANNEL*); + PFN_KODI_ADDON_PVR_DELETE_CHANNEL_V1 delete_channel; + PFN_KODI_ADDON_PVR_RENAME_CHANNEL_V1 rename_channel; + PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_SETTINGS_V1 open_dialog_channel_settings; + PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_ADD_V1 open_dialog_channel_add; + PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_SCAN_V1 open_dialog_channel_scan; + PFN_KODI_ADDON_PVR_CALL_CHANNEL_MENU_HOOK_V1 call_channel_menu_hook; //--==----==----==----==----==----==----==----==----==----==----==----==----== // EPG interface functions - enum PVR_ERROR(__cdecl* GetEPGForChannel)( - const struct AddonInstance_PVR*, PVR_HANDLE, int, time_t, time_t); - enum PVR_ERROR(__cdecl* IsEPGTagRecordable)(const struct AddonInstance_PVR*, - const struct EPG_TAG*, - bool*); - enum PVR_ERROR(__cdecl* IsEPGTagPlayable)(const struct AddonInstance_PVR*, - const struct EPG_TAG*, - bool*); - enum PVR_ERROR(__cdecl* GetEPGTagEdl)(const struct AddonInstance_PVR*, - const struct EPG_TAG*, - struct PVR_EDL_ENTRY[], - int*); - enum PVR_ERROR(__cdecl* GetEPGTagStreamProperties)(const struct AddonInstance_PVR*, - const struct EPG_TAG*, - struct PVR_NAMED_VALUE*, - unsigned int*); - enum PVR_ERROR(__cdecl* SetEPGMaxPastDays)(const struct AddonInstance_PVR*, int); - enum PVR_ERROR(__cdecl* SetEPGMaxFutureDays)(const struct AddonInstance_PVR*, int); - enum PVR_ERROR(__cdecl* CallEPGMenuHook)(const struct AddonInstance_PVR*, - const struct PVR_MENUHOOK*, - const struct EPG_TAG*); + PFN_KODI_ADDON_PVR_GET_EPG_FOR_CHANNEL_V1 get_epg_for_channel; + PFN_KODI_ADDON_PVR_IS_EPG_TAG_RECORDABLE_V1 is_epg_tag_recordable; + PFN_KODI_ADDON_PVR_IS_EPG_TAG_PLAYABLE_V1 is_epg_tag_playable; + PFN_KODI_ADDON_PVR_GET_EPG_TAG_EDL_V1 get_epg_tag_edl; + PFN_KODI_ADDON_PVR_GET_EPG_TAG_STREAM_PROPERTIES_V1 get_epg_tag_stream_properties; + PFN_KODI_ADDON_PVR_SET_EPG_MAX_PAST_DAYS_V1 set_epg_max_past_days; + PFN_KODI_ADDON_PVR_SET_EPG_MAX_FUTURE_DAYS_V1 set_epg_max_future_days; + PFN_KODI_ADDON_PVR_CALL_EPG_MENU_HOOK_V1 call_epg_menu_hook; //--==----==----==----==----==----==----==----==----==----==----==----==----== // Recording interface functions - enum PVR_ERROR(__cdecl* GetRecordingsAmount)(const struct AddonInstance_PVR*, bool, int*); - enum PVR_ERROR(__cdecl* GetRecordings)(const struct AddonInstance_PVR*, PVR_HANDLE, bool); - enum PVR_ERROR(__cdecl* DeleteRecording)(const struct AddonInstance_PVR*, - const struct PVR_RECORDING*); - enum PVR_ERROR(__cdecl* UndeleteRecording)(const struct AddonInstance_PVR*, - const struct PVR_RECORDING*); - enum PVR_ERROR(__cdecl* DeleteAllRecordingsFromTrash)(const struct AddonInstance_PVR*); - enum PVR_ERROR(__cdecl* RenameRecording)(const struct AddonInstance_PVR*, - const struct PVR_RECORDING*); - enum PVR_ERROR(__cdecl* SetRecordingLifetime)(const struct AddonInstance_PVR*, - const struct PVR_RECORDING*); - enum PVR_ERROR(__cdecl* SetRecordingPlayCount)(const struct AddonInstance_PVR*, - const struct PVR_RECORDING*, - int); - enum PVR_ERROR(__cdecl* SetRecordingLastPlayedPosition)(const struct AddonInstance_PVR*, - const struct PVR_RECORDING*, - int); - enum PVR_ERROR(__cdecl* GetRecordingLastPlayedPosition)(const struct AddonInstance_PVR*, - const struct PVR_RECORDING*, - int*); - enum PVR_ERROR(__cdecl* GetRecordingEdl)(const struct AddonInstance_PVR*, - const struct PVR_RECORDING*, - struct PVR_EDL_ENTRY[], - int*); - enum PVR_ERROR(__cdecl* GetRecordingSize)(const struct AddonInstance_PVR*, - const PVR_RECORDING*, - int64_t*); - enum PVR_ERROR(__cdecl* GetRecordingStreamProperties)(const struct AddonInstance_PVR*, - const struct PVR_RECORDING*, - struct PVR_NAMED_VALUE*, - unsigned int*); - enum PVR_ERROR(__cdecl* CallRecordingMenuHook)(const struct AddonInstance_PVR*, - const struct PVR_MENUHOOK*, - const struct PVR_RECORDING*); + PFN_KODI_ADDON_PVR_GET_RECORDINGS_AMOUNT_V1 get_recordings_amount; + PFN_KODI_ADDON_PVR_GET_RECORDINGS_V1 get_recordings; + PFN_KODI_ADDON_PVR_DELETE_RECORDING_V1 delete_recording; + PFN_KODI_ADDON_PVR_UNDELETE_RECORDING_V1 undelete_recording; + PFN_KODI_ADDON_PVR_DELETE_ALL_RECORDINGS_FROM_TRASH_V1 delete_all_recordings_from_trash; + PFN_KODI_ADDON_PVR_RENAME_RECORDING_V1 rename_recording; + PFN_KODI_ADDON_PVR_SET_RECORDING_LIFETIME_V1 set_recording_lifetime; + PFN_KODI_ADDON_PVR_SET_RECORDING_PLAY_COUNT_V1 set_recording_play_count; + PFN_KODI_ADDON_PVR_SET_RECORDING_LAST_PLAYED_POSITION_V1 set_recording_last_played_position; + PFN_KODI_ADDON_PVR_GET_RECORDING_LAST_PLAYED_POSITION_V1 get_recording_last_played_position; + PFN_KODI_ADDON_PVR_GET_RECORDING_EDL_V1 get_recording_edl; + PFN_KODI_ADDON_PVR_GET_RECORDING_SIZE_V1 get_recording_size; + PFN_KODI_ADDON_PVR_GET_RECORDING_STREAM_PROPERTIES_V1 get_recording_stream_properties; + PFN_KODI_ADDON_PVR_CALL_RECORDING_MENU_HOOK_V1 call_recording_menu_hook; //--==----==----==----==----==----==----==----==----==----==----==----==----== // Timer interface functions - enum PVR_ERROR(__cdecl* GetTimerTypes)(const struct AddonInstance_PVR*, - struct PVR_TIMER_TYPE[], - int*); - enum PVR_ERROR(__cdecl* GetTimersAmount)(const struct AddonInstance_PVR*, int*); - enum PVR_ERROR(__cdecl* GetTimers)(const struct AddonInstance_PVR*, PVR_HANDLE); - enum PVR_ERROR(__cdecl* AddTimer)(const struct AddonInstance_PVR*, const struct PVR_TIMER*); - enum PVR_ERROR(__cdecl* DeleteTimer)(const struct AddonInstance_PVR*, - const struct PVR_TIMER*, - bool); - enum PVR_ERROR(__cdecl* UpdateTimer)(const struct AddonInstance_PVR*, const struct PVR_TIMER*); - enum PVR_ERROR(__cdecl* CallTimerMenuHook)(const struct AddonInstance_PVR*, - const struct PVR_MENUHOOK*, - const struct PVR_TIMER*); + PFN_KODI_ADDON_PVR_GET_TIMER_TYPES_V1 get_timer_types; + PFN_KODI_ADDON_PVR_GET_TIMERS_AMOUNT_V1 get_timers_amount; + PFN_KODI_ADDON_PVR_GET_TIMERS_V1 get_timers; + PFN_KODI_ADDON_PVR_ADD_TIMER_V1 add_timer; + PFN_KODI_ADDON_PVR_DELETE_TIMER_V1 delete_timer; + PFN_KODI_ADDON_PVR_UPDATE_TIMER_V1 update_timer; + PFN_KODI_ADDON_PVR_CALL_TIMER_MENU_HOOK_V1 call_timer_menu_hook; //--==----==----==----==----==----==----==----==----==----==----==----==----== // Powersaving interface functions - enum PVR_ERROR(__cdecl* OnSystemSleep)(const struct AddonInstance_PVR*); - enum PVR_ERROR(__cdecl* OnSystemWake)(const struct AddonInstance_PVR*); - enum PVR_ERROR(__cdecl* OnPowerSavingActivated)(const struct AddonInstance_PVR*); - enum PVR_ERROR(__cdecl* OnPowerSavingDeactivated)(const struct AddonInstance_PVR*); - - //--==----==----==----==----==----==----==----==----==----==----==----==----== - // Live stream read interface functions - bool(__cdecl* OpenLiveStream)(const struct AddonInstance_PVR*, const struct PVR_CHANNEL*); - void(__cdecl* CloseLiveStream)(const struct AddonInstance_PVR*); - int(__cdecl* ReadLiveStream)(const struct AddonInstance_PVR*, unsigned char*, unsigned int); - int64_t(__cdecl* SeekLiveStream)(const struct AddonInstance_PVR*, int64_t, int); - int64_t(__cdecl* LengthLiveStream)(const struct AddonInstance_PVR*); - - //--==----==----==----==----==----==----==----==----==----==----==----==----== - // Recording stream read interface functions - bool(__cdecl* OpenRecordedStream)(const struct AddonInstance_PVR*, const struct PVR_RECORDING*); - void(__cdecl* CloseRecordedStream)(const struct AddonInstance_PVR*); - int(__cdecl* ReadRecordedStream)(const struct AddonInstance_PVR*, unsigned char*, unsigned int); - int64_t(__cdecl* SeekRecordedStream)(const struct AddonInstance_PVR*, int64_t, int); - int64_t(__cdecl* LengthRecordedStream)(const struct AddonInstance_PVR*); - - //--==----==----==----==----==----==----==----==----==----==----==----==----== - // Stream demux interface functions - enum PVR_ERROR(__cdecl* GetStreamProperties)(const struct AddonInstance_PVR*, - struct PVR_STREAM_PROPERTIES*); - struct DEMUX_PACKET*(__cdecl* DemuxRead)(const struct AddonInstance_PVR*); - void(__cdecl* DemuxReset)(const struct AddonInstance_PVR*); - void(__cdecl* DemuxAbort)(const struct AddonInstance_PVR*); - void(__cdecl* DemuxFlush)(const struct AddonInstance_PVR*); - void(__cdecl* SetSpeed)(const struct AddonInstance_PVR*, int); - void(__cdecl* FillBuffer)(const struct AddonInstance_PVR*, bool); - bool(__cdecl* SeekTime)(const struct AddonInstance_PVR*, double, bool, double*); - - //--==----==----==----==----==----==----==----==----==----==----==----==----== - // General stream interface functions - bool(__cdecl* CanPauseStream)(const struct AddonInstance_PVR*); - void(__cdecl* PauseStream)(const struct AddonInstance_PVR*, bool); - bool(__cdecl* CanSeekStream)(const struct AddonInstance_PVR*); - bool(__cdecl* IsRealTimeStream)(const struct AddonInstance_PVR*); - enum PVR_ERROR(__cdecl* GetStreamTimes)(const struct AddonInstance_PVR*, - struct PVR_STREAM_TIMES*); - enum PVR_ERROR(__cdecl* GetStreamReadChunkSize)(const struct AddonInstance_PVR*, int*); - - //--==----==----==----==----==----==----==----==----==----==----==----==----== - // New functions becomes added below and can be on another API change (where - // breaks min API version) moved up. - } KodiToAddonFuncTable_PVR; - - typedef struct AddonInstance_PVR - { - struct AddonProperties_PVR* props; - struct AddonToKodiFuncTable_PVR* toKodi; - struct KodiToAddonFuncTable_PVR* toAddon; - } AddonInstance_PVR; + PFN_KODI_ADDON_PVR_ON_SYSTEM_SLEEP_V1 on_system_sleep; + PFN_KODI_ADDON_PVR_ON_SYSTEM_WAKE_V1 on_system_wake; + PFN_KODI_ADDON_PVR_ON_POWER_SAVING_ACTIVATED_V1 on_power_saving_activated; + PFN_KODI_ADDON_PVR_ON_POWER_SAVING_DEACTIVATED_V1 on_power_saving_deactivated; + } KODI_ADDON_PVR_FUNC; + + ATTR_DLL_EXPORT int kodi_addon_pvr_get_epg_max_future_days(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_addon_pvr_get_epg_max_past_days(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) + __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT void kodi_addon_pvr_add_menu_hook(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const struct PVR_MENUHOOK* hook) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_recording_notification(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* name, + const char* fileName, + bool on) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_connection_state_change(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* strConnectionString, + enum PVR_CONNECTION_STATE newState, + const char* strMessage) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_epg_event_state_change(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct EPG_TAG* tag, + enum EPG_EVENT_STATE newState) + __INTRODUCED_IN_KODI(1); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Transfer functions where give data back to Kodi, e.g. GetChannels calls TransferChannelEntry + ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_entry( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL* chan) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_provider_entry( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_PROVIDER* chanProvider) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_group( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP* group) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_group_member( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP_MEMBER* member) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_epg_entry(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct EPG_TAG* epgentry) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_recording_entry( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_RECORDING* recording) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_timer_entry(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_TIMER* timer) + __INTRODUCED_IN_KODI(1); + + //--==----==----==----==----==----==----==----==----==----==----==----==----== + // Kodi inform interface functions + ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_channel_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_providers_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_channel_groups_update( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_epg_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + unsigned int iChannelUid) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_recording_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_timer_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/screensaver.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/screensaver.h index 062390d3583b9..5322dcbd26aee 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/screensaver.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/screensaver.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2020 Team Kodi + * Copyright (C) 2005-2018 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later @@ -16,7 +16,7 @@ extern "C" { #endif /* __cplusplus */ - typedef void* KODI_ADDON_SCREENSAVER_HDL; + typedef KODI_ADDON_INSTANCE_HDL KODI_ADDON_SCREENSAVER_HDL; struct KODI_ADDON_SCREENSAVER_PROPS { @@ -28,30 +28,23 @@ extern "C" float pixelRatio; }; - typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_START_V1)( - const KODI_ADDON_SCREENSAVER_HDL hdl); - typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_STOP_V1)( - const KODI_ADDON_SCREENSAVER_HDL hdl); - typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_RENDER_V1)( - const KODI_ADDON_SCREENSAVER_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_START_V1)(const KODI_ADDON_SCREENSAVER_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_STOP_V1)(const KODI_ADDON_SCREENSAVER_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_RENDER_V1)(const KODI_ADDON_SCREENSAVER_HDL hdl); - typedef struct KodiToAddonFuncTable_Screensaver + typedef struct KODI_ADDON_SCREENSAVER_FUNC { + PFN_KODI_ADDON_INSTANCE_CREATE_V1 create; + PFN_KODI_ADDON_INSTANCE_DESTROY_V1 destroy; PFN_KODI_ADDON_SCREENSAVER_START_V1 start; PFN_KODI_ADDON_SCREENSAVER_STOP_V1 stop; PFN_KODI_ADDON_SCREENSAVER_RENDER_V1 render; - } KodiToAddonFuncTable_Screensaver; + } KODI_ADDON_SCREENSAVER_FUNC; + /*---AUTO_GEN_PARSE---*/ - typedef struct AddonToKodiFuncTable_Screensaver - { - void (*get_properties)(const KODI_HANDLE hdl, struct KODI_ADDON_SCREENSAVER_PROPS* props); - } AddonToKodiFuncTable_Screensaver; - - typedef struct AddonInstance_Screensaver - { - struct AddonToKodiFuncTable_Screensaver* toKodi; - struct KodiToAddonFuncTable_Screensaver* toAddon; - } AddonInstance_Screensaver; + ATTR_DLL_EXPORT void kodi_addon_screensaver_get_properties( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct KODI_ADDON_SCREENSAVER_PROPS* props) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/vfs.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/vfs.h index b4fd90cf32207..1d49fb07b0005 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/vfs.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/vfs.h @@ -1,5 +1,6 @@ /* - * Copyright (C) 2005-2020 Team Kodi + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later * See LICENSES/README.md for more information. @@ -11,14 +12,16 @@ #include "../addon_base.h" #include "../filesystem.h" -#define VFS_FILE_HANDLE void* - #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - struct VFSURL + typedef KODI_ADDON_INSTANCE_HDL KODI_ADDON_VFS_HDL; + typedef void* KODI_VFS_FILE_HDL; + typedef void* KODI_CTX_CB_HDL; + + struct KODI_ADDON_VFS_URL { const char* url; const char* domain; @@ -33,112 +36,124 @@ extern "C" const char* protocol; }; - typedef struct VFSGetDirectoryCallbacks /* internal */ - { - bool(__cdecl* get_keyboard_input)(KODI_HANDLE ctx, - const char* heading, - char** input, - bool hidden_input); - void(__cdecl* set_error_dialog)(KODI_HANDLE ctx, - const char* heading, - const char* line1, - const char* line2, - const char* line3); - void(__cdecl* require_authentication)(KODI_HANDLE ctx, const char* url); - KODI_HANDLE ctx; - } VFSGetDirectoryCallbacks; + typedef KODI_VFS_FILE_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_OPEN_V1)( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + typedef KODI_VFS_FILE_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_OPEN_FOR_WRITE_V1)( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, bool overwrite); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_CLOSE_V1)(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context); + typedef ssize_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_READ_V1)(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + uint8_t* buffer, + size_t buf_size); + typedef ssize_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_WRITE_V1)(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + const uint8_t* buffer, + size_t buf_size); + typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_SEEK_V1)(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t position, + int whence); + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_TRUNCATE_V1)(const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t size); + typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_GET_LENGTH_V1)( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_GET_POSITION_V1)( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_GET_CHUNK_SIZE_V1)( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_GET_SEEK_POSSIBLE_V1)( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_GET_CACHE_STATUS_V1)( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, struct VFS_CACHE_STATUS* status); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_SET_CACHE_RATE_V1)( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, uint32_t rate); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_SET_RETRY_V1)( + const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, bool retry); + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_STAT_V1)(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_STAT_STRUCTURE* buffer); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_EXISTS_V1)(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_CLEAR_OUT_IDLE_V1)(const KODI_ADDON_VFS_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DISCONNECT_ALL_V1)(const KODI_ADDON_VFS_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DELETE_IT_V1)( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_RENAME_V1)(const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + const struct KODI_ADDON_VFS_URL* url2); - typedef struct AddonProps_VFSEntry /* internal */ - { - int dummy; - } AddonProps_VFSEntry; + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_EXISTS_V1)( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_REMOVE_V1)( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_CREATE_V1)( + const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_GET_V1)( + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** entries, + size_t* num_entries, + KODI_CTX_CB_HDL ctx_cb_hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_CONTAINS_FILES_V1)( + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** entries, + size_t* num_entries, + char** rootpath); - typedef struct AddonToKodiFuncTable_VFSEntry /* internal */ + struct KODI_ADDON_VFS_FUNC { - KODI_HANDLE kodiInstance; - } AddonToKodiFuncTable_VFSEntry; + PFN_KODI_ADDON_INSTANCE_CREATE_V1 create; + PFN_KODI_ADDON_INSTANCE_DESTROY_V1 destroy; - struct AddonInstance_VFSEntry; - typedef struct KodiToAddonFuncTable_VFSEntry /* internal */ - { - KODI_HANDLE addonInstance; + PFN_KODI_ADDON_VFS_CLEAR_OUT_IDLE_V1 clear_out_idle; + PFN_KODI_ADDON_VFS_DISCONNECT_ALL_V1 disconnect_all; - VFS_FILE_HANDLE(__cdecl* open) - (const struct AddonInstance_VFSEntry* instance, const struct VFSURL* url); - VFS_FILE_HANDLE(__cdecl* open_for_write) - (const struct AddonInstance_VFSEntry* instance, const struct VFSURL* url, bool overwrite); - ssize_t(__cdecl* read)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - uint8_t* buffer, - size_t buf_size); - ssize_t(__cdecl* write)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - const uint8_t* buffer, - size_t buf_size); - int64_t(__cdecl* seek)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - int64_t position, - int whence); - int(__cdecl* truncate)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - int64_t size); - int64_t(__cdecl* get_length)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context); - int64_t(__cdecl* get_position)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context); - int(__cdecl* get_chunk_size)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context); - bool(__cdecl* io_control_get_seek_possible)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context); - bool(__cdecl* io_control_get_cache_status)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - struct VFS_CACHE_STATUS_DATA* status); - bool(__cdecl* io_control_set_cache_rate)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - uint32_t rate); - bool(__cdecl* io_control_set_retry)(const struct AddonInstance_VFSEntry* instance, - VFS_FILE_HANDLE context, - bool retry); - int(__cdecl* stat)(const struct AddonInstance_VFSEntry* instance, - const struct VFSURL* url, - struct STAT_STRUCTURE* buffer); - bool(__cdecl* close)(const struct AddonInstance_VFSEntry* instance, VFS_FILE_HANDLE context); + PFN_KODI_ADDON_VFS_FILE_OPEN_V1 file_open; + PFN_KODI_ADDON_VFS_FILE_OPEN_FOR_WRITE_V1 file_open_for_write; + PFN_KODI_ADDON_VFS_FILE_CLOSE_V1 file_close; + PFN_KODI_ADDON_VFS_FILE_READ_V1 file_read; + PFN_KODI_ADDON_VFS_FILE_WRITE_V1 file_write; + PFN_KODI_ADDON_VFS_FILE_SEEK_V1 file_seek; + PFN_KODI_ADDON_VFS_FILE_TRUNCATE_V1 file_truncate; + PFN_KODI_ADDON_VFS_FILE_GET_LENGTH_V1 file_get_length; + PFN_KODI_ADDON_VFS_FILE_GET_POSITION_V1 file_get_position; + PFN_KODI_ADDON_VFS_FILE_GET_CHUNK_SIZE_V1 file_get_chunk_size; + PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_GET_SEEK_POSSIBLE_V1 file_io_control_get_seek_possible; + PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_GET_CACHE_STATUS_V1 file_io_control_get_cache_status; + PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_SET_CACHE_RATE_V1 file_io_control_set_cache_rate; + PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_SET_RETRY_V1 file_io_control_set_retry; - bool(__cdecl* exists)(const struct AddonInstance_VFSEntry* instance, const struct VFSURL* url); - void(__cdecl* clear_out_idle)(const struct AddonInstance_VFSEntry* instance); - void(__cdecl* disconnect_all)(const struct AddonInstance_VFSEntry* instance); - bool(__cdecl* delete_it)(const struct AddonInstance_VFSEntry* instance, - const struct VFSURL* url); - bool(__cdecl* rename)(const struct AddonInstance_VFSEntry* instance, - const struct VFSURL* url, - const struct VFSURL* url2); - bool(__cdecl* directory_exists)(const struct AddonInstance_VFSEntry* instance, - const struct VFSURL* url); - bool(__cdecl* remove_directory)(const struct AddonInstance_VFSEntry* instance, - const struct VFSURL* url); - bool(__cdecl* create_directory)(const struct AddonInstance_VFSEntry* instance, - const struct VFSURL* url); - bool(__cdecl* get_directory)(const struct AddonInstance_VFSEntry* instance, - const struct VFSURL* url, - struct VFSDirEntry** entries, - int* num_entries, - struct VFSGetDirectoryCallbacks* callbacks); - bool(__cdecl* contains_files)(const struct AddonInstance_VFSEntry* instance, - const struct VFSURL* url, - struct VFSDirEntry** entries, - int* num_entries, - char* rootpath); - void(__cdecl* free_directory)(const struct AddonInstance_VFSEntry* instance, - struct VFSDirEntry* entries, - int num_entries); - } KodiToAddonFuncTable_VFSEntry; + PFN_KODI_ADDON_VFS_STAT_V1 stat; + PFN_KODI_ADDON_VFS_EXISTS_V1 exists; + PFN_KODI_ADDON_VFS_DELETE_IT_V1 delete_it; + PFN_KODI_ADDON_VFS_RENAME_V1 rename; - typedef struct AddonInstance_VFSEntry /* internal */ - { - struct AddonProps_VFSEntry* props; - struct AddonToKodiFuncTable_VFSEntry* toKodi; - struct KodiToAddonFuncTable_VFSEntry* toAddon; - } AddonInstance_VFSEntry; + PFN_KODI_ADDON_VFS_DIRECTORY_EXISTS_V1 directory_exists; + PFN_KODI_ADDON_VFS_DIRECTORY_REMOVE_V1 directory_remove; + PFN_KODI_ADDON_VFS_DIRECTORY_CREATE_V1 directory_create; + PFN_KODI_ADDON_VFS_DIRECTORY_GET_V1 directory_get; + PFN_KODI_ADDON_VFS_DIRECTORY_CONTAINS_FILES_V1 directory_contains_files; + }; + + ATTR_DLL_EXPORT bool kodi_addon_vfs_get_dir_cb__get_keyboard_input( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_CTX_CB_HDL ctx_cb_hdl, + const char* heading, + char** input, + bool hidden_input) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_vfs_get_dir_cb__set_error_dialog( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_CTX_CB_HDL ctx_cb_hdl, + const char* heading, + const char* line1, + const char* line2, + const char* line3) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_vfs_get_dir_cb__require_authentication( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_CTX_CB_HDL ctx_cb_hdl, const char* url) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/video_codec.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/videocodec.h similarity index 72% rename from xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/video_codec.h rename to xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/videocodec.h index 98a32f2db4ab7..570fb3103f63d 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/video_codec.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/videocodec.h @@ -1,11 +1,13 @@ /* - * Copyright (C) 2017-2018 Team Kodi + * Copyright (C) 2005-2018 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later * See LICENSES/README.md for more information. */ +/*---AUTO_GEN_PARSE---*/ + #ifndef C_API_ADDONINSTANCE_VIDEOCODEC_H #define C_API_ADDONINSTANCE_VIDEOCODEC_H @@ -19,6 +21,8 @@ extern "C" { #endif /* __cplusplus */ + typedef void* KODI_ADDON_VIDEOCODEC_HDL; + //============================================================================ /// @ingroup cpp_kodi_addon_videocodec_Defs /// @brief Return values used by video decoder interface @@ -148,7 +152,7 @@ extern "C" { /// @brief The video format declared with @ref VIDEOCODEC_FORMAT and to be /// used on the addon. - enum VIDEOCODEC_FORMAT videoFormat; + enum VIDEOCODEC_FORMAT video_format; /// @brief Video coded process flags, used to perform special operations in /// stream calls. @@ -163,16 +167,16 @@ extern "C" uint32_t height; /// @brief Data to be decoded in the addon. - uint8_t* decodedData; + uint8_t* decoded_data; /// @brief Size of the data given with @ref decodedData - size_t decodedDataSize; + size_t decoded_data_size; /// @brief YUV color plane calculation array. /// /// This includes the three values of the YUV and can be identified using /// @ref VIDEOCODEC_PLANE. - uint32_t planeOffsets[VIDEOCODEC_PICTURE_MAXPLANES]; + uint32_t plane_offsets[VIDEOCODEC_PICTURE_MAXPLANES]; /// @brief YUV color stride calculation array /// @@ -188,7 +192,7 @@ extern "C" /// To handle the input stream buffer, this is given by Kodi using /// @ref kodi::addon::CInstanceVideoCodec::GetFrameBuffer and must be /// released again using @ref kodi::addon::CInstanceVideoCodec::ReleaseFrameBuffer. - KODI_HANDLE videoBufferHandle; + KODI_OWN_HDL video_buffer_handle; }; ///@} //---------------------------------------------------------------------------- @@ -196,63 +200,51 @@ extern "C" struct VIDEOCODEC_INITDATA { enum VIDEOCODEC_TYPE codec; - enum STREAMCODEC_PROFILE codecProfile; - enum VIDEOCODEC_FORMAT* videoFormats; + enum STREAMCODEC_PROFILE codec_profile; + enum VIDEOCODEC_FORMAT* video_formats; uint32_t width; uint32_t height; - const uint8_t* extraData; - unsigned int extraDataSize; - struct STREAM_CRYPTO_SESSION cryptoSession; + const uint8_t* extra_data; + unsigned int extra_data_size; + struct STREAM_CRYPTO_SESSION crypto_session; }; - // this are properties given to the addon on create - // at this time we have no parameters for the addon - typedef struct AddonProps_VideoCodec - { - int dummy; - } AddonProps_VideoCodec; - - struct AddonInstance_VideoCodec; - typedef struct KodiToAddonFuncTable_VideoCodec - { - KODI_HANDLE addonInstance; - - //! @brief Opens a codec - bool(__cdecl* open)(const struct AddonInstance_VideoCodec* instance, - struct VIDEOCODEC_INITDATA* initData); - - //! @brief Reconfigures a codec - bool(__cdecl* reconfigure)(const struct AddonInstance_VideoCodec* instance, - struct VIDEOCODEC_INITDATA* initData); - - //! @brief Feed codec if requested from GetPicture() (return VC_BUFFER) - bool(__cdecl* add_data)(const struct AddonInstance_VideoCodec* instance, - const struct DEMUX_PACKET* packet); + typedef KODI_ADDON_VIDEOCODEC_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_CREATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_DESTROY_V1)(KODI_ADDON_VIDEOCODEC_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_OPEN_V1)( + KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_INITDATA* initData); - //! @brief Get a decoded picture / request new data - enum VIDEOCODEC_RETVAL(__cdecl* get_picture)(const struct AddonInstance_VideoCodec* instance, - struct VIDEOCODEC_PICTURE* picture); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_RECONFIGURE_V1)( + KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_INITDATA* initData); - //! @brief Get the name of this video decoder - const char*(__cdecl* get_name)(const struct AddonInstance_VideoCodec* instance); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_ADD_DATA_V1)( + KODI_ADDON_VIDEOCODEC_HDL hdl, const struct DEMUX_PACKET* packet); - //! @brief Reset the codec - void(__cdecl* reset)(const struct AddonInstance_VideoCodec* instance); - } KodiToAddonFuncTable_VideoCodec; - - typedef struct AddonToKodiFuncTable_VideoCodec - { - KODI_HANDLE kodiInstance; - bool (*get_frame_buffer)(void* kodiInstance, struct VIDEOCODEC_PICTURE* picture); - void (*release_frame_buffer)(void* kodiInstance, void* buffer); - } AddonToKodiFuncTable_VideoCodec; + typedef enum VIDEOCODEC_RETVAL(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_GET_PICTURE_V1)( + KODI_ADDON_VIDEOCODEC_HDL hdl, struct VIDEOCODEC_PICTURE* picture); + typedef const char*(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_GET_NAME_V1)( + KODI_ADDON_VIDEOCODEC_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_RESET_V1)(KODI_ADDON_VIDEOCODEC_HDL hdl); - typedef struct AddonInstance_VideoCodec + typedef struct KODI_ADDON_VIDEOCODEC_FUNC { - struct AddonProps_VideoCodec* props; - struct AddonToKodiFuncTable_VideoCodec* toKodi; - struct KodiToAddonFuncTable_VideoCodec* toAddon; - } AddonInstance_VideoCodec; + PFN_KODI_ADDON_VIDEOCODEC_CREATE_V1 create; + PFN_KODI_ADDON_VIDEOCODEC_DESTROY_V1 destroy; + PFN_KODI_ADDON_VIDEOCODEC_OPEN_V1 open; + PFN_KODI_ADDON_VIDEOCODEC_RECONFIGURE_V1 reconfigure; + PFN_KODI_ADDON_VIDEOCODEC_ADD_DATA_V1 add_data; + PFN_KODI_ADDON_VIDEOCODEC_GET_PICTURE_V1 get_picture; + PFN_KODI_ADDON_VIDEOCODEC_GET_NAME_V1 get_name; + PFN_KODI_ADDON_VIDEOCODEC_RESET_V1 reset; + } KODI_ADDON_VIDEOCODEC_FUNC; + + ATTR_DLL_EXPORT bool kodi_addon_videocodec_get_frame_buffer(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct VIDEOCODEC_PICTURE* picture) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_videocodec_release_frame_buffer( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct VIDEOCODEC_PICTURE* picture) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/visualization.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/visualization.h index 616e0a8666432..a88d937065be2 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/visualization.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/visualization.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2020 Team Kodi + * Copyright (C) 2005-2018 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later @@ -11,31 +11,25 @@ #include "../addon_base.h" -#define VIZ_LYRICS_SIZE 32768 - #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - struct VIS_INFO - { - bool bWantsFreq; - int iSyncDelay; - }; + typedef KODI_ADDON_INSTANCE_HDL KODI_ADDON_VISUALIZATION_HDL; - struct VIS_TRACK + struct KODI_ADDON_VISUALIZATION_TRACK { - const char *title; - const char *artist; - const char *album; - const char *albumArtist; - const char *genre; - const char *comment; - const char *lyrics; + const char* title; + const char* artist; + const char* album; + const char* albumArtist; + const char* genre; + const char* comment; + const char* lyrics; - const char *reserved1; - const char *reserved2; + const char* reserved1; + const char* reserved2; int trackNumber; int discNumber; @@ -47,7 +41,7 @@ extern "C" int reserved4; }; - typedef struct AddonProps_Visualization + struct KODI_ADDON_VISUALIZATION_PROPS { ADDON_HARDWARE_CONTEXT device; int x; @@ -55,63 +49,90 @@ extern "C" int width; int height; float pixelRatio; - const char* name; - const char* presets; - const char* profile; - } AddonProps_Visualization; - - typedef struct AddonToKodiFuncTable_Visualization - { - KODI_HANDLE kodiInstance; - void(__cdecl* transfer_preset)(KODI_HANDLE kodiInstance, const char* preset); - void(__cdecl* clear_presets)(KODI_HANDLE kodiInstance); - } AddonToKodiFuncTable_Visualization; - - struct AddonInstance_Visualization; + }; - typedef struct KodiToAddonFuncTable_Visualization - { - KODI_HANDLE addonInstance; - bool(__cdecl* start)(const struct AddonInstance_Visualization* instance, - int channels, - int samples_per_sec, - int bits_per_sample, - const char* song_name); - void(__cdecl* stop)(const struct AddonInstance_Visualization* instance); - - void(__cdecl* get_info)(const struct AddonInstance_Visualization* instance, - struct VIS_INFO* info); - - void(__cdecl* audio_data)(const struct AddonInstance_Visualization* instance, - const float* audio_data, - int audio_data_length, - float* freq_data, - int freq_data_length); - bool(__cdecl* is_dirty)(const struct AddonInstance_Visualization* instance); - void(__cdecl* render)(const struct AddonInstance_Visualization* instance); - - unsigned int(__cdecl* get_presets)(const struct AddonInstance_Visualization* instance); - int(__cdecl* get_active_preset)(const struct AddonInstance_Visualization* instance); - bool(__cdecl* prev_preset)(const struct AddonInstance_Visualization* instance); - bool(__cdecl* next_preset)(const struct AddonInstance_Visualization* instance); - bool(__cdecl* load_preset)(const struct AddonInstance_Visualization* instance, int select); - bool(__cdecl* random_preset)(const struct AddonInstance_Visualization* instance); - bool(__cdecl* lock_preset)(const struct AddonInstance_Visualization* instance); - bool(__cdecl* rate_preset)(const struct AddonInstance_Visualization* instance, bool plus_minus); - bool(__cdecl* is_locked)(const struct AddonInstance_Visualization* instance); - - bool(__cdecl* update_albumart)(const struct AddonInstance_Visualization* instance, - const char* albumart); - bool(__cdecl* update_track)(const struct AddonInstance_Visualization* instance, - const struct VIS_TRACK* track); - } KodiToAddonFuncTable_Visualization; - - typedef struct AddonInstance_Visualization + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_START_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl, + int channels, + int samples_per_sec, + int bits_per_sample, + const char* song_name); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_STOP_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_GET_SYNC_DELAY_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_AUDIO_DATA_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl, + const float* audio_data, + size_t audio_data_length); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_IS_DIRTY_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_RENDER_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + + typedef unsigned int(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_GET_PRESETS_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_GET_ACTIVE_PRESET_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_PREV_PRESET_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_NEXT_PRESET_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_LOAD_PRESET_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl, int select); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_RANDOM_PRESET_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_LOCK_PRESET_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_RATE_PRESET_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl, bool plus_minus); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_IS_LOCKED_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl); + + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_UPDATE_ALBUMART_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl, const char* albumart); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_UPDATE_TRACK_V1)( + const KODI_ADDON_VISUALIZATION_HDL hdl, const struct KODI_ADDON_VISUALIZATION_TRACK* track); + + typedef struct KODI_ADDON_VISUALIZATION_FUNC { - struct AddonProps_Visualization* props; - struct AddonToKodiFuncTable_Visualization* toKodi; - struct KodiToAddonFuncTable_Visualization* toAddon; - } AddonInstance_Visualization; + PFN_KODI_ADDON_INSTANCE_CREATE_V1 create; + PFN_KODI_ADDON_INSTANCE_DESTROY_V1 destroy; + PFN_KODI_ADDON_VISUALIZATION_START_V1 start; + PFN_KODI_ADDON_VISUALIZATION_STOP_V1 stop; + + PFN_KODI_ADDON_VISUALIZATION_GET_SYNC_DELAY_V1 get_sync_delay; + + PFN_KODI_ADDON_VISUALIZATION_AUDIO_DATA_V1 audio_data; + PFN_KODI_ADDON_VISUALIZATION_IS_DIRTY_V1 is_dirty; + PFN_KODI_ADDON_VISUALIZATION_RENDER_V1 render; + + PFN_KODI_ADDON_VISUALIZATION_GET_PRESETS_V1 get_presets; + PFN_KODI_ADDON_VISUALIZATION_GET_ACTIVE_PRESET_V1 get_active_preset; + PFN_KODI_ADDON_VISUALIZATION_PREV_PRESET_V1 prev_preset; + PFN_KODI_ADDON_VISUALIZATION_NEXT_PRESET_V1 next_preset; + PFN_KODI_ADDON_VISUALIZATION_LOAD_PRESET_V1 load_preset; + PFN_KODI_ADDON_VISUALIZATION_RANDOM_PRESET_V1 random_preset; + PFN_KODI_ADDON_VISUALIZATION_LOCK_PRESET_V1 lock_preset; + PFN_KODI_ADDON_VISUALIZATION_RATE_PRESET_V1 rate_preset; + PFN_KODI_ADDON_VISUALIZATION_IS_LOCKED_V1 is_locked; + + PFN_KODI_ADDON_VISUALIZATION_UPDATE_ALBUMART_V1 update_albumart; + PFN_KODI_ADDON_VISUALIZATION_UPDATE_TRACK_V1 update_track; + } KODI_ADDON_VISUALIZATION_FUNC; + /*---AUTO_GEN_PARSE---*/ + + ATTR_DLL_EXPORT void kodi_addon_visualization_get_properties(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct KODI_ADDON_VISUALIZATION_PROPS* props) + __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT void kodi_addon_visualization_transfer_preset(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* preset) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_visualization_clear_presets(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/web.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/web.h new file mode 100644 index 0000000000000..181272a25b4be --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon-instance/web.h @@ -0,0 +1,341 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#ifndef C_API_ADDONINSTANCE_WEB_H +#define C_API_ADDONINSTANCE_WEB_H + +#include "../addon_base.h" + +#define WEB_TYPE_ID_BROWSER 0 +#define WEB_MAX_NAME_STRING_SIZE 80 + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#if __KODI_API__ >= 1 + + typedef KODI_ADDON_INSTANCE_HDL KODI_ADDON_WEB_HDL; + typedef void* KODI_ADDON_WEB_CONTROL_HDL; + typedef void* WEB_KODI_CONTROL; + + //============================================================================ + /// @brief Web add-on error codes + /// + enum WEB_ADDON_ERROR + { + /// @brief if something was go complete wrong + WEB_ADDON_ERROR_PERMANENT_FAILED = -7, + + /// @brief the command failed + WEB_ADDON_ERROR_FAILED = -6, + + /// @brief the parameters of the method that was called are invalid for this operation + WEB_ADDON_ERROR_INVALID_PARAMETERS = -5, + + /// @brief the command was rejected by the addon + WEB_ADDON_ERROR_REJECTED = -4, + + /// @brief the method that KODI called is not implemented by the add-on + WEB_ADDON_ERROR_NOT_IMPLEMENTED = -3, + + /// @brief an unknown error occurred + WEB_ADDON_ERROR_UNKNOWN = -2, + + /// @brief no error occurred, but existing part reopened + WEB_ADDON_ERROR_NO_ERROR_REOPEN = -1, + + /// @brief no error occurred + WEB_ADDON_ERROR_NO_ERROR = 0, + }; + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief + typedef enum WEB_KEY_MOD + { + /// @brief + WEB_KEY_MOD_NONE = 0x0000, + + /// @brief + WEB_KEY_MOD_SHIFT = 0x0001, + + /// @brief + WEB_KEY_MOD_CTRL = 0x0002, + + /// @brief + WEB_KEY_MOD_ALT = 0x0004, + + /// @brief + WEB_KEY_MOD_META = 0x0008, + + /// @brief + WEB_KEY_MOD_SUPER = 0x0010, + + /// @brief + WEB_KEY_MOD_NUMLOCK = 0x0100, + + /// @brief + WEB_KEY_MOD_CAPSLOCK = 0x0200, + + /// @brief + WEB_KEY_MOD_SCROLLOCK = 0x0400, + } WEB_KEY_MOD; + //---------------------------------------------------------------------------- + + typedef struct WEB_KEYBOARD_INPUT_EVENT + { + const char* controller_id; + const char* feature_name; + bool pressed; + uint32_t unicode; + enum WEB_KEY_MOD modifiers; + } WEB_KEYBOARD_INPUT_EVENT; + + /*! + * @brief Type defination structure + */ + typedef struct WEB_ADDON_VARIOUS_TYPE + { + const char* strName; + int iAddonInternalId; + int iType; + } WEB_ADDON_VARIOUS_TYPE; + + /*! + * @brief Web addon gui control handle data + */ + typedef struct WEB_ADDON_GUI_PROPS + { + /*! + * @brief identify name of related control to know on next open + */ + char strName[WEB_MAX_NAME_STRING_SIZE]; + + /*! + * @brief Used render device, NULL for OpenGL and only be used for DirectX + */ + ADDON_HARDWARE_CONTEXT pDevice; + + /*! + * @brief For GUI control used render positions and sizes + */ + float fXPos; + float fYPos; + float fWidth; + float fHeight; + float fPixelRatio; + float fFPS; + + /*! + * @brief For GUI control used positions and sizes on skin + */ + float fSkinXPos; + float fSkinYPos; + float fSkinWidth; + float fSkinHeight; + + /*! + * @brief If set the opened control becomes handled transparent with the + * color value given on iBackgroundColorARGB + */ + bool bUseTransparentBackground; + + /*! + * @brief The wanted background color on opened control. + * + * If bUseTransparentBackground is false it is the background during empty + * control (Webside not loaded) + * If bUseTransparentBackground is true then it set the transparency color + * of the handled control + */ + uint32_t iBackgroundColorARGB; + + /*! + * @brief The id's from control outside of the web GUI render control. + * Used with OnAction to inform about next GUI item to select if inside + * control a point comes to the end. + */ + int iGUIItemLeft; + int iGUIItemRight; + int iGUIItemTop; + int iGUIItemBottom; + int iGUIItemBack; + + /*! + * @brief Identifier of the control on Kodi. Required to have on callbacks, + * must set by callback functions on WEB_KODI_CONTROL::dataAddress with this! + */ + WEB_KODI_CONTROL pControlIdent; + } WEB_ADDON_GUI_PROPS; + + struct ADDON_HANDLE_STRUCT + { + void* callerAddress; /*!< address of the caller */ + void* dataAddress; /*!< address to store data in */ + int dataIdentifier; /*!< parameter to pass back when calling the callback */ + }; + + struct KODI_ADDON_ACTION_DATA; + + typedef enum WEB_ADDON_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_START_INSTANCE_V1)(const KODI_ADDON_WEB_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_STOP_INSTANCE_V1)(const KODI_ADDON_WEB_HDL hdl); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_MAIN_INITIALIZE_V1)(const KODI_ADDON_WEB_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_MAIN_LOOP_V1)(const KODI_ADDON_WEB_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_MAIN_SHUTDOWN_V1)(const KODI_ADDON_WEB_HDL hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_SET_MUTE_V1)(const KODI_ADDON_WEB_HDL hdl, bool mute); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_SET_LANGUAGE_V1)(const KODI_ADDON_WEB_HDL hdl, + const char* language); + + typedef enum WEB_ADDON_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CREATE_CONTROL_V1)(const KODI_ADDON_WEB_HDL hdl, + const struct WEB_ADDON_GUI_PROPS* props, + const char* start_url, + WEB_KODI_CONTROL* handle); + typedef enum WEB_ADDON_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_DESTROY_CONTROL_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + bool complete); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_RENDER_INIT_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_RENDER_DEINIT_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_RENDER_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_DIRTY_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_ON_INIT_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_ON_ACTION_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const struct KODI_ADDON_ACTION_DATA* action, + int* nextItem); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_ON_MOUSE_EVENT_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + int id, + double x, + double y, + double offsetX, + double offsetY, + int state); + + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_OPEN_WEBSITE_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* url); + typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_GET_HISTORY_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + char*** list, + size_t* entries, + bool behind_current); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SEARCH_TEXT_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* text, + bool forward, + bool matchCase, + bool findNext); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_STOP_SEARCH_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + bool clearSelection); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_RELOAD_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_STOP_LOAD_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_NAV_BACK_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_NAV_FORWARD_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_OPEN_OWN_CONTEXT_MENU_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SCREEN_SIZE_CHANGE_V1)(const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + float x, + float y, + float width, + float height, + bool fullscreen); + + struct KODI_ADDON_WEB_FUNC + { + PFN_KODI_ADDON_INSTANCE_CREATE_V1 create; + PFN_KODI_ADDON_INSTANCE_DESTROY_V1 destroy; + + PFN_KODI_ADDON_WEB_START_INSTANCE_V1 start_instance; + PFN_KODI_ADDON_WEB_STOP_INSTANCE_V1 stop_instance; + PFN_KODI_ADDON_WEB_MAIN_INITIALIZE_V1 main_initialize; + PFN_KODI_ADDON_WEB_MAIN_LOOP_V1 main_loop; + PFN_KODI_ADDON_WEB_MAIN_SHUTDOWN_V1 main_shutdown; + PFN_KODI_ADDON_WEB_SET_MUTE_V1 set_mute; + PFN_KODI_ADDON_WEB_SET_LANGUAGE_V1 set_language; + + PFN_KODI_ADDON_WEB_CREATE_CONTROL_V1 create_control; + PFN_KODI_ADDON_WEB_DESTROY_CONTROL_V1 destroy_control; + PFN_KODI_ADDON_WEB_CONTROL_RENDER_INIT_V1 control_render_init; + PFN_KODI_ADDON_WEB_CONTROL_RENDER_DEINIT_V1 control_render_deinit; + PFN_KODI_ADDON_WEB_CONTROL_RENDER_V1 control_render; + PFN_KODI_ADDON_WEB_CONTROL_DIRTY_V1 control_dirty; + PFN_KODI_ADDON_WEB_CONTROL_ON_INIT_V1 control_on_init; + PFN_KODI_ADDON_WEB_CONTROL_ON_ACTION_V1 control_on_action; + PFN_KODI_ADDON_WEB_CONTROL_ON_MOUSE_EVENT_V1 control_on_mouse_event; + + PFN_KODI_ADDON_WEB_CONTROL_OPEN_WEBSITE_V1 control_open_website; + PFN_KODI_ADDON_WEB_CONTROL_GET_HISTORY_V1 control_get_history; + PFN_KODI_ADDON_WEB_CONTROL_SEARCH_TEXT_V1 control_search_text; + PFN_KODI_ADDON_WEB_CONTROL_STOP_SEARCH_V1 control_stop_search; + PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_RELOAD_V1 control_web_cmd_reload; + PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_STOP_LOAD_V1 control_web_cmd_stop_load; + PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_NAV_BACK_V1 control_web_cmd_nav_back; + PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_NAV_FORWARD_V1 control_web_cmd_nav_forward; + PFN_KODI_ADDON_WEB_CONTROL_WEB_OPEN_OWN_CONTEXT_MENU_V1 control_web_open_own_context_menu; + PFN_KODI_ADDON_WEB_CONTROL_SCREEN_SIZE_CHANGE_V1 control_screen_size_change; + }; + /*---AUTO_GEN_PARSE---*/ + + ATTR_DLL_EXPORT void kodi_addon_web_inhibit_shutdown(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + bool inhibit); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_web_inhibit_screensaver(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + bool inhibit); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_web_is_muted(KODI_ADDON_INSTANCE_BACKEND_HDL hdl); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_web_control_set_control_ready(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool ready); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_web_control_set_opened_address(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* title); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_web_control_set_opened_title(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* title); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_web_control_set_icon_url(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* icon); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_web_control_set_fullscreen(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool fullscreen); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_web_control_set_loading_state(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool isLoading, + bool canGoBack, + bool canGoForward); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_web_control_set_tooltip(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* tooltip); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_web_control_set_status_message(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* status); __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_addon_web_control_request_open_site_in_new_tab(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* url); __INTRODUCED_IN_KODI(1); + + +#endif /* __KODI_API__ >= 1 */ + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* !C_API_ADDONINSTANCE_WEB_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon_base.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon_base.h index ca0e4416e71b7..ad383961a12b4 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon_base.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/addon_base.h @@ -1,20 +1,23 @@ /* - * Copyright (C) 2005-2019 Team Kodi + * Copyright (C) 2005-2020 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later * See LICENSES/README.md for more information. */ -#ifndef C_API_ADDON_BASE_H -#define C_API_ADDON_BASE_H +#ifndef C_API_ADDON_H +#define C_API_ADDON_H #if !defined(NOMINMAX) #define NOMINMAX #endif -#include "stdbool.h" -#include "stdint.h" +#include "version.h" + +#include +#include +#include #ifndef TARGET_WINDOWS #ifndef __cdecl @@ -74,8 +77,12 @@ #if __GNUC__ >= 4 #define ATTR_DLL_IMPORT __attribute__((visibility("default"))) #define ATTR_DLL_EXPORT __attribute__((visibility("default"))) +#ifndef SWIG #define ATTR_DLL_LOCAL __attribute__((visibility("hidden"))) #else +#define ATTR_DLL_LOCAL +#endif +#else #define ATTR_DLL_IMPORT #define ATTR_DLL_EXPORT #define ATTR_DLL_LOCAL @@ -100,26 +107,23 @@ typedef intptr_t ssize_t; #include #endif // TARGET_POSIX -// Hardware specific device context interface -#define ADDON_HARDWARE_CONTEXT void* - -/* - * To have a on add-on and kodi itself handled string always on known size! - */ -#define ADDON_STANDARD_STRING_LENGTH 1024 -#define ADDON_STANDARD_STRING_LENGTH_SMALL 256 - #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ +#if __KODI_API__ >= 1 + + typedef void* KODI_HANDLE; + typedef void* KODI_DLL_HDL; + typedef void* KODI_OWN_HDL; + typedef void* KODI_IFC_HDL; typedef void* KODI_ADDON_HDL; typedef void* KODI_ADDON_BACKEND_HDL; typedef void* KODI_ADDON_INSTANCE_HDL; typedef void* KODI_ADDON_INSTANCE_BACKEND_HDL; - typedef void* KODI_ADDON_FUNC_DUMMY; + typedef void* ADDON_HARDWARE_CONTEXT; //============================================================================ /// @ingroup cpp_kodi_addon_addonbase_Defs @@ -131,30 +135,14 @@ extern "C" ///@{ typedef enum ADDON_STATUS { - /// @brief For everything OK and no error ADDON_STATUS_OK, - - /// @brief A needed connection was lost ADDON_STATUS_LOST_CONNECTION, - - /// @brief Addon needs a restart inside Kodi ADDON_STATUS_NEED_RESTART, - - /// @brief Necessary settings are not yet set ADDON_STATUS_NEED_SETTINGS, - - /// @brief Unknown and incomprehensible error ADDON_STATUS_UNKNOWN, - - /// @brief Permanent failure, like failing to resolve methods ADDON_STATUS_PERMANENT_FAILURE, - - /* internal used return error if function becomes not used from child on - * addon */ ADDON_STATUS_NOT_IMPLEMENTED } ADDON_STATUS; - ///@} - //---------------------------------------------------------------------------- //============================================================================ /// @defgroup cpp_kodi_Defs_ADDON_LOG enum ADDON_LOG @@ -175,172 +163,66 @@ extern "C" ///@{ typedef enum ADDON_LOG { - /// @brief **0** : To include debug information in the log file. ADDON_LOG_DEBUG = 0, - - /// @brief **1** : To include information messages in the log file. ADDON_LOG_INFO = 1, - - /// @brief **2** : To write warnings in the log file. ADDON_LOG_WARNING = 2, - - /// @brief **3** : To report error messages in the log file. ADDON_LOG_ERROR = 3, - - /// @brief **4** : To notify fatal unrecoverable errors, which can may also indicate - /// upcoming crashes. ADDON_LOG_FATAL = 4 } ADDON_LOG; ///@} //---------------------------------------------------------------------------- - typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_STRING_V1)( - const KODI_ADDON_INSTANCE_HDL hdl, const char* name, const char* value); - typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_BOOLEAN_V1)( - const KODI_ADDON_INSTANCE_HDL hdl, const char* name, bool value); - typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_INTEGER_V1)( - const KODI_ADDON_INSTANCE_HDL hdl, const char* name, int value); - typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_FLOAT_V1)( - const KODI_ADDON_INSTANCE_HDL hdl, const char* name, float value); - - typedef struct KODI_ADDON_INSTANCE_FUNC - { - PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_STRING_V1 instance_setting_change_string; - PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_BOOLEAN_V1 instance_setting_change_boolean; - PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_INTEGER_V1 instance_setting_change_integer; - PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_FLOAT_V1 instance_setting_change_float; - } KODI_ADDON_INSTANCE_FUNC; - - typedef struct KODI_ADDON_INSTANCE_FUNC_CB + typedef enum KODI_ADDON_INSTANCE_TYPE { - char* (*get_instance_user_path)(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl); - bool (*is_instance_setting_using_default)(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id); - - bool (*get_instance_setting_bool)(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - bool* value); - bool (*get_instance_setting_int)(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - int* value); - bool (*get_instance_setting_float)(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - float* value); - bool (*get_instance_setting_string)(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - char** value); - - bool (*set_instance_setting_bool)(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - bool value); - bool (*set_instance_setting_int)(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - int value); - bool (*set_instance_setting_float)(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - float value); - bool (*set_instance_setting_string)(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, - const char* id, - const char* value); - } KODI_ADDON_INSTANCE_FUNC_CB; - - typedef int KODI_ADDON_INSTANCE_TYPE; + ADDON_INSTANCE_UNKNOWN = 0, + ADDON_INSTANCE_AUDIODECODER, + ADDON_INSTANCE_AUDIOENCODER, + ADDON_INSTANCE_GAME, + ADDON_INSTANCE_INPUTSTREAM, + ADDON_INSTANCE_PERIPHERAL, + ADDON_INSTANCE_PVR, + ADDON_INSTANCE_SCREENSAVER, + ADDON_INSTANCE_VISUALIZATION, + ADDON_INSTANCE_VFS, + ADDON_INSTANCE_IMAGEDECODER, + ADDON_INSTANCE_VIDEOCODEC, + ADDON_INSTANCE_WEB, + } KODI_ADDON_INSTANCE_TYPE; struct KODI_ADDON_INSTANCE_INFO { - KODI_ADDON_INSTANCE_TYPE type; - uint32_t number; - const char* id; - const char* version; + enum KODI_ADDON_INSTANCE_TYPE type; + uint32_t instance_id; + const char* unique_work_id; KODI_ADDON_INSTANCE_BACKEND_HDL kodi; KODI_ADDON_INSTANCE_HDL parent; - bool first_instance; - - struct KODI_ADDON_INSTANCE_FUNC_CB* functions; }; + /*---AUTO_GEN_PARSE---*/ - typedef struct KODI_ADDON_INSTANCE_STRUCT + struct KODI_ADDON_INSTANCE_STRUCT { - const KODI_ADDON_INSTANCE_INFO* info; - KODI_ADDON_INSTANCE_HDL hdl; - struct KODI_ADDON_INSTANCE_FUNC* functions; - union { - KODI_ADDON_FUNC_DUMMY dummy; - struct AddonInstance_AudioDecoder* audiodecoder; - struct AddonInstance_AudioEncoder* audioencoder; - struct AddonInstance_ImageDecoder* imagedecoder; - struct AddonInstance_Game* game; - struct AddonInstance_InputStream* inputstream; - struct AddonInstance_Peripheral* peripheral; - struct AddonInstance_PVR* pvr; - struct AddonInstance_Screensaver* screensaver; - struct AddonInstance_VFSEntry* vfs; - struct AddonInstance_VideoCodec* videocodec; - struct AddonInstance_Visualization* visualization; + union + { + KODI_HANDLE dummy; + struct KODI_ADDON_INSTANCE_FUNC* instance; + struct KODI_ADDON_AUDIODECODER_FUNC* audiodecoder; + struct KODI_ADDON_AUDIOENCODER_FUNC* audioencoder; + struct KODI_ADDON_IMAGEDECODER_FUNC* imagedecoder; + struct KODI_ADDON_GAME_FUNC* game; + struct KODI_ADDON_INPUTSTREAM_FUNC* inputstream; + struct KODI_ADDON_PERIPHERAL_FUNC* peripheral; + struct KODI_ADDON_SCREENSAVER_FUNC* screensaver; + struct KODI_ADDON_VFS_FUNC* vfs; + struct KODI_ADDON_VIDEOCODEC_FUNC* videocodec; + struct KODI_ADDON_VISUALIZATION_FUNC* visualization; + struct KODI_ADDON_WEB_FUNC* web; }; - } KODI_ADDON_INSTANCE_STRUCT; - - /*! @brief Standard undefined pointer handle */ - typedef void* KODI_HANDLE; - - typedef struct AddonToKodiFuncTable_kodi_addon - { - char* (*get_addon_path)(const KODI_ADDON_BACKEND_HDL hdl); - char* (*get_lib_path)(const KODI_ADDON_BACKEND_HDL hdl); - char* (*get_user_path)(const KODI_ADDON_BACKEND_HDL hdl); - char* (*get_temp_path)(const KODI_ADDON_BACKEND_HDL hdl); - - char* (*get_localized_string)(const KODI_ADDON_BACKEND_HDL hdl, long label_id); - - bool (*open_settings_dialog)(const KODI_ADDON_BACKEND_HDL hdl); - bool (*is_setting_using_default)(const KODI_ADDON_BACKEND_HDL hdl, const char* id); - - bool (*get_setting_bool)(const KODI_ADDON_BACKEND_HDL hdl, const char* id, bool* value); - bool (*get_setting_int)(const KODI_ADDON_BACKEND_HDL hdl, const char* id, int* value); - bool (*get_setting_float)(const KODI_ADDON_BACKEND_HDL hdl, const char* id, float* value); - bool (*get_setting_string)(const KODI_ADDON_BACKEND_HDL hdl, const char* id, char** value); - - bool (*set_setting_bool)(const KODI_ADDON_BACKEND_HDL hdl, const char* id, bool value); - bool (*set_setting_int)(const KODI_ADDON_BACKEND_HDL hdl, const char* id, int value); - bool (*set_setting_float)(const KODI_ADDON_BACKEND_HDL hdl, const char* id, float value); - bool (*set_setting_string)(const KODI_ADDON_BACKEND_HDL hdl, const char* id, const char* value); - - char* (*get_addon_info)(const KODI_ADDON_BACKEND_HDL hdl, const char* id); + }; - char* (*get_type_version)(const KODI_ADDON_BACKEND_HDL hdl, int type); - void* (*get_interface)(const KODI_ADDON_BACKEND_HDL hdl, const char* name, const char* version); - } AddonToKodiFuncTable_kodi_addon; + typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_CREATE_V1)(const struct KODI_ADDON_INSTANCE_INFO* first_instance, KODI_ADDON_HDL* hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_DESTROY_V1)(KODI_ADDON_HDL hdl); - /*! - * @brief Callback function tables from addon to Kodi - * Set complete from Kodi! - */ - typedef struct AddonToKodiFuncTable_Addon - { - // Pointer inside Kodi, used on callback functions to give related handle - // class, for this ADDON::CAddonDll inside Kodi. - KODI_ADDON_BACKEND_HDL kodiBase; - - void (*free_string)(const KODI_ADDON_BACKEND_HDL hdl, char* str); - void (*free_string_array)(const KODI_ADDON_BACKEND_HDL hdl, char** arr, int numElements); - void (*addon_log_msg)(const KODI_ADDON_BACKEND_HDL hdl, const int loglevel, const char* msg); - - struct AddonToKodiFuncTable_kodi* kodi; - struct AddonToKodiFuncTable_kodi_addon* kodi_addon; - struct AddonToKodiFuncTable_kodi_audioengine* kodi_audioengine; - struct AddonToKodiFuncTable_kodi_filesystem* kodi_filesystem; - struct AddonToKodiFuncTable_kodi_gui* kodi_gui; - struct AddonToKodiFuncTable_kodi_network* kodi_network; - } AddonToKodiFuncTable_Addon; - - typedef ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_CREATE_V1)( - const KODI_ADDON_INSTANCE_BACKEND_HDL first_instance, KODI_ADDON_HDL* hdl); - typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_DESTROY_V1)(const KODI_ADDON_HDL hdl); - typedef ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_CREATE_INSTANCE_V1)( - const KODI_ADDON_HDL hdl, struct KODI_ADDON_INSTANCE_STRUCT* instance); - typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_DESTROY_INSTANCE_V1)( - const KODI_ADDON_HDL hdl, struct KODI_ADDON_INSTANCE_STRUCT* instance); typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_STRING_V1)( const KODI_ADDON_HDL hdl, const char* name, const char* value); typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_BOOLEAN_V1)( @@ -348,52 +230,151 @@ extern "C" typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_INTEGER_V1)( const KODI_ADDON_HDL hdl, const char* name, int value); typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_FLOAT_V1)( - const KODI_ADDON_HDL hdl, const char* name, float value); + const KODI_ADDON_HDL hdl, const char* name, double value); - /*! - * @brief Function tables from Kodi to addon - */ - typedef struct KodiToAddonFuncTable_Addon + typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_CREATE_INSTANCE_V1)( + const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + struct KODI_ADDON_INSTANCE_STRUCT* instance); + /*---AUTO_GEN_PARSE---*/ + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_DESTROY_INSTANCE_V1)( + const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + const KODI_ADDON_INSTANCE_HDL instance_hdl); + /*---AUTO_GEN_PARSE---*/ + + typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_STRING_V1)( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + const char* value); + typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_BOOLEAN_V1)( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + bool value); + typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_INTEGER_V1)( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + int value); + typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_FLOAT_V1)( + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + double value); + + struct KODI_ADDON_FUNC { PFN_KODI_ADDON_CREATE_V1 create; PFN_KODI_ADDON_DESTROY_V1 destroy; - PFN_KODI_ADDON_CREATE_INSTANCE_V1 create_instance; - PFN_KODI_ADDON_DESTROY_INSTANCE_V1 destroy_instance; + PFN_KODI_ADDON_SETTING_CHANGE_STRING_V1 setting_change_string; PFN_KODI_ADDON_SETTING_CHANGE_BOOLEAN_V1 setting_change_boolean; PFN_KODI_ADDON_SETTING_CHANGE_INTEGER_V1 setting_change_integer; PFN_KODI_ADDON_SETTING_CHANGE_FLOAT_V1 setting_change_float; - } KodiToAddonFuncTable_Addon; - /*! - * @brief Main structure passed from kodi to addon with basic information needed to - * create add-on. - */ - typedef struct AddonGlobalInterface - { - // Pointer of first created instance, used in case this add-on goes with single way - // Set from Kodi! - struct KODI_ADDON_INSTANCE_STRUCT* firstKodiInstance; + PFN_KODI_ADDON_CREATE_INSTANCE_V1 create_instance; + PFN_KODI_ADDON_DESTROY_INSTANCE_V1 destroy_instance; - // Pointer to master base class inside add-on - // Set from addon header (kodi::addon::CAddonBase)! - KODI_ADDON_HDL addonBase; + PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_STRING_V1 instance_setting_change_string; + PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_BOOLEAN_V1 instance_setting_change_boolean; + PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_INTEGER_V1 instance_setting_change_integer; + PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_FLOAT_V1 instance_setting_change_float; + }; - // Pointer to a instance used on single way (together with this class) - // Set from addon header (kodi::addon::IAddonInstance)! - KODI_ADDON_INSTANCE_HDL globalSingleInstance; + typedef KODI_ADDON_INSTANCE_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_CREATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_DESTROY_V1)(KODI_ADDON_INSTANCE_HDL hdl); - // Callback function tables from addon to Kodi - // Set from Kodi! - AddonToKodiFuncTable_Addon* toKodi; + struct KODI_ADDON_INSTANCE_FUNC + { + PFN_KODI_ADDON_INSTANCE_CREATE_V1 create; + PFN_KODI_ADDON_INSTANCE_DESTROY_V1 destroy; + }; - // Function tables from Kodi to addon - // Set from addon header! - KodiToAddonFuncTable_Addon* toAddon; - } AddonGlobalInterface; + ATTR_DLL_EXPORT const char* kodi_check_main_shared(int argc, char* argv[]) + __INTRODUCED_IN_KODI(1); + /*---AUTO_GEN_PARSE---*/ + ATTR_DLL_EXPORT KODI_IFC_HDL kodi_init(unsigned int api, + int argc, + char* argv[], + struct KODI_ADDON_FUNC* func, + bool via_main, + bool no_receive) __INTRODUCED_IN_KODI(1); + /*---AUTO_GEN_PARSE---*/ + ATTR_DLL_EXPORT void kodi_deinit(KODI_IFC_HDL hdl) __INTRODUCED_IN_KODI(1); + /*---AUTO_GEN_PARSE---*/ + ATTR_DLL_EXPORT bool kodi_process(KODI_IFC_HDL hdl) __INTRODUCED_IN_KODI(1); + /*---AUTO_GEN_PARSE---*/ + + ATTR_DLL_EXPORT void kodi_log(enum ADDON_LOG loglevel, const char* format, ...) + __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT char* kodi_addon_get_addon_path() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_addon_get_lib_path() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_addon_get_user_path() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_addon_get_temp_path() __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT char* kodi_addon_localized_string(long label_id) __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT char* kodi_addon_get_info(const char* id) __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT bool kodi_addon_open_settings_dialog() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_is_setting_using_default(const char* id) __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT bool kodi_addon_get_setting_bool(const char* id, bool* value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_get_setting_int(const char* id, int* value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_get_setting_float(const char* id, double* value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_get_setting_string(const char* id, char** value) + __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT bool kodi_addon_set_setting_bool(const char* id, bool value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_set_setting_int(const char* id, int value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_set_setting_float(const char* id, double value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_set_setting_string(const char* id, const char* value) + __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT char* kodi_addon_instance_get_user_path(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_instance_is_setting_using_default( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id) __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_bool( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, bool* value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_int( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, int* value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_float( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, double* value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_string( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, char** value) + __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_bool( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, bool value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_int( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, int value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_float( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, double value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_string( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, const char* value) + __INTRODUCED_IN_KODI(1); + +#endif /* __KODI_API__ >= 1 */ #ifdef __cplusplus } #endif /* __cplusplus */ -#endif /* !C_API_ADDON_BASE_H */ +#endif /* !C_API_ADDON_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/audio_engine.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/audio_engine.h index dcb004c209cec..9de0a9ff3c249 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/audio_engine.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/audio_engine.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2019 Team Kodi + * Copyright (C) 2005-2020 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later @@ -9,7 +9,8 @@ #ifndef C_API_AUDIO_ENGINE_H #define C_API_AUDIO_ENGINE_H -#include +#include "addon_base.h" + #include #ifdef __cplusplus @@ -17,293 +18,139 @@ extern "C" { #endif /* __cplusplus */ - //¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ - // "C" Definitions, structures and enumerators of audio engine - //{{{ + typedef void* KODI_AE_HDL; - //============================================================================ - /// @defgroup cpp_kodi_audioengine_Defs_AudioEngineStreamOptions enum AudioEngineStreamOptions - /// @ingroup cpp_kodi_audioengine_Defs - /// @brief **Bit options to pass to CAEStream**\n - /// A bit field of stream options. - /// - /// - /// ------------------------------------------------------------------------ - /// - /// **Usage example:** - /// ~~~~~~~~~~~~~{.cpp} - /// // Here only as minimal, "format" must be set to wanted types - /// kodi::audioengine::AudioEngineFormat format; - /// m_audioengine = new kodi::audioengine::CAEStream(format, AUDIO_STREAM_FORCE_RESAMPLE | AUDIO_STREAM_AUTOSTART); - /// ~~~~~~~~~~~~~ - /// - ///@{ typedef enum AudioEngineStreamOptions { - /// force resample even if rates match AUDIO_STREAM_FORCE_RESAMPLE = 1 << 0, - /// create the stream paused AUDIO_STREAM_PAUSED = 1 << 1, - /// autostart the stream when enough data is buffered AUDIO_STREAM_AUTOSTART = 1 << 2, } AudioEngineStreamOptions; - ///@} - //---------------------------------------------------------------------------- - - //============================================================================ - /// @defgroup cpp_kodi_audioengine_Defs_AudioEngineChannel enum AudioEngineChannel - /// @ingroup cpp_kodi_audioengine_Defs - /// @brief **The possible channels**\n - /// Used to set available or used channels on stream. - /// - /// - /// ------------------------------------------------------------------------ - /// - /// **Usage example:** - /// ~~~~~~~~~~~~~{.cpp} - /// kodi::audioengine::AudioEngineFormat format; - /// format.SetChannelLayout(std::vector(AUDIOENGINE_CH_FL, AUDIOENGINE_CH_FR)); - /// ~~~~~~~~~~~~~ - /// - ///@{ - enum AudioEngineChannel - { - /// Used inside to indicate the end of a list and not for addon use directly. - AUDIOENGINE_CH_NULL = -1, - /// RAW Audio format - AUDIOENGINE_CH_RAW, - /// Front left - AUDIOENGINE_CH_FL, - /// Front right - AUDIOENGINE_CH_FR, - /// Front center - AUDIOENGINE_CH_FC, - /// LFE / Subwoofer - AUDIOENGINE_CH_LFE, - /// Back left - AUDIOENGINE_CH_BL, - /// Back right - AUDIOENGINE_CH_BR, - /// Front left over center - AUDIOENGINE_CH_FLOC, - /// Front right over center - AUDIOENGINE_CH_FROC, - /// Back center - AUDIOENGINE_CH_BC, - /// Side left - AUDIOENGINE_CH_SL, - /// Side right - AUDIOENGINE_CH_SR, - /// Top front left - AUDIOENGINE_CH_TFL, - /// Top front right - AUDIOENGINE_CH_TFR, - /// Top front center - AUDIOENGINE_CH_TFC, - /// Top center - AUDIOENGINE_CH_TC, - /// Top back left - AUDIOENGINE_CH_TBL, - /// Top back right - AUDIOENGINE_CH_TBR, - /// Top back center - AUDIOENGINE_CH_TBC, - /// Back left over center - AUDIOENGINE_CH_BLOC, - /// Back right over center - AUDIOENGINE_CH_BROC, - /// Maximum possible value, to use e.g. as size inside list - AUDIOENGINE_CH_MAX - }; - ///@} - //---------------------------------------------------------------------------- - //============================================================================ - /// @defgroup cpp_kodi_audioengine_Defs_AudioEngineDataFormat enum AudioEngineDataFormat - /// @ingroup cpp_kodi_audioengine_Defs - /// @brief **Audio sample formats**\n - /// The bit layout of the audio data. - /// - /// LE = Little Endian, BE = Big Endian, NE = Native Endian - /// - /// For planar sample formats, each audio channel is in a separate data plane, - /// and linesize is the buffer size, in bytes, for a single plane. All data - /// planes must be the same size. For packed sample formats, only the first - /// data plane is used, and samples for each channel are interleaved. In this - /// case, linesize is the buffer size, in bytes, for the 1 plane. - /// - /// @note This is ordered from the worst to best preferred formats - /// - /// - /// ------------------------------------------------------------------------ - /// - /// **Usage example:** - /// ~~~~~~~~~~~~~{.cpp} - /// kodi::audioengine::AudioEngineFormat format; - /// format.SetDataFormat(AUDIOENGINE_FMT_FLOATP); - /// ~~~~~~~~~~~~~ - /// - ///@{ enum AudioEngineDataFormat { - /// To define format as invalid AUDIOENGINE_FMT_INVALID = -1, - - /// Unsigned integer 8 bit AUDIOENGINE_FMT_U8, - - /// Big Endian signed integer 16 bit AUDIOENGINE_FMT_S16BE, - /// Little Endian signed integer 16 bit AUDIOENGINE_FMT_S16LE, - /// Native Endian signed integer 16 bit AUDIOENGINE_FMT_S16NE, - - /// Big Endian signed integer 32 bit AUDIOENGINE_FMT_S32BE, - /// Little Endian signed integer 32 bit AUDIOENGINE_FMT_S32LE, - /// Native Endian signed integer 32 bit AUDIOENGINE_FMT_S32NE, - - /// Big Endian signed integer 24 bit (in 4 bytes) AUDIOENGINE_FMT_S24BE4, - /// Little Endian signed integer 24 bit (in 4 bytes) AUDIOENGINE_FMT_S24LE4, - /// Native Endian signed integer 24 bit (in 4 bytes) AUDIOENGINE_FMT_S24NE4, - /// S32 with bits_per_sample < 32 AUDIOENGINE_FMT_S24NE4MSB, - - /// Big Endian signed integer 24 bit (3 bytes) AUDIOENGINE_FMT_S24BE3, - /// Little Endian signed integer 24 bit (3 bytes) AUDIOENGINE_FMT_S24LE3, - /// Native Endian signed integer 24 bit (3 bytes) AUDIOENGINE_FMT_S24NE3, - - /// Double floating point AUDIOENGINE_FMT_DOUBLE, - /// Floating point AUDIOENGINE_FMT_FLOAT, - - /// **Bitstream**\n - /// RAW Audio format AUDIOENGINE_FMT_RAW, - - /// **Planar format**\n - /// Unsigned byte AUDIOENGINE_FMT_U8P, - /// **Planar format**\n - /// Native Endian signed 16 bit AUDIOENGINE_FMT_S16NEP, - /// **Planar format**\n - /// Native Endian signed 32 bit AUDIOENGINE_FMT_S32NEP, - /// **Planar format**\n - /// Native Endian signed integer 24 bit (in 4 bytes) AUDIOENGINE_FMT_S24NE4P, - /// **Planar format**\n - /// S32 with bits_per_sample < 32 AUDIOENGINE_FMT_S24NE4MSBP, - /// **Planar format**\n - /// Native Endian signed integer 24 bit (in 3 bytes) AUDIOENGINE_FMT_S24NE3P, - /// **Planar format**\n - /// Double floating point AUDIOENGINE_FMT_DOUBLEP, - /// **Planar format**\n - /// Floating point AUDIOENGINE_FMT_FLOATP, - - /// Amount of sample formats. AUDIOENGINE_FMT_MAX }; - ///@} - //---------------------------------------------------------------------------- - /*! - * @brief Internal API structure which are used for data exchange between - * Kodi and addon. - */ - struct AUDIO_ENGINE_FORMAT + enum AudioEngineChannel { - /*! The stream's data format (eg, AUDIOENGINE_FMT_S16LE) */ - enum AudioEngineDataFormat m_dataFormat; - - /*! The stream's sample rate (eg, 48000) */ - unsigned int m_sampleRate; - - /*! The encoded streams sample rate if a bitstream, otherwise undefined */ - unsigned int m_encodedRate; - - /*! The amount of used speaker channels */ - unsigned int m_channelCount; - - /*! The stream's channel layout */ - enum AudioEngineChannel m_channels[AUDIOENGINE_CH_MAX]; - - /*! The number of frames per period */ - unsigned int m_frames; - - /*! The size of one frame in bytes */ - unsigned int m_frameSize; + AUDIOENGINE_CH_NULL = -1, + AUDIOENGINE_CH_RAW, + AUDIOENGINE_CH_FL, + AUDIOENGINE_CH_FR, + AUDIOENGINE_CH_FC, + AUDIOENGINE_CH_LFE, + AUDIOENGINE_CH_BL, + AUDIOENGINE_CH_BR, + AUDIOENGINE_CH_FLOC, + AUDIOENGINE_CH_FROC, + AUDIOENGINE_CH_BC, + AUDIOENGINE_CH_SL, + AUDIOENGINE_CH_SR, + AUDIOENGINE_CH_TFL, + AUDIOENGINE_CH_TFR, + AUDIOENGINE_CH_TFC, + AUDIOENGINE_CH_TC, + AUDIOENGINE_CH_TBL, + AUDIOENGINE_CH_TBR, + AUDIOENGINE_CH_TBC, + AUDIOENGINE_CH_BLOC, + AUDIOENGINE_CH_BROC, + AUDIOENGINE_CH_MAX }; - /* A stream handle pointer, which is only used internally by the addon stream handle */ - typedef void AEStreamHandle; - - //}}} - - //¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ - // "C" Internal interface tables for intercommunications between addon and kodi - //{{{ - - /* - * Function address structure, not need to visible on dev kit doxygen - * documentation - */ - typedef struct AddonToKodiFuncTable_kodi_audioengine + struct AUDIO_ENGINE_FMT { - AEStreamHandle* (*make_stream)(void* kodiBase, - struct AUDIO_ENGINE_FORMAT* format, - unsigned int options); - void (*free_stream)(void* kodiBase, AEStreamHandle* stream); - bool (*get_current_sink_format)(void* kodiBase, struct AUDIO_ENGINE_FORMAT* sink_format); - - // Audio Engine Stream definitions - unsigned int (*aestream_get_space)(void* kodiBase, AEStreamHandle* handle); - unsigned int (*aestream_add_data)(void* kodiBase, - AEStreamHandle* handle, - uint8_t* const* data, - unsigned int offset, - unsigned int frames, - double pts, - bool hasDownmix, - double centerMixLevel); - double (*aestream_get_delay)(void* kodiBase, AEStreamHandle* handle); - bool (*aestream_is_buffering)(void* kodiBase, AEStreamHandle* handle); - double (*aestream_get_cache_time)(void* kodiBase, AEStreamHandle* handle); - double (*aestream_get_cache_total)(void* kodiBase, AEStreamHandle* handle); - void (*aestream_pause)(void* kodiBase, AEStreamHandle* handle); - void (*aestream_resume)(void* kodiBase, AEStreamHandle* handle); - void (*aestream_drain)(void* kodiBase, AEStreamHandle* handle, bool wait); - bool (*aestream_is_draining)(void* kodiBase, AEStreamHandle* handle); - bool (*aestream_is_drained)(void* kodiBase, AEStreamHandle* handle); - void (*aestream_flush)(void* kodiBase, AEStreamHandle* handle); - float (*aestream_get_volume)(void* kodiBase, AEStreamHandle* handle); - void (*aestream_set_volume)(void* kodiBase, AEStreamHandle* handle, float volume); - float (*aestream_get_amplification)(void* kodiBase, AEStreamHandle* handle); - void (*aestream_set_amplification)(void* kodiBase, AEStreamHandle* handle, float amplify); - unsigned int (*aestream_get_frame_size)(void* kodiBase, AEStreamHandle* handle); - unsigned int (*aestream_get_channel_count)(void* kodiBase, AEStreamHandle* handle); - unsigned int (*aestream_get_sample_rate)(void* kodiBase, AEStreamHandle* handle); - enum AudioEngineDataFormat (*aestream_get_data_format)(void* kodiBase, AEStreamHandle* handle); - double (*aestream_get_resample_ratio)(void* kodiBase, AEStreamHandle* handle); - void (*aestream_set_resample_ratio)(void* kodiBase, AEStreamHandle* handle, double ratio); - } AddonToKodiFuncTable_kodi_audioengine; + enum AudioEngineDataFormat data_format; + unsigned int sample_rate; + unsigned int channel_count; + enum AudioEngineChannel channels[AUDIOENGINE_CH_MAX]; + unsigned int frames; + unsigned int frame_size; + }; - //}}} + ATTR_DLL_EXPORT bool kodi_audioengine_get_current_sink_format(struct AUDIO_ENGINE_FMT* fmt) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_audioengine_is_planar_format(enum AudioEngineDataFormat format) + __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT KODI_AE_HDL kodi_audioengine_stream_make(const struct AUDIO_ENGINE_FMT* fmt, + unsigned int options) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_audioengine_stream_free(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_space(KODI_AE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_add_data(KODI_AE_HDL hdl, + uint8_t* const* data, + size_t planes, + size_t data_size, + unsigned int offset, + unsigned int frames, + unsigned int frame_size, + double pts, + bool hasDownmix, + double centerMixLevel) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT double kodi_audioengine_stream_get_delay(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_buffering(KODI_AE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT double kodi_audioengine_stream_get_cache_time(KODI_AE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT double kodi_audioengine_stream_get_cache_total(KODI_AE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_audioengine_stream_pause(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_audioengine_stream_resume(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_audioengine_stream_drain(KODI_AE_HDL hdl, bool wait) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_draining(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_drained(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_audioengine_stream_flush(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT float kodi_audioengine_stream_get_volume(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_audioengine_stream_set_volume(KODI_AE_HDL hdl, float volume) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT float kodi_audioengine_stream_get_amplification(KODI_AE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_audioengine_stream_set_amplification(KODI_AE_HDL hdl, float amplify) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_frame_size(KODI_AE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_channel_count(KODI_AE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_sample_rate(KODI_AE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT enum AudioEngineDataFormat kodi_audioengine_stream_get_data_format( + KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT double kodi_audioengine_stream_get_resample_ratio(KODI_AE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_audioengine_stream_set_resample_ratio(KODI_AE_HDL hdl, double ratio) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/dl/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/dl/CMakeLists.txt new file mode 100644 index 0000000000000..f98c0fa2e5281 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/dl/CMakeLists.txt @@ -0,0 +1,10 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(HEADERS + kodi_api_1.h +) + +if(HEADERS) + core_add_devkit_header(kodi_c-api_dl) +endif() diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/dl/kodi_api_1.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/dl/kodi_api_1.h new file mode 100644 index 0000000000000..125ec79e019a8 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/dl/kodi_api_1.h @@ -0,0 +1,1466 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +/* API_HASH */ + +#ifndef C_API_DL_API_1_H +#define C_API_DL_API_1_H + +#include "../addon-instance/audioencoder.h" +#include "../addon-instance/game.h" +#include "../addon-instance/inputstream.h" +#include "../addon-instance/peripheral.h" +#include "../addon-instance/pvr.h" +#include "../addon-instance/screensaver.h" +#include "../addon-instance/vfs.h" +#include "../addon-instance/videocodec.h" +#include "../addon-instance/visualization.h" +#include "../addon-instance/web.h" +#include "../addon_base.h" +#include "../audio_engine.h" +#include "../filesystem.h" +#include "../general.h" +#include "../gui/controls/button.h" +#include "../gui/controls/edit.h" +#include "../gui/controls/fade_label.h" +#include "../gui/controls/image.h" +#include "../gui/controls/label.h" +#include "../gui/controls/progress.h" +#include "../gui/controls/radio_button.h" +#include "../gui/controls/rendering.h" +#include "../gui/controls/settings_slider.h" +#include "../gui/controls/slider.h" +#include "../gui/controls/spin.h" +#include "../gui/controls/text_box.h" +#include "../gui/dialogs/extended_progress.h" +#include "../gui/dialogs/progress.h" +#include "../gui/general.h" +#include "../gui/list_item.h" +#include "../gui/window.h" + +#ifndef ATTR_DL_APIENTRYP +#define ATTR_DL_APIENTRYP ATTR_APIENTRYP +#endif + +#ifndef ATTR_DL_DLL_EXPORT +#define ATTR_DL_DLL_EXPORT ATTR_DLL_EXPORT +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + struct kodi_api_1; + + ATTR_DL_DLL_EXPORT bool load_kodi_api_1(struct kodi_api_1* api); + + struct KODI_ADDON_FUNC; + struct AUDIO_ENGINE_FMT; + struct VFS_DIR_ENTRY; + struct VFS_STAT_STRUCTURE; + struct VFS_CACHE_STATUS; + struct AddonKeyboardKeyTable; + struct game_stream_properties; + struct game_stream_buffer; + struct game_stream_packet; + struct game_input_event; + struct DEMUX_PACKET; + struct PVR_MENUHOOK; + struct EPG_TAG; + struct PVR_CHANNEL; + struct PVR_PROVIDER; + struct PVR_CHANNEL_GROUP; + struct PVR_CHANNEL_GROUP_MEMBER; + struct PVR_RECORDING; + struct PVR_TIMER; + struct KODI_ADDON_SCREENSAVER_PROPS; + struct VIDEOCODEC_PICTURE; + struct KODI_ADDON_VISUALIZATION_PROPS; + struct tm; + + // addon_base.h + typedef KODI_IFC_HDL(ATTR_DL_APIENTRYP PFN_KODI_INIT_V1)( + unsigned int, int, char*[], struct KODI_ADDON_FUNC*, bool, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GET_SETTING_BOOL_V1)(const char*, bool*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GET_SETTING_FLOAT_V1)(const char*, double*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GET_SETTING_INT_V1)(const char*, int*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GET_SETTING_STRING_V1)(const char*, char**); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INSTANCE_GET_SETTING_BOOL_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, bool*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INSTANCE_GET_SETTING_FLOAT_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, double*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INSTANCE_GET_SETTING_INT_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, int*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INSTANCE_GET_SETTING_STRING_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, char**); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INSTANCE_IS_SETTING_USING_DEFAULT_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INSTANCE_SET_SETTING_BOOL_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INSTANCE_SET_SETTING_FLOAT_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, double); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INSTANCE_SET_SETTING_INT_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, int); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INSTANCE_SET_SETTING_STRING_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_IS_SETTING_USING_DEFAULT_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_OPEN_SETTINGS_DIALOG_V1)(); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_SET_SETTING_BOOL_V1)(const char*, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_SET_SETTING_FLOAT_V1)(const char*, double); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_SET_SETTING_INT_V1)(const char*, int); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_SET_SETTING_STRING_V1)(const char*, const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_PROCESS_V1)(KODI_IFC_HDL); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GET_ADDON_PATH_V1)(); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GET_INFO_V1)(const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GET_LIB_PATH_V1)(); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GET_TEMP_PATH_V1)(); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GET_USER_PATH_V1)(); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INSTANCE_GET_USER_PATH_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_ADDON_LOCALIZED_STRING_V1)(long); + typedef const char*(ATTR_DL_APIENTRYP PFN_KODI_CHECK_MAIN_SHARED_V1)(int, char*[]); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_DEINIT_V1)(KODI_IFC_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_LOG_V1)(enum ADDON_LOG, const char*, ...); + + // audio_engine.h + typedef KODI_AE_HDL(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_MAKE_V1)( + const struct AUDIO_ENGINE_FMT*, unsigned int); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_GET_CURRENT_SINK_FORMAT_V1)( + struct AUDIO_ENGINE_FMT*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_IS_PLANAR_FORMAT_V1)( + enum AudioEngineDataFormat); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_IS_BUFFERING_V1)(KODI_AE_HDL); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_IS_DRAINED_V1)(KODI_AE_HDL); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_IS_DRAINING_V1)(KODI_AE_HDL); + typedef double(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_CACHE_TIME_V1)(KODI_AE_HDL); + typedef double(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_CACHE_TOTAL_V1)(KODI_AE_HDL); + typedef double(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_DELAY_V1)(KODI_AE_HDL); + typedef double(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_RESAMPLE_RATIO_V1)(KODI_AE_HDL); + typedef enum AudioEngineDataFormat( + ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_DATA_FORMAT_V1)(KODI_AE_HDL); + typedef float(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_AMPLIFICATION_V1)(KODI_AE_HDL); + typedef float(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_VOLUME_V1)(KODI_AE_HDL); + typedef unsigned int(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_ADD_DATA_V1)(KODI_AE_HDL, + uint8_t* const*, + size_t, + size_t, + unsigned int, + unsigned int, + unsigned int, + double, + bool, + double); + typedef unsigned int(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_CHANNEL_COUNT_V1)( + KODI_AE_HDL); + typedef unsigned int(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_FRAME_SIZE_V1)( + KODI_AE_HDL); + typedef unsigned int(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_SAMPLE_RATE_V1)( + KODI_AE_HDL); + typedef unsigned int(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_GET_SPACE_V1)(KODI_AE_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_DRAIN_V1)(KODI_AE_HDL, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_FLUSH_V1)(KODI_AE_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_FREE_V1)(KODI_AE_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_PAUSE_V1)(KODI_AE_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_RESUME_V1)(KODI_AE_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_SET_AMPLIFICATION_V1)(KODI_AE_HDL, + float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_SET_RESAMPLE_RATIO_V1)(KODI_AE_HDL, + double); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_AUDIOENGINE_STREAM_SET_VOLUME_V1)(KODI_AE_HDL, float); + + // filesystem.h + typedef KODI_FILE_HDL(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_CURL_CREATE_V1)(const char*); + typedef KODI_FILE_HDL(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_OPEN_FOR_WRITE_V1)(const char*, bool); + typedef KODI_FILE_HDL(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_OPEN_V1)(const char*, unsigned int); + typedef KODI_HTTP_HEADER_HDL(ATTR_DL_APIENTRYP PFN_KODI_VFS_HTTP_HEADER_OPEN_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_CAN_OPEN_DIRECTORY_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_COPY_FILE_V1)(const char*, const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_CREATE_DIRECTORY_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_DELETE_FILE_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_DIRECTORY_EXISTS_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_AT_END_V1)(KODI_FILE_HDL); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_CURL_ADD_OPTION_V1)(KODI_FILE_HDL, + enum CURLOptiontype, + const char*, + const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_CURL_OPEN_V1)(KODI_FILE_HDL, unsigned int); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_EXISTS_V1)(const char*, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_IO_CTL_GET_CACHE_STATUS_V1)( + KODI_FILE_HDL, struct VFS_CACHE_STATUS*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_IO_CTL_GET_SEEK_POSSIBLE_V1)(KODI_FILE_HDL); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_IO_CTL_SET_CACHE_RATE_V1)(KODI_FILE_HDL, + uint32_t); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_IO_CTL_SET_RETRY_V1)(KODI_FILE_HDL, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_READ_LINE_V1)(KODI_FILE_HDL, char*, size_t); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_GET_CONTENT_TYPE_V1)(const char*, + char**, + const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_GET_COOKIES_V1)(const char*, char**); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_GET_DIRECTORY_V1)(const char*, + const char*, + struct VFS_DIR_ENTRY**, + size_t*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_GET_DISK_SPACE_V1)(const char*, + uint64_t*, + uint64_t*, + uint64_t*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_GET_MIME_TYPE_V1)(const char*, char**, const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_IS_INTERNET_STREAM_V1)(const char*, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_IS_LOCAL_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_IS_ON_LAN_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_IS_REMOTE_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_IS_URL_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_REMOVE_DIRECTORY_RECURSIVE_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_REMOVE_DIRECTORY_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_RENAME_FILE_V1)(const char*, const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_VFS_STAT_FILE_V1)(const char*, + struct VFS_STAT_STRUCTURE*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_GET_PROPERTY_VALUE_V1)(KODI_FILE_HDL, + enum FilePropertyTypes, + const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_GET_CACHE_THUMB_NAME_V1)(const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_GET_FILE_MD5_V1)(const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_HTTP_HEADER_GET_CHARSET_V1)(KODI_HTTP_HEADER_HDL); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_HTTP_HEADER_GET_HEADER_V1)(KODI_HTTP_HEADER_HDL); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_HTTP_HEADER_GET_MIME_TYPE_V1)(KODI_HTTP_HEADER_HDL); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_HTTP_HEADER_GET_PROTO_LINE_V1)(KODI_HTTP_HEADER_HDL); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_HTTP_HEADER_GET_VALUE_V1)(KODI_HTTP_HEADER_HDL, + const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_MAKE_LEGAL_FILENAME_V1)(const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_MAKE_LEGAL_PATH_V1)(const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_VFS_TRANSLATE_SPECIAL_PROTOCOL_V1)(const char*); + typedef char**(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_GET_PROPERTY_VALUES_V1)(KODI_FILE_HDL, + enum FilePropertyTypes, + const char*, + size_t*); + typedef char**(ATTR_DL_APIENTRYP PFN_KODI_VFS_HTTP_HEADER_GET_VALUES_V1)(KODI_HTTP_HEADER_HDL, + const char*, + size_t*); + typedef double(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_GET_DOWNLOAD_SPEED_V1)(KODI_FILE_HDL); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_GET_CHUNK_SIZE_V1)(KODI_FILE_HDL); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_TRUNCATE_V1)(KODI_FILE_HDL, int64_t); + typedef int64_t(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_GET_LENGTH_V1)(KODI_FILE_HDL); + typedef int64_t(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_GET_POSITION_V1)(KODI_FILE_HDL); + typedef int64_t(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_SEEK_V1)(KODI_FILE_HDL, int64_t, int); + typedef ssize_t(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_READ_V1)(KODI_FILE_HDL, uint8_t*, size_t); + typedef ssize_t(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_WRITE_V1)(KODI_FILE_HDL, + const uint8_t*, + size_t); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_CLOSE_V1)(KODI_FILE_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_VFS_FILE_FLUSH_V1)(KODI_FILE_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_VFS_FREE_DIRECTORY_V1)(struct VFS_DIR_ENTRY*, size_t); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_VFS_HTTP_HEADER_CLOSE_V1)(KODI_HTTP_HEADER_HDL); + + // general.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_CHANGE_KEYBOARD_LAYOUT_V1)(char**); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GET_KEYBOARD_LAYOUT_V1)(int, + char**, + struct AddonKeyboardKeyTable*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_IS_ADDON_AVILABLE_V1)(const char*, char**, bool*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GET_CURRENT_SKIN_ID_V1)(); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GET_DIGEST_V1)(enum DigestType, const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GET_LANGUAGE_V1)(enum LangFormats, bool); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GET_LOCALIZED_STRING_V1)(long); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GET_REGION_V1)(const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_UNKNOWN_TO_UTF8_V1)(const char*, bool*, bool); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GET_GLOBAL_IDLE_TIME_V1)(); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GET_FREE_MEM_V1)(long*, long*, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_PLAY_SFX_V1)(const char*, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_QUEUE_NOTIFICATION_V1)( + enum QueueMsg, const char*, const char*, const char*, unsigned int, bool, unsigned int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_STOP_SFX_V1)(); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_VERSION_V1)(char**, int*, int*, char**, char**, char**); + + // monitor.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_MONITOR_ABORT_REQUESTED_V1)(); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_MONITOR_WAIT_FOR_ABORT_V1)(double); + + // network.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_NETWORK_IS_HOST_ON_LAN_V1)(const char*, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_NETWORK_IS_LOCAL_HOST_V1)(const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_NETWORK_WAKE_ON_LAN_V1)(const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_NETWORK_DNS_LOOKUP_V1)(const char*, bool*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_NETWORK_GET_HOSTNAME_V1)(); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_NETWORK_GET_IP_ADDRESS_V1)(); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_NETWORK_GET_USER_AGENT_V1)(); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_NETWORK_URL_ENCODE_V1)(const char*); + + // addon-instance/audioencoder.h + typedef ssize_t(ATTR_DL_APIENTRYP PFN_KODI_ADDON_AUDIOENCODER_SEEK_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, ssize_t, int); + typedef ssize_t(ATTR_DL_APIENTRYP PFN_KODI_ADDON_AUDIOENCODER_WRITE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const uint8_t*, size_t); + + // addon-instance/game.h + typedef KODI_GAME_STREAM_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GAME_OPEN_STREAM_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const struct game_stream_properties*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GAME_GET_STREAM_BUFFER_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, + KODI_GAME_STREAM_HANDLE, + unsigned int, + unsigned int, + struct game_stream_buffer*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GAME_INPUT_EVENT_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const struct game_input_event*); + typedef game_proc_address_t(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GAME_HW_GET_PROC_ADDRESS_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GAME_ADD_STREAM_DATA_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, KODI_GAME_STREAM_HANDLE, const struct game_stream_packet*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GAME_CLOSE_STREAM_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, KODI_GAME_STREAM_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GAME_CLOSE_V1)(KODI_ADDON_INSTANCE_BACKEND_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_GAME_RELEASE_STREAM_BUFFER_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, KODI_GAME_STREAM_HANDLE, struct game_stream_buffer*); + + // addon-instance/inputstream.h + typedef struct DEMUX_PACKET*( + ATTR_DL_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_ALLOCATE_DEMUX_PACKET_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, int); + typedef struct DEMUX_PACKET*( + ATTR_DL_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_ALLOCATE_ENCRYPTED_DEMUX_PACKET_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, unsigned int, unsigned int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_INPUTSTREAM_FREE_DEMUX_PACKET_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, struct DEMUX_PACKET*); + + // addon-instance/peripheral.h + typedef enum JOYSTICK_FEATURE_TYPE(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FEATURE_TYPE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, const char*); + typedef unsigned int(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_FEATURE_COUNT_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, enum JOYSTICK_FEATURE_TYPE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_REFRESH_BUTTON_MAPS_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PERIPHERAL_TRIGGER_SCAN_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL); + + // addon-instance/pvr.h + typedef int(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_MAX_FUTURE_DAYS_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_MAX_PAST_DAYS_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_ADD_MENU_HOOK_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const struct PVR_MENUHOOK*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_CONNECTION_STATE_CHANGE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, enum PVR_CONNECTION_STATE, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_EPG_EVENT_STATE_CHANGE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, struct EPG_TAG*, enum EPG_EVENT_STATE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_RECORDING_NOTIFICATION_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const char*, const char*, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRANSFER_CHANNEL_ENTRY_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, + const KODI_ADDON_PVR_TRANSFER_HDL, + const struct PVR_CHANNEL*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRANSFER_CHANNEL_GROUP_MEMBER_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, + const KODI_ADDON_PVR_TRANSFER_HDL, + const struct PVR_CHANNEL_GROUP_MEMBER*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRANSFER_CHANNEL_GROUP_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, + const KODI_ADDON_PVR_TRANSFER_HDL, + const struct PVR_CHANNEL_GROUP*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRANSFER_EPG_ENTRY_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const KODI_ADDON_PVR_TRANSFER_HDL, const struct EPG_TAG*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRANSFER_PROVIDER_ENTRY_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, + const KODI_ADDON_PVR_TRANSFER_HDL, + const struct PVR_PROVIDER*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRANSFER_RECORDING_ENTRY_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, + const KODI_ADDON_PVR_TRANSFER_HDL, + const struct PVR_RECORDING*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRANSFER_TIMER_ENTRY_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, const KODI_ADDON_PVR_TRANSFER_HDL, const struct PVR_TIMER*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRIGGER_CHANNEL_GROUPS_UPDATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRIGGER_CHANNEL_UPDATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRIGGER_EPG_UPDATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, unsigned int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRIGGER_PROVIDERS_UPDATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRIGGER_RECORDING_UPDATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_PVR_TRIGGER_TIMER_UPDATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL); + + // addon-instance/screensaver.h + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_GET_PROPERTIES_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, struct KODI_ADDON_SCREENSAVER_PROPS*); + + // addon-instance/vfs.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_VFS_GET_DIR_CB__GET_KEYBOARD_INPUT_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, KODI_CTX_CB_HDL, const char*, char**, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_VFS_GET_DIR_CB__REQUIRE_AUTHENTICATION_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, KODI_CTX_CB_HDL, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_VFS_GET_DIR_CB__SET_ERROR_DIALOG_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, + KODI_CTX_CB_HDL, + const char*, + const char*, + const char*, + const char*); + + // addon-instance/videocodec.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_GET_FRAME_BUFFER_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, struct VIDEOCODEC_PICTURE*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_VIDEOCODEC_RELEASE_FRAME_BUFFER_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, struct VIDEOCODEC_PICTURE*); + + // addon-instance/visualization.h + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_CLEAR_PRESETS_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_GET_PROPERTIES_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, struct KODI_ADDON_VISUALIZATION_PROPS*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_TRANSFER_PRESET_V1)( + const KODI_ADDON_INSTANCE_BACKEND_HDL, const char*); + + // addon-instance/web.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_IS_MUTED_V1)(KODI_ADDON_INSTANCE_BACKEND_HDL); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_REQUEST_OPEN_SITE_IN_NEW_TAB_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, WEB_KODI_CONTROL, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SET_CONTROL_READY_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, WEB_KODI_CONTROL, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SET_FULLSCREEN_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, WEB_KODI_CONTROL, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SET_ICON_URL_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, WEB_KODI_CONTROL, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SET_LOADING_STATE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, WEB_KODI_CONTROL, bool, bool, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SET_OPENED_ADDRESS_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, WEB_KODI_CONTROL, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SET_OPENED_TITLE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, WEB_KODI_CONTROL, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SET_STATUS_MESSAGE_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, WEB_KODI_CONTROL, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SET_TOOLTIP_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, WEB_KODI_CONTROL, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_INHIBIT_SCREENSAVER_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_ADDON_WEB_INHIBIT_SHUTDOWN_V1)( + KODI_ADDON_INSTANCE_BACKEND_HDL, bool); + + // gui/general.h + typedef ADDON_HARDWARE_CONTEXT(ATTR_DL_APIENTRYP PFN_KODI_GUI_GET_HW_CONTEXT_V1)(); + typedef float(ATTR_DL_APIENTRYP PFN_KODI_GUI_GET_VIDEO_RESOLUTION_V1)(); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_GET_CURRENT_WINDOW_DIALOG_ID_V1)(); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_GET_CURRENT_WINDOW_ID_V1)(); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_GET_SCREEN_HEIGHT_V1)(); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_GET_SCREEN_WIDTH_V1)(); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_LOCK_V1)(); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_UNLOCK_V1)(); + + // gui/list_item.h + typedef KODI_GUI_LISTITEM_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_CREATE_V1)(const char*, + const char*, + const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_IS_SELECTED_V1)(KODI_GUI_LISTITEM_HANDLE); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_GET_ART_V1)(KODI_GUI_LISTITEM_HANDLE, + const char*); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_GET_LABEL2_V1)(KODI_GUI_LISTITEM_HANDLE); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_GET_LABEL_V1)(KODI_GUI_LISTITEM_HANDLE); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_GET_PATH_V1)(KODI_GUI_LISTITEM_HANDLE); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_GET_PROPERTY_V1)(KODI_GUI_LISTITEM_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_DESTROY_V1)(KODI_GUI_LISTITEM_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_SELECT_V1)(KODI_GUI_LISTITEM_HANDLE, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_SET_ART_V1)(KODI_GUI_LISTITEM_HANDLE, + const char*, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_SET_LABEL2_V1)(KODI_GUI_LISTITEM_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_SET_LABEL_V1)(KODI_GUI_LISTITEM_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_SET_PATH_V1)(KODI_GUI_LISTITEM_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_LISTITEM_SET_PROPERTY_V1)(KODI_GUI_LISTITEM_HANDLE, + const char*, + const char*); + + // gui/window.h + typedef KODI_GUI_CONTROL_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_BUTTON_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef KODI_GUI_CONTROL_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_EDIT_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef KODI_GUI_CONTROL_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_FADE_LABEL_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef KODI_GUI_CONTROL_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_IMAGE_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef KODI_GUI_CONTROL_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_LABEL_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef KODI_GUI_CONTROL_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_PROGRESS_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef KODI_GUI_CONTROL_HANDLE( + ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_RADIO_BUTTON_V1)(KODI_GUI_WINDOW_HANDLE, + int); + typedef KODI_GUI_CONTROL_HANDLE( + ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_RENDER_ADDON_V1)(KODI_GUI_WINDOW_HANDLE, + int); + typedef KODI_GUI_CONTROL_HANDLE( + ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_SETTINGS_SLIDER_V1)(KODI_GUI_WINDOW_HANDLE, + int); + typedef KODI_GUI_CONTROL_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_SLIDER_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef KODI_GUI_CONTROL_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_SPIN_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef KODI_GUI_CONTROL_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTROL_TEXT_BOX_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef KODI_GUI_LISTITEM_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_LIST_ITEM_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef KODI_GUI_WINDOW_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_CREATE_V1)( + KODI_HANDLE, const char*, const char*, bool, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_CLOSE_V1)(KODI_GUI_WINDOW_HANDLE); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_DO_MODAL_V1)(KODI_GUI_WINDOW_HANDLE); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_PROPERTY_BOOL_V1)(KODI_GUI_WINDOW_HANDLE, + const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_FOCUS_ID_V1)(KODI_GUI_WINDOW_HANDLE, int); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SHOW_V1)(KODI_GUI_WINDOW_HANDLE); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_PROPERTY_V1)(KODI_GUI_WINDOW_HANDLE, + const char*); + typedef double(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_PROPERTY_DOUBLE_V1)( + KODI_GUI_WINDOW_HANDLE, const char*); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CURRENT_CONTAINER_ID_V1)( + KODI_GUI_WINDOW_HANDLE); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CURRENT_LIST_POSITION_V1)( + KODI_GUI_WINDOW_HANDLE); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_FOCUS_ID_V1)(KODI_GUI_WINDOW_HANDLE); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_LIST_SIZE_V1)(KODI_GUI_WINDOW_HANDLE); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_GET_PROPERTY_INT_V1)(KODI_GUI_WINDOW_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_ADD_LIST_ITEM_V1)(KODI_GUI_WINDOW_HANDLE, + KODI_GUI_LISTITEM_HANDLE, + int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_CLEAR_ITEM_LIST_V1)(KODI_GUI_WINDOW_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_CLEAR_PROPERTIES_V1)(KODI_GUI_WINDOW_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_CLEAR_PROPERTY_V1)(KODI_GUI_WINDOW_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_DESTROY_V1)(KODI_GUI_WINDOW_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_MARK_DIRTY_REGION_V1)(KODI_GUI_WINDOW_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_REMOVE_LIST_ITEM_FROM_POSITION_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_REMOVE_LIST_ITEM_V1)(KODI_GUI_WINDOW_HANDLE, + KODI_GUI_LISTITEM_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_CONTAINER_CONTENT_V1)( + KODI_GUI_WINDOW_HANDLE, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_CONTAINER_PROPERTY_V1)( + KODI_GUI_WINDOW_HANDLE, const char*, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_CONTROL_LABEL_V1)(KODI_GUI_WINDOW_HANDLE, + int, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_CONTROL_SELECTED_V1)( + KODI_GUI_WINDOW_HANDLE, int, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_CONTROL_VISIBLE_V1)(KODI_GUI_WINDOW_HANDLE, + int, + bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_CURRENT_LIST_POSITION_V1)( + KODI_GUI_WINDOW_HANDLE, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_PROPERTY_BOOL_V1)(KODI_GUI_WINDOW_HANDLE, + const char*, + bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_PROPERTY_DOUBLE_V1)(KODI_GUI_WINDOW_HANDLE, + const char*, + double); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_PROPERTY_INT_V1)(KODI_GUI_WINDOW_HANDLE, + const char*, + int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_WINDOW_SET_PROPERTY_V1)(KODI_GUI_WINDOW_HANDLE, + const char*, + const char*); + + // gui/controls/button.h + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_BUTTON_GET_LABEL2_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_BUTTON_GET_LABEL_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_BUTTON_SET_ENABLED_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_BUTTON_SET_LABEL2_V1)( + KODI_GUI_CONTROL_HANDLE, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_BUTTON_SET_LABEL_V1)(KODI_GUI_CONTROL_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_BUTTON_SET_VISIBLE_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + + // gui/controls/edit.h + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_EDIT_GET_LABEL_V1)(KODI_GUI_CONTROL_HANDLE); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_EDIT_GET_TEXT_V1)(KODI_GUI_CONTROL_HANDLE); + typedef unsigned int(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_EDIT_GET_CURSOR_POSITION_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_EDIT_SET_CURSOR_POSITION_V1)( + KODI_GUI_CONTROL_HANDLE, unsigned int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_EDIT_SET_ENABLED_V1)(KODI_GUI_CONTROL_HANDLE, + bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_EDIT_SET_INPUT_TYPE_V1)( + KODI_GUI_CONTROL_HANDLE, int, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_EDIT_SET_LABEL_V1)(KODI_GUI_CONTROL_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_EDIT_SET_TEXT_V1)(KODI_GUI_CONTROL_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_EDIT_SET_VISIBLE_V1)(KODI_GUI_CONTROL_HANDLE, + bool); + + // gui/controls/fade_label.h + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_FADE_LABEL_GET_LABEL_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_FADE_LABEL_ADD_LABEL_V1)( + KODI_GUI_CONTROL_HANDLE, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_FADE_LABEL_RESET_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_FADE_LABEL_SET_SCROLLING_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_FADE_LABEL_SET_VISIBLE_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + + // gui/controls/image.h + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_IMAGE_SET_COLOR_DIFFUSE_V1)( + KODI_GUI_CONTROL_HANDLE, uint32_t); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_IMAGE_SET_FILENAME_V1)( + KODI_GUI_CONTROL_HANDLE, const char*, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_IMAGE_SET_VISIBLE_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + + // gui/controls/label.h + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_LABEL_GET_LABEL_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_LABEL_SET_LABEL_V1)(KODI_GUI_CONTROL_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_LABEL_SET_VISIBLE_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + + // gui/controls/progress.h + typedef float(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_PROGRESS_GET_PERCENTAGE_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_PROGRESS_SET_PERCENTAGE_V1)( + KODI_GUI_CONTROL_HANDLE, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_PROGRESS_SET_VISIBLE_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + + // gui/controls/radio_button.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_IS_SELECTED_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_GET_LABEL_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_SET_ENABLED_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_SET_LABEL_V1)( + KODI_GUI_CONTROL_HANDLE, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_SET_SELECTED_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_SET_VISIBLE_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + + // gui/controls/rendering.h + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_RADIO_RENDERING_DESTROY_V1)( + KODI_GUI_CONTROL_HANDLE); + + // gui/controls/settings_slider.h + typedef float(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_GET_FLOAT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef float(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_GET_PERCENTAGE_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_GET_INT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_RESET_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_ENABLED_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_FLOAT_INTERVAL_V1)( + KODI_GUI_CONTROL_HANDLE, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_FLOAT_RANGE_V1)( + KODI_GUI_CONTROL_HANDLE, float, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_FLOAT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_INT_INTERVAL_V1)( + KODI_GUI_CONTROL_HANDLE, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_INT_RANGE_V1)( + KODI_GUI_CONTROL_HANDLE, int, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_INT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_PERCENTAGE_V1)( + KODI_GUI_CONTROL_HANDLE, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_TEXT_V1)( + KODI_GUI_CONTROL_HANDLE, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_VISIBLE_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + + // gui/controls/slider.h + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_GET_DESCRIPTION_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef float(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_GET_FLOAT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef float(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_GET_PERCENTAGE_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_GET_INT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_RESET_V1)(KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_SET_ENABLED_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_SET_FLOAT_INTERVAL_V1)( + KODI_GUI_CONTROL_HANDLE, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_SET_FLOAT_RANGE_V1)( + KODI_GUI_CONTROL_HANDLE, float, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_SET_FLOAT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_SET_INT_INTERVAL_V1)( + KODI_GUI_CONTROL_HANDLE, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_SET_INT_RANGE_V1)( + KODI_GUI_CONTROL_HANDLE, int, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_SET_INT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_SET_PERCENTAGE_V1)( + KODI_GUI_CONTROL_HANDLE, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SLIDER_SET_VISIBLE_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + + // gui/controls/spin.h + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_GET_STRING_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef float(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_GET_FLOAT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_GET_INT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_ADD_INT_LABEL_V1)( + KODI_GUI_CONTROL_HANDLE, const char*, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_ADD_STRING_LABEL_V1)( + KODI_GUI_CONTROL_HANDLE, const char*, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_RESET_V1)(KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_SET_ENABLED_V1)(KODI_GUI_CONTROL_HANDLE, + bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_SET_FLOAT_INTERVAL_V1)( + KODI_GUI_CONTROL_HANDLE, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_SET_FLOAT_RANGE_V1)( + KODI_GUI_CONTROL_HANDLE, float, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_SET_FLOAT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_SET_INT_RANGE_V1)( + KODI_GUI_CONTROL_HANDLE, int, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_SET_INT_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_SET_STRING_VALUE_V1)( + KODI_GUI_CONTROL_HANDLE, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_SET_TEXT_V1)(KODI_GUI_CONTROL_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_SET_TYPE_V1)(KODI_GUI_CONTROL_HANDLE, + int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_SPIN_SET_VISIBLE_V1)(KODI_GUI_CONTROL_HANDLE, + bool); + + // gui/controls/text_box.h + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_TEXT_BOX_GET_TEXT_V1)( + KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_TEXT_BOX_RESET_V1)(KODI_GUI_CONTROL_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_TEXT_BOX_SCROLL_V1)(KODI_GUI_CONTROL_HANDLE, + unsigned int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_TEXT_BOX_SET_AUTO_SCROLLING_V1)( + KODI_GUI_CONTROL_HANDLE, int, int, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_TEXT_BOX_SET_TEXT_V1)( + KODI_GUI_CONTROL_HANDLE, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_CONTROLS_TEXT_BOX_SET_VISIBLE_V1)( + KODI_GUI_CONTROL_HANDLE, bool); + + // gui/dialogs/context_menu.h + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_CONTEXT_MENU_OPEN_V1)(const char*, + const char*[], + size_t); + + // gui/dialogs/extended_progress.h + typedef KODI_GUI_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_NEW_DIALOG_V1)( + const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_IS_FINISHED_V1)( + KODI_GUI_HANDLE); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_GET_TEXT_V1)( + KODI_GUI_HANDLE); + typedef char*(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_GET_TITLE_V1)( + KODI_GUI_HANDLE); + typedef float(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_GET_PERCENTAGE_V1)( + KODI_GUI_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_DELETE_DIALOG_V1)( + KODI_GUI_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_MARK_FINISHED_V1)( + KODI_GUI_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_SET_PERCENTAGE_V1)( + KODI_GUI_HANDLE, float); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_SET_PROGRESS_V1)( + KODI_GUI_HANDLE, int, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_SET_TEXT_V1)( + KODI_GUI_HANDLE, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_SET_TITLE_V1)( + KODI_GUI_HANDLE, const char*); + + // gui/dialogs/filebrowser.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_DIRECTORY_V1)( + const char*, const char*, const char*, char**, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_FILE_FROM_DIR_V1)( + const char*, const char*, const char*, const char*, char**, bool, bool, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_FILE_LIST_V1)( + const char*, const char*, const char*, char***, size_t*, bool, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_FILE_V1)( + const char*, const char*, const char*, const char*, char**, bool, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_IMAGE_LIST_V1)( + const char*, const char*, char***, size_t*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_IMAGE_V1)( + const char*, const char*, const char*, char**); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_SOURCE_V1)( + const char*, char**, bool, const char*, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_FILE_BROWSER_CLEAR_FILE_LIST_V1)(char***, + size_t); + + // gui/dialogs/keyboard.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_KEYBOARD_IS_KEYBOARD_ACTIVATED_V1)(); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_KEYBOARD_SEND_TEXT_TO_ACTIVE_KEYBOARD_V1)( + const char*, bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_GET_FILTER_V1)( + const char*, char**, bool, unsigned int); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_GET_INPUT_V1)(const char*, + char**, + bool, + unsigned int); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_GET_INPUT_WITH_HEAD_V1)( + const char*, char**, const char*, bool, bool, unsigned int); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_GET_NEW_PASSWORD_V1)( + const char*, char**, unsigned int); + typedef bool( + ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_GET_NEW_PASSWORD_WITH_HEAD_V1)( + const char*, char**, const char*, bool, unsigned int); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_VERIFY_NEW_PASSWORD_V1)( + char**, unsigned int); + typedef bool( + ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_VERIFY_NEW_PASSWORD_WITH_HEAD_V1)( + char**, const char*, bool, unsigned int); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_VERIFY_PASSWORD_V1)( + const char*, char**, const char*, int, unsigned int); + + // gui/dialogs/numeric.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_GET_DATE_V1)(struct tm*, + const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_GET_IP_ADDRESS_V1)( + const char*, char**, const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_GET_NUMBER_V1)(const char*, + char**, + const char*, + unsigned int); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_GET_SECONDS_V1)(const char*, + char**, + const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_GET_TIME_V1)(struct tm*, + const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_VERIFY_INPUT_V1)(const char*, + char**, + const char*, + bool); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_VERIFY_NEW_PASSWORD_V1)( + char**); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_VERIFY_PASSWORD_V1)( + const char*, const char*, int); + + // gui/dialogs/ok.h + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_OK_SHOW_AND_GET_INPUT_LINE_TEXT_V1)( + const char*, const char*, const char*, const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_OK_SHOW_AND_GET_INPUT_SINGLE_TEXT_V1)( + const char*, const char*); + + // gui/dialogs/progress.h + typedef KODI_GUI_HANDLE(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_NEW_DIALOG_V1)(); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_ABORT_V1)(KODI_GUI_HANDLE); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_IS_CANCELED_V1)(KODI_GUI_HANDLE); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_GET_PERCENTAGE_V1)(KODI_GUI_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_DELETE_DIALOG_V1)(KODI_GUI_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_OPEN_V1)(KODI_GUI_HANDLE); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_SET_CAN_CANCEL_V1)(KODI_GUI_HANDLE, + bool); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_SET_HEADING_V1)(KODI_GUI_HANDLE, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_SET_LINE_V1)(KODI_GUI_HANDLE, + unsigned int, + const char*); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_SET_PERCENTAGE_V1)(KODI_GUI_HANDLE, + int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_SET_PROGRESS_ADVANCE_V1)( + KODI_GUI_HANDLE, int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_SET_PROGRESS_MAX_V1)(KODI_GUI_HANDLE, + int); + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_PROGRESS_SHOW_PROGRESS_BAR_V1)( + KODI_GUI_HANDLE, bool); + + // gui/dialogs/select.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_SELECT_OPEN_MULTI_SELECT_V1)( + const char*, const char*[], const char*[], uint8_t[], size_t, unsigned int); + typedef int(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_SELECT_OPEN_V1)( + const char*, const char*[], size_t, int, unsigned int); + + // gui/dialogs/text_viewer.h + typedef void(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_TEXT_VIEWER_SHOW_V1)(const char*, + const char*); + + // gui/dialogs/yes_no.h + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_YESNO_SHOW_AND_GET_INPUT_LINE_BUTTON_TEXT_V1)( + const char*, const char*, const char*, const char*, bool*, const char*, const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_YESNO_SHOW_AND_GET_INPUT_LINE_TEXT_V1)( + const char*, const char*, const char*, const char*, const char*, const char*); + typedef bool(ATTR_DL_APIENTRYP PFN_KODI_GUI_DIALOGS_YESNO_SHOW_AND_GET_INPUT_SINGLE_TEXT_V1)( + const char*, const char*, bool*, const char*, const char*); + + struct kodi_api_1 + { + // addon_base.h + PFN_KODI_ADDON_GET_ADDON_PATH_V1 kodi_addon_get_addon_path; + PFN_KODI_ADDON_GET_INFO_V1 kodi_addon_get_info; + PFN_KODI_ADDON_GET_LIB_PATH_V1 kodi_addon_get_lib_path; + PFN_KODI_ADDON_GET_SETTING_BOOL_V1 kodi_addon_get_setting_bool; + PFN_KODI_ADDON_GET_SETTING_FLOAT_V1 kodi_addon_get_setting_float; + PFN_KODI_ADDON_GET_SETTING_INT_V1 kodi_addon_get_setting_int; + PFN_KODI_ADDON_GET_SETTING_STRING_V1 kodi_addon_get_setting_string; + PFN_KODI_ADDON_GET_TEMP_PATH_V1 kodi_addon_get_temp_path; + PFN_KODI_ADDON_GET_USER_PATH_V1 kodi_addon_get_user_path; + PFN_KODI_ADDON_INSTANCE_GET_SETTING_BOOL_V1 kodi_addon_instance_get_setting_bool; + PFN_KODI_ADDON_INSTANCE_GET_SETTING_FLOAT_V1 kodi_addon_instance_get_setting_float; + PFN_KODI_ADDON_INSTANCE_GET_SETTING_INT_V1 kodi_addon_instance_get_setting_int; + PFN_KODI_ADDON_INSTANCE_GET_SETTING_STRING_V1 kodi_addon_instance_get_setting_string; + PFN_KODI_ADDON_INSTANCE_GET_USER_PATH_V1 kodi_addon_instance_get_user_path; + PFN_KODI_ADDON_INSTANCE_IS_SETTING_USING_DEFAULT_V1 + kodi_addon_instance_is_setting_using_default; + PFN_KODI_ADDON_INSTANCE_SET_SETTING_BOOL_V1 kodi_addon_instance_set_setting_bool; + PFN_KODI_ADDON_INSTANCE_SET_SETTING_FLOAT_V1 kodi_addon_instance_set_setting_float; + PFN_KODI_ADDON_INSTANCE_SET_SETTING_INT_V1 kodi_addon_instance_set_setting_int; + PFN_KODI_ADDON_INSTANCE_SET_SETTING_STRING_V1 kodi_addon_instance_set_setting_string; + PFN_KODI_ADDON_IS_SETTING_USING_DEFAULT_V1 kodi_addon_is_setting_using_default; + PFN_KODI_ADDON_LOCALIZED_STRING_V1 kodi_addon_localized_string; + PFN_KODI_ADDON_OPEN_SETTINGS_DIALOG_V1 kodi_addon_open_settings_dialog; + PFN_KODI_ADDON_SET_SETTING_BOOL_V1 kodi_addon_set_setting_bool; + PFN_KODI_ADDON_SET_SETTING_FLOAT_V1 kodi_addon_set_setting_float; + PFN_KODI_ADDON_SET_SETTING_INT_V1 kodi_addon_set_setting_int; + PFN_KODI_ADDON_SET_SETTING_STRING_V1 kodi_addon_set_setting_string; + PFN_KODI_CHECK_MAIN_SHARED_V1 kodi_check_main_shared; + PFN_KODI_DEINIT_V1 kodi_deinit; + PFN_KODI_INIT_V1 kodi_init; + PFN_KODI_LOG_V1 kodi_log; + PFN_KODI_PROCESS_V1 kodi_process; + + // audio_engine.h + PFN_KODI_AUDIOENGINE_GET_CURRENT_SINK_FORMAT_V1 kodi_audioengine_get_current_sink_format; + PFN_KODI_AUDIOENGINE_IS_PLANAR_FORMAT_V1 kodi_audioengine_is_planar_format; + PFN_KODI_AUDIOENGINE_STREAM_ADD_DATA_V1 kodi_audioengine_stream_add_data; + PFN_KODI_AUDIOENGINE_STREAM_DRAIN_V1 kodi_audioengine_stream_drain; + PFN_KODI_AUDIOENGINE_STREAM_FLUSH_V1 kodi_audioengine_stream_flush; + PFN_KODI_AUDIOENGINE_STREAM_FREE_V1 kodi_audioengine_stream_free; + PFN_KODI_AUDIOENGINE_STREAM_GET_AMPLIFICATION_V1 kodi_audioengine_stream_get_amplification; + PFN_KODI_AUDIOENGINE_STREAM_GET_CACHE_TIME_V1 kodi_audioengine_stream_get_cache_time; + PFN_KODI_AUDIOENGINE_STREAM_GET_CACHE_TOTAL_V1 kodi_audioengine_stream_get_cache_total; + PFN_KODI_AUDIOENGINE_STREAM_GET_CHANNEL_COUNT_V1 kodi_audioengine_stream_get_channel_count; + PFN_KODI_AUDIOENGINE_STREAM_GET_DATA_FORMAT_V1 kodi_audioengine_stream_get_data_format; + PFN_KODI_AUDIOENGINE_STREAM_GET_DELAY_V1 kodi_audioengine_stream_get_delay; + PFN_KODI_AUDIOENGINE_STREAM_GET_FRAME_SIZE_V1 kodi_audioengine_stream_get_frame_size; + PFN_KODI_AUDIOENGINE_STREAM_GET_RESAMPLE_RATIO_V1 kodi_audioengine_stream_get_resample_ratio; + PFN_KODI_AUDIOENGINE_STREAM_GET_SAMPLE_RATE_V1 kodi_audioengine_stream_get_sample_rate; + PFN_KODI_AUDIOENGINE_STREAM_GET_SPACE_V1 kodi_audioengine_stream_get_space; + PFN_KODI_AUDIOENGINE_STREAM_GET_VOLUME_V1 kodi_audioengine_stream_get_volume; + PFN_KODI_AUDIOENGINE_STREAM_IS_BUFFERING_V1 kodi_audioengine_stream_is_buffering; + PFN_KODI_AUDIOENGINE_STREAM_IS_DRAINED_V1 kodi_audioengine_stream_is_drained; + PFN_KODI_AUDIOENGINE_STREAM_IS_DRAINING_V1 kodi_audioengine_stream_is_draining; + PFN_KODI_AUDIOENGINE_STREAM_MAKE_V1 kodi_audioengine_stream_make; + PFN_KODI_AUDIOENGINE_STREAM_PAUSE_V1 kodi_audioengine_stream_pause; + PFN_KODI_AUDIOENGINE_STREAM_RESUME_V1 kodi_audioengine_stream_resume; + PFN_KODI_AUDIOENGINE_STREAM_SET_AMPLIFICATION_V1 kodi_audioengine_stream_set_amplification; + PFN_KODI_AUDIOENGINE_STREAM_SET_RESAMPLE_RATIO_V1 kodi_audioengine_stream_set_resample_ratio; + PFN_KODI_AUDIOENGINE_STREAM_SET_VOLUME_V1 kodi_audioengine_stream_set_volume; + + // filesystem.h + PFN_KODI_VFS_CAN_OPEN_DIRECTORY_V1 kodi_vfs_can_open_directory; + PFN_KODI_VFS_COPY_FILE_V1 kodi_vfs_copy_file; + PFN_KODI_VFS_CREATE_DIRECTORY_V1 kodi_vfs_create_directory; + PFN_KODI_VFS_DELETE_FILE_V1 kodi_vfs_delete_file; + PFN_KODI_VFS_DIRECTORY_EXISTS_V1 kodi_vfs_directory_exists; + PFN_KODI_VFS_FILE_AT_END_V1 kodi_vfs_file_at_end; + PFN_KODI_VFS_FILE_CLOSE_V1 kodi_vfs_file_close; + PFN_KODI_VFS_FILE_CURL_ADD_OPTION_V1 kodi_vfs_file_curl_add_option; + PFN_KODI_VFS_FILE_CURL_CREATE_V1 kodi_vfs_file_curl_create; + PFN_KODI_VFS_FILE_CURL_OPEN_V1 kodi_vfs_file_curl_open; + PFN_KODI_VFS_FILE_EXISTS_V1 kodi_vfs_file_exists; + PFN_KODI_VFS_FILE_FLUSH_V1 kodi_vfs_file_flush; + PFN_KODI_VFS_FILE_GET_CHUNK_SIZE_V1 kodi_vfs_file_get_chunk_size; + PFN_KODI_VFS_FILE_GET_DOWNLOAD_SPEED_V1 kodi_vfs_file_get_download_speed; + PFN_KODI_VFS_FILE_GET_LENGTH_V1 kodi_vfs_file_get_length; + PFN_KODI_VFS_FILE_GET_POSITION_V1 kodi_vfs_file_get_position; + PFN_KODI_VFS_FILE_GET_PROPERTY_VALUES_V1 kodi_vfs_file_get_property_values; + PFN_KODI_VFS_FILE_GET_PROPERTY_VALUE_V1 kodi_vfs_file_get_property_value; + PFN_KODI_VFS_FILE_IO_CTL_GET_CACHE_STATUS_V1 kodi_vfs_file_io_ctl_get_cache_status; + PFN_KODI_VFS_FILE_IO_CTL_GET_SEEK_POSSIBLE_V1 kodi_vfs_file_io_ctl_get_seek_possible; + PFN_KODI_VFS_FILE_IO_CTL_SET_CACHE_RATE_V1 kodi_vfs_file_io_ctl_set_cache_rate; + PFN_KODI_VFS_FILE_IO_CTL_SET_RETRY_V1 kodi_vfs_file_io_ctl_set_retry; + PFN_KODI_VFS_FILE_OPEN_FOR_WRITE_V1 kodi_vfs_file_open_for_write; + PFN_KODI_VFS_FILE_OPEN_V1 kodi_vfs_file_open; + PFN_KODI_VFS_FILE_READ_LINE_V1 kodi_vfs_file_read_line; + PFN_KODI_VFS_FILE_READ_V1 kodi_vfs_file_read; + PFN_KODI_VFS_FILE_SEEK_V1 kodi_vfs_file_seek; + PFN_KODI_VFS_FILE_TRUNCATE_V1 kodi_vfs_file_truncate; + PFN_KODI_VFS_FILE_WRITE_V1 kodi_vfs_file_write; + PFN_KODI_VFS_FREE_DIRECTORY_V1 kodi_vfs_free_directory; + PFN_KODI_VFS_GET_CACHE_THUMB_NAME_V1 kodi_vfs_get_cache_thumb_name; + PFN_KODI_VFS_GET_CONTENT_TYPE_V1 kodi_vfs_get_content_type; + PFN_KODI_VFS_GET_COOKIES_V1 kodi_vfs_get_cookies; + PFN_KODI_VFS_GET_DIRECTORY_V1 kodi_vfs_get_directory; + PFN_KODI_VFS_GET_DISK_SPACE_V1 kodi_vfs_get_disk_space; + PFN_KODI_VFS_GET_FILE_MD5_V1 kodi_vfs_get_file_md5; + PFN_KODI_VFS_GET_MIME_TYPE_V1 kodi_vfs_get_mime_type; + PFN_KODI_VFS_HTTP_HEADER_CLOSE_V1 kodi_vfs_http_header_close; + PFN_KODI_VFS_HTTP_HEADER_GET_CHARSET_V1 kodi_vfs_http_header_get_charset; + PFN_KODI_VFS_HTTP_HEADER_GET_HEADER_V1 kodi_vfs_http_header_get_header; + PFN_KODI_VFS_HTTP_HEADER_GET_MIME_TYPE_V1 kodi_vfs_http_header_get_mime_type; + PFN_KODI_VFS_HTTP_HEADER_GET_PROTO_LINE_V1 kodi_vfs_http_header_get_proto_line; + PFN_KODI_VFS_HTTP_HEADER_GET_VALUES_V1 kodi_vfs_http_header_get_values; + PFN_KODI_VFS_HTTP_HEADER_GET_VALUE_V1 kodi_vfs_http_header_get_value; + PFN_KODI_VFS_HTTP_HEADER_OPEN_V1 kodi_vfs_http_header_open; + PFN_KODI_VFS_IS_INTERNET_STREAM_V1 kodi_vfs_is_internet_stream; + PFN_KODI_VFS_IS_LOCAL_V1 kodi_vfs_is_local; + PFN_KODI_VFS_IS_ON_LAN_V1 kodi_vfs_is_on_lan; + PFN_KODI_VFS_IS_REMOTE_V1 kodi_vfs_is_remote; + PFN_KODI_VFS_IS_URL_V1 kodi_vfs_is_url; + PFN_KODI_VFS_MAKE_LEGAL_FILENAME_V1 kodi_vfs_make_legal_filename; + PFN_KODI_VFS_MAKE_LEGAL_PATH_V1 kodi_vfs_make_legal_path; + PFN_KODI_VFS_REMOVE_DIRECTORY_RECURSIVE_V1 kodi_vfs_remove_directory_recursive; + PFN_KODI_VFS_REMOVE_DIRECTORY_V1 kodi_vfs_remove_directory; + PFN_KODI_VFS_RENAME_FILE_V1 kodi_vfs_rename_file; + PFN_KODI_VFS_STAT_FILE_V1 kodi_vfs_stat_file; + PFN_KODI_VFS_TRANSLATE_SPECIAL_PROTOCOL_V1 kodi_vfs_translate_special_protocol; + + // general.h + PFN_KODI_CHANGE_KEYBOARD_LAYOUT_V1 kodi_change_keyboard_layout; + PFN_KODI_GET_CURRENT_SKIN_ID_V1 kodi_get_current_skin_id; + PFN_KODI_GET_DIGEST_V1 kodi_get_digest; + PFN_KODI_GET_FREE_MEM_V1 kodi_get_free_mem; + PFN_KODI_GET_GLOBAL_IDLE_TIME_V1 kodi_get_global_idle_time; + PFN_KODI_GET_KEYBOARD_LAYOUT_V1 kodi_get_keyboard_layout; + PFN_KODI_GET_LANGUAGE_V1 kodi_get_language; + PFN_KODI_GET_LOCALIZED_STRING_V1 kodi_get_localized_string; + PFN_KODI_GET_REGION_V1 kodi_get_region; + PFN_KODI_IS_ADDON_AVILABLE_V1 kodi_is_addon_avilable; + PFN_KODI_PLAY_SFX_V1 kodi_play_sfx; + PFN_KODI_QUEUE_NOTIFICATION_V1 kodi_queue_notification; + PFN_KODI_STOP_SFX_V1 kodi_stop_sfx; + PFN_KODI_UNKNOWN_TO_UTF8_V1 kodi_unknown_to_utf8; + PFN_KODI_VERSION_V1 kodi_version; + + // monitor.h + PFN_KODI_MONITOR_ABORT_REQUESTED_V1 kodi_monitor_abort_requested; + PFN_KODI_MONITOR_WAIT_FOR_ABORT_V1 kodi_monitor_wait_for_abort; + + // network.h + PFN_KODI_NETWORK_DNS_LOOKUP_V1 kodi_network_dns_lookup; + PFN_KODI_NETWORK_GET_HOSTNAME_V1 kodi_network_get_hostname; + PFN_KODI_NETWORK_GET_IP_ADDRESS_V1 kodi_network_get_ip_address; + PFN_KODI_NETWORK_GET_USER_AGENT_V1 kodi_network_get_user_agent; + PFN_KODI_NETWORK_IS_HOST_ON_LAN_V1 kodi_network_is_host_on_lan; + PFN_KODI_NETWORK_IS_LOCAL_HOST_V1 kodi_network_is_local_host; + PFN_KODI_NETWORK_URL_ENCODE_V1 kodi_network_url_encode; + PFN_KODI_NETWORK_WAKE_ON_LAN_V1 kodi_network_wake_on_lan; + + // addon-instance/audioencoder.h + PFN_KODI_ADDON_AUDIOENCODER_SEEK_V1 kodi_addon_audioencoder_seek; + PFN_KODI_ADDON_AUDIOENCODER_WRITE_V1 kodi_addon_audioencoder_write; + + // addon-instance/game.h + PFN_KODI_ADDON_GAME_ADD_STREAM_DATA_V1 kodi_addon_game_add_stream_data; + PFN_KODI_ADDON_GAME_CLOSE_STREAM_V1 kodi_addon_game_close_stream; + PFN_KODI_ADDON_GAME_CLOSE_V1 kodi_addon_game_close; + PFN_KODI_ADDON_GAME_GET_STREAM_BUFFER_V1 kodi_addon_game_get_stream_buffer; + PFN_KODI_ADDON_GAME_HW_GET_PROC_ADDRESS_V1 kodi_addon_game_hw_get_proc_address; + PFN_KODI_ADDON_GAME_INPUT_EVENT_V1 kodi_addon_game_input_event; + PFN_KODI_ADDON_GAME_OPEN_STREAM_V1 kodi_addon_game_open_stream; + PFN_KODI_ADDON_GAME_RELEASE_STREAM_BUFFER_V1 kodi_addon_game_release_stream_buffer; + + // addon-instance/inputstream.h + PFN_KODI_ADDON_INPUTSTREAM_ALLOCATE_DEMUX_PACKET_V1 + kodi_addon_inputstream_allocate_demux_packet; + PFN_KODI_ADDON_INPUTSTREAM_ALLOCATE_ENCRYPTED_DEMUX_PACKET_V1 + kodi_addon_inputstream_allocate_encrypted_demux_packet; + PFN_KODI_ADDON_INPUTSTREAM_FREE_DEMUX_PACKET_V1 kodi_addon_inputstream_free_demux_packet; + + // addon-instance/peripheral.h + PFN_KODI_ADDON_PERIPHERAL_FEATURE_COUNT_V1 kodi_addon_peripheral_feature_count; + PFN_KODI_ADDON_PERIPHERAL_FEATURE_TYPE_V1 kodi_addon_peripheral_feature_type; + PFN_KODI_ADDON_PERIPHERAL_REFRESH_BUTTON_MAPS_V1 kodi_addon_peripheral_refresh_button_maps; + PFN_KODI_ADDON_PERIPHERAL_TRIGGER_SCAN_V1 kodi_addon_peripheral_trigger_scan; + + // addon-instance/pvr.h + PFN_KODI_ADDON_PVR_ADD_MENU_HOOK_V1 kodi_addon_pvr_add_menu_hook; + PFN_KODI_ADDON_PVR_CONNECTION_STATE_CHANGE_V1 kodi_addon_pvr_connection_state_change; + PFN_KODI_ADDON_PVR_EPG_EVENT_STATE_CHANGE_V1 kodi_addon_pvr_epg_event_state_change; + PFN_KODI_ADDON_PVR_GET_EPG_MAX_FUTURE_DAYS_V1 kodi_addon_pvr_get_epg_max_future_days; + PFN_KODI_ADDON_PVR_GET_EPG_MAX_PAST_DAYS_V1 kodi_addon_pvr_get_epg_max_past_days; + PFN_KODI_ADDON_PVR_RECORDING_NOTIFICATION_V1 kodi_addon_pvr_recording_notification; + PFN_KODI_ADDON_PVR_TRANSFER_CHANNEL_ENTRY_V1 kodi_addon_pvr_transfer_channel_entry; + PFN_KODI_ADDON_PVR_TRANSFER_CHANNEL_GROUP_MEMBER_V1 + kodi_addon_pvr_transfer_channel_group_member; + PFN_KODI_ADDON_PVR_TRANSFER_CHANNEL_GROUP_V1 kodi_addon_pvr_transfer_channel_group; + PFN_KODI_ADDON_PVR_TRANSFER_EPG_ENTRY_V1 kodi_addon_pvr_transfer_epg_entry; + PFN_KODI_ADDON_PVR_TRANSFER_PROVIDER_ENTRY_V1 kodi_addon_pvr_transfer_provider_entry; + PFN_KODI_ADDON_PVR_TRANSFER_RECORDING_ENTRY_V1 kodi_addon_pvr_transfer_recording_entry; + PFN_KODI_ADDON_PVR_TRANSFER_TIMER_ENTRY_V1 kodi_addon_pvr_transfer_timer_entry; + PFN_KODI_ADDON_PVR_TRIGGER_CHANNEL_GROUPS_UPDATE_V1 + kodi_addon_pvr_trigger_channel_groups_update; + PFN_KODI_ADDON_PVR_TRIGGER_CHANNEL_UPDATE_V1 kodi_addon_pvr_trigger_channel_update; + PFN_KODI_ADDON_PVR_TRIGGER_EPG_UPDATE_V1 kodi_addon_pvr_trigger_epg_update; + PFN_KODI_ADDON_PVR_TRIGGER_PROVIDERS_UPDATE_V1 kodi_addon_pvr_trigger_providers_update; + PFN_KODI_ADDON_PVR_TRIGGER_RECORDING_UPDATE_V1 kodi_addon_pvr_trigger_recording_update; + PFN_KODI_ADDON_PVR_TRIGGER_TIMER_UPDATE_V1 kodi_addon_pvr_trigger_timer_update; + + // addon-instance/screensaver.h + PFN_KODI_ADDON_SCREENSAVER_GET_PROPERTIES_V1 kodi_addon_screensaver_get_properties; + + // addon-instance/vfs.h + PFN_KODI_ADDON_VFS_GET_DIR_CB__GET_KEYBOARD_INPUT_V1 + kodi_addon_vfs_get_dir_cb__get_keyboard_input; + PFN_KODI_ADDON_VFS_GET_DIR_CB__REQUIRE_AUTHENTICATION_V1 + kodi_addon_vfs_get_dir_cb__require_authentication; + PFN_KODI_ADDON_VFS_GET_DIR_CB__SET_ERROR_DIALOG_V1 kodi_addon_vfs_get_dir_cb__set_error_dialog; + + // addon-instance/videocodec.h + PFN_KODI_ADDON_VIDEOCODEC_GET_FRAME_BUFFER_V1 kodi_addon_videocodec_get_frame_buffer; + PFN_KODI_ADDON_VIDEOCODEC_RELEASE_FRAME_BUFFER_V1 kodi_addon_videocodec_release_frame_buffer; + + // addon-instance/visualization.h + PFN_KODI_ADDON_VISUALIZATION_CLEAR_PRESETS_V1 kodi_addon_visualization_clear_presets; + PFN_KODI_ADDON_VISUALIZATION_GET_PROPERTIES_V1 kodi_addon_visualization_get_properties; + PFN_KODI_ADDON_VISUALIZATION_TRANSFER_PRESET_V1 kodi_addon_visualization_transfer_preset; + + // addon-instance/web.h + PFN_KODI_ADDON_WEB_CONTROL_REQUEST_OPEN_SITE_IN_NEW_TAB_V1 + kodi_addon_web_control_request_open_site_in_new_tab; + PFN_KODI_ADDON_WEB_CONTROL_SET_CONTROL_READY_V1 kodi_addon_web_control_set_control_ready; + PFN_KODI_ADDON_WEB_CONTROL_SET_FULLSCREEN_V1 kodi_addon_web_control_set_fullscreen; + PFN_KODI_ADDON_WEB_CONTROL_SET_ICON_URL_V1 kodi_addon_web_control_set_icon_url; + PFN_KODI_ADDON_WEB_CONTROL_SET_LOADING_STATE_V1 kodi_addon_web_control_set_loading_state; + PFN_KODI_ADDON_WEB_CONTROL_SET_OPENED_ADDRESS_V1 kodi_addon_web_control_set_opened_address; + PFN_KODI_ADDON_WEB_CONTROL_SET_OPENED_TITLE_V1 kodi_addon_web_control_set_opened_title; + PFN_KODI_ADDON_WEB_CONTROL_SET_STATUS_MESSAGE_V1 kodi_addon_web_control_set_status_message; + PFN_KODI_ADDON_WEB_CONTROL_SET_TOOLTIP_V1 kodi_addon_web_control_set_tooltip; + PFN_KODI_ADDON_WEB_INHIBIT_SCREENSAVER_V1 kodi_addon_web_inhibit_screensaver; + PFN_KODI_ADDON_WEB_INHIBIT_SHUTDOWN_V1 kodi_addon_web_inhibit_shutdown; + PFN_KODI_ADDON_WEB_IS_MUTED_V1 kodi_addon_web_is_muted; + + // gui/general.h + PFN_KODI_GUI_GET_CURRENT_WINDOW_DIALOG_ID_V1 kodi_gui_get_current_window_dialog_id; + PFN_KODI_GUI_GET_CURRENT_WINDOW_ID_V1 kodi_gui_get_current_window_id; + PFN_KODI_GUI_GET_HW_CONTEXT_V1 kodi_gui_get_hw_context; + PFN_KODI_GUI_GET_SCREEN_HEIGHT_V1 kodi_gui_get_screen_height; + PFN_KODI_GUI_GET_SCREEN_WIDTH_V1 kodi_gui_get_screen_width; + PFN_KODI_GUI_GET_VIDEO_RESOLUTION_V1 kodi_gui_get_video_resolution; + PFN_KODI_GUI_LOCK_V1 kodi_gui_lock; + PFN_KODI_GUI_UNLOCK_V1 kodi_gui_unlock; + + // gui/list_item.h + PFN_KODI_GUI_LISTITEM_CREATE_V1 kodi_gui_listitem_create; + PFN_KODI_GUI_LISTITEM_DESTROY_V1 kodi_gui_listitem_destroy; + PFN_KODI_GUI_LISTITEM_GET_ART_V1 kodi_gui_listitem_get_art; + PFN_KODI_GUI_LISTITEM_GET_LABEL2_V1 kodi_gui_listitem_get_label2; + PFN_KODI_GUI_LISTITEM_GET_LABEL_V1 kodi_gui_listitem_get_label; + PFN_KODI_GUI_LISTITEM_GET_PATH_V1 kodi_gui_listitem_get_path; + PFN_KODI_GUI_LISTITEM_GET_PROPERTY_V1 kodi_gui_listitem_get_property; + PFN_KODI_GUI_LISTITEM_IS_SELECTED_V1 kodi_gui_listitem_is_selected; + PFN_KODI_GUI_LISTITEM_SELECT_V1 kodi_gui_listitem_select; + PFN_KODI_GUI_LISTITEM_SET_ART_V1 kodi_gui_listitem_set_art; + PFN_KODI_GUI_LISTITEM_SET_LABEL2_V1 kodi_gui_listitem_set_label2; + PFN_KODI_GUI_LISTITEM_SET_LABEL_V1 kodi_gui_listitem_set_label; + PFN_KODI_GUI_LISTITEM_SET_PATH_V1 kodi_gui_listitem_set_path; + PFN_KODI_GUI_LISTITEM_SET_PROPERTY_V1 kodi_gui_listitem_set_property; + + // gui/window.h + PFN_KODI_GUI_WINDOW_ADD_LIST_ITEM_V1 kodi_gui_window_add_list_item; + PFN_KODI_GUI_WINDOW_CLEAR_ITEM_LIST_V1 kodi_gui_window_clear_item_list; + PFN_KODI_GUI_WINDOW_CLEAR_PROPERTIES_V1 kodi_gui_window_clear_properties; + PFN_KODI_GUI_WINDOW_CLEAR_PROPERTY_V1 kodi_gui_window_clear_property; + PFN_KODI_GUI_WINDOW_CLOSE_V1 kodi_gui_window_close; + PFN_KODI_GUI_WINDOW_CREATE_V1 kodi_gui_window_create; + PFN_KODI_GUI_WINDOW_DESTROY_V1 kodi_gui_window_destroy; + PFN_KODI_GUI_WINDOW_DO_MODAL_V1 kodi_gui_window_do_modal; + PFN_KODI_GUI_WINDOW_GET_CONTROL_BUTTON_V1 kodi_gui_window_get_control_button; + PFN_KODI_GUI_WINDOW_GET_CONTROL_EDIT_V1 kodi_gui_window_get_control_edit; + PFN_KODI_GUI_WINDOW_GET_CONTROL_FADE_LABEL_V1 kodi_gui_window_get_control_fade_label; + PFN_KODI_GUI_WINDOW_GET_CONTROL_IMAGE_V1 kodi_gui_window_get_control_image; + PFN_KODI_GUI_WINDOW_GET_CONTROL_LABEL_V1 kodi_gui_window_get_control_label; + PFN_KODI_GUI_WINDOW_GET_CONTROL_PROGRESS_V1 kodi_gui_window_get_control_progress; + PFN_KODI_GUI_WINDOW_GET_CONTROL_RADIO_BUTTON_V1 kodi_gui_window_get_control_radio_button; + PFN_KODI_GUI_WINDOW_GET_CONTROL_RENDER_ADDON_V1 kodi_gui_window_get_control_render_addon; + PFN_KODI_GUI_WINDOW_GET_CONTROL_SETTINGS_SLIDER_V1 kodi_gui_window_get_control_settings_slider; + PFN_KODI_GUI_WINDOW_GET_CONTROL_SLIDER_V1 kodi_gui_window_get_control_slider; + PFN_KODI_GUI_WINDOW_GET_CONTROL_SPIN_V1 kodi_gui_window_get_control_spin; + PFN_KODI_GUI_WINDOW_GET_CONTROL_TEXT_BOX_V1 kodi_gui_window_get_control_text_box; + PFN_KODI_GUI_WINDOW_GET_CURRENT_CONTAINER_ID_V1 kodi_gui_window_get_current_container_id; + PFN_KODI_GUI_WINDOW_GET_CURRENT_LIST_POSITION_V1 kodi_gui_window_get_current_list_position; + PFN_KODI_GUI_WINDOW_GET_FOCUS_ID_V1 kodi_gui_window_get_focus_id; + PFN_KODI_GUI_WINDOW_GET_LIST_ITEM_V1 kodi_gui_window_get_list_item; + PFN_KODI_GUI_WINDOW_GET_LIST_SIZE_V1 kodi_gui_window_get_list_size; + PFN_KODI_GUI_WINDOW_GET_PROPERTY_BOOL_V1 kodi_gui_window_get_property_bool; + PFN_KODI_GUI_WINDOW_GET_PROPERTY_DOUBLE_V1 kodi_gui_window_get_property_double; + PFN_KODI_GUI_WINDOW_GET_PROPERTY_INT_V1 kodi_gui_window_get_property_int; + PFN_KODI_GUI_WINDOW_GET_PROPERTY_V1 kodi_gui_window_get_property; + PFN_KODI_GUI_WINDOW_MARK_DIRTY_REGION_V1 kodi_gui_window_mark_dirty_region; + PFN_KODI_GUI_WINDOW_REMOVE_LIST_ITEM_FROM_POSITION_V1 + kodi_gui_window_remove_list_item_from_position; + PFN_KODI_GUI_WINDOW_REMOVE_LIST_ITEM_V1 kodi_gui_window_remove_list_item; + PFN_KODI_GUI_WINDOW_SET_CONTAINER_CONTENT_V1 kodi_gui_window_set_container_content; + PFN_KODI_GUI_WINDOW_SET_CONTAINER_PROPERTY_V1 kodi_gui_window_set_container_property; + PFN_KODI_GUI_WINDOW_SET_CONTROL_LABEL_V1 kodi_gui_window_set_control_label; + PFN_KODI_GUI_WINDOW_SET_CONTROL_SELECTED_V1 kodi_gui_window_set_control_selected; + PFN_KODI_GUI_WINDOW_SET_CONTROL_VISIBLE_V1 kodi_gui_window_set_control_visible; + PFN_KODI_GUI_WINDOW_SET_CURRENT_LIST_POSITION_V1 kodi_gui_window_set_current_list_position; + PFN_KODI_GUI_WINDOW_SET_FOCUS_ID_V1 kodi_gui_window_set_focus_id; + PFN_KODI_GUI_WINDOW_SET_PROPERTY_BOOL_V1 kodi_gui_window_set_property_bool; + PFN_KODI_GUI_WINDOW_SET_PROPERTY_DOUBLE_V1 kodi_gui_window_set_property_double; + PFN_KODI_GUI_WINDOW_SET_PROPERTY_INT_V1 kodi_gui_window_set_property_int; + PFN_KODI_GUI_WINDOW_SET_PROPERTY_V1 kodi_gui_window_set_property; + PFN_KODI_GUI_WINDOW_SHOW_V1 kodi_gui_window_show; + + // gui/controls/button.h + PFN_KODI_GUI_CONTROLS_BUTTON_GET_LABEL2_V1 kodi_gui_controls_button_get_label2; + PFN_KODI_GUI_CONTROLS_BUTTON_GET_LABEL_V1 kodi_gui_controls_button_get_label; + PFN_KODI_GUI_CONTROLS_BUTTON_SET_ENABLED_V1 kodi_gui_controls_button_set_enabled; + PFN_KODI_GUI_CONTROLS_BUTTON_SET_LABEL2_V1 kodi_gui_controls_button_set_label2; + PFN_KODI_GUI_CONTROLS_BUTTON_SET_LABEL_V1 kodi_gui_controls_button_set_label; + PFN_KODI_GUI_CONTROLS_BUTTON_SET_VISIBLE_V1 kodi_gui_controls_button_set_visible; + + // gui/controls/edit.h + PFN_KODI_GUI_CONTROLS_EDIT_GET_CURSOR_POSITION_V1 kodi_gui_controls_edit_get_cursor_position; + PFN_KODI_GUI_CONTROLS_EDIT_GET_LABEL_V1 kodi_gui_controls_edit_get_label; + PFN_KODI_GUI_CONTROLS_EDIT_GET_TEXT_V1 kodi_gui_controls_edit_get_text; + PFN_KODI_GUI_CONTROLS_EDIT_SET_CURSOR_POSITION_V1 kodi_gui_controls_edit_set_cursor_position; + PFN_KODI_GUI_CONTROLS_EDIT_SET_ENABLED_V1 kodi_gui_controls_edit_set_enabled; + PFN_KODI_GUI_CONTROLS_EDIT_SET_INPUT_TYPE_V1 kodi_gui_controls_edit_set_input_type; + PFN_KODI_GUI_CONTROLS_EDIT_SET_LABEL_V1 kodi_gui_controls_edit_set_label; + PFN_KODI_GUI_CONTROLS_EDIT_SET_TEXT_V1 kodi_gui_controls_edit_set_text; + PFN_KODI_GUI_CONTROLS_EDIT_SET_VISIBLE_V1 kodi_gui_controls_edit_set_visible; + + // gui/controls/fade_label.h + PFN_KODI_GUI_CONTROLS_FADE_LABEL_ADD_LABEL_V1 kodi_gui_controls_fade_label_add_label; + PFN_KODI_GUI_CONTROLS_FADE_LABEL_GET_LABEL_V1 kodi_gui_controls_fade_label_get_label; + PFN_KODI_GUI_CONTROLS_FADE_LABEL_RESET_V1 kodi_gui_controls_fade_label_reset; + PFN_KODI_GUI_CONTROLS_FADE_LABEL_SET_SCROLLING_V1 kodi_gui_controls_fade_label_set_scrolling; + PFN_KODI_GUI_CONTROLS_FADE_LABEL_SET_VISIBLE_V1 kodi_gui_controls_fade_label_set_visible; + + // gui/controls/image.h + PFN_KODI_GUI_CONTROLS_IMAGE_SET_COLOR_DIFFUSE_V1 kodi_gui_controls_image_set_color_diffuse; + PFN_KODI_GUI_CONTROLS_IMAGE_SET_FILENAME_V1 kodi_gui_controls_image_set_filename; + PFN_KODI_GUI_CONTROLS_IMAGE_SET_VISIBLE_V1 kodi_gui_controls_image_set_visible; + + // gui/controls/label.h + PFN_KODI_GUI_CONTROLS_LABEL_GET_LABEL_V1 kodi_gui_controls_label_get_label; + PFN_KODI_GUI_CONTROLS_LABEL_SET_LABEL_V1 kodi_gui_controls_label_set_label; + PFN_KODI_GUI_CONTROLS_LABEL_SET_VISIBLE_V1 kodi_gui_controls_label_set_visible; + + // gui/controls/progress.h + PFN_KODI_GUI_CONTROLS_PROGRESS_GET_PERCENTAGE_V1 kodi_gui_controls_progress_get_percentage; + PFN_KODI_GUI_CONTROLS_PROGRESS_SET_PERCENTAGE_V1 kodi_gui_controls_progress_set_percentage; + PFN_KODI_GUI_CONTROLS_PROGRESS_SET_VISIBLE_V1 kodi_gui_controls_progress_set_visible; + + // gui/controls/radio_button.h + PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_GET_LABEL_V1 kodi_gui_controls_radio_button_get_label; + PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_IS_SELECTED_V1 kodi_gui_controls_radio_button_is_selected; + PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_SET_ENABLED_V1 kodi_gui_controls_radio_button_set_enabled; + PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_SET_LABEL_V1 kodi_gui_controls_radio_button_set_label; + PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_SET_SELECTED_V1 kodi_gui_controls_radio_button_set_selected; + PFN_KODI_GUI_CONTROLS_RADIO_BUTTON_SET_VISIBLE_V1 kodi_gui_controls_radio_button_set_visible; + + // gui/controls/rendering.h + PFN_KODI_GUI_CONTROLS_RADIO_RENDERING_DESTROY_V1 kodi_gui_controls_radio_rendering_destroy; + + // gui/controls/settings_slider.h + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_GET_FLOAT_VALUE_V1 + kodi_gui_controls_settings_slider_get_float_value; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_GET_INT_VALUE_V1 + kodi_gui_controls_settings_slider_get_int_value; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_GET_PERCENTAGE_V1 + kodi_gui_controls_settings_slider_get_percentage; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_RESET_V1 kodi_gui_controls_settings_slider_reset; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_ENABLED_V1 + kodi_gui_controls_settings_slider_set_enabled; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_FLOAT_INTERVAL_V1 + kodi_gui_controls_settings_slider_set_float_interval; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_FLOAT_RANGE_V1 + kodi_gui_controls_settings_slider_set_float_range; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_FLOAT_VALUE_V1 + kodi_gui_controls_settings_slider_set_float_value; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_INT_INTERVAL_V1 + kodi_gui_controls_settings_slider_set_int_interval; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_INT_RANGE_V1 + kodi_gui_controls_settings_slider_set_int_range; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_INT_VALUE_V1 + kodi_gui_controls_settings_slider_set_int_value; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_PERCENTAGE_V1 + kodi_gui_controls_settings_slider_set_percentage; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_TEXT_V1 kodi_gui_controls_settings_slider_set_text; + PFN_KODI_GUI_CONTROLS_SETTINGS_SLIDER_SET_VISIBLE_V1 + kodi_gui_controls_settings_slider_set_visible; + + // gui/controls/slider.h + PFN_KODI_GUI_CONTROLS_SLIDER_GET_DESCRIPTION_V1 kodi_gui_controls_slider_get_description; + PFN_KODI_GUI_CONTROLS_SLIDER_GET_FLOAT_VALUE_V1 kodi_gui_controls_slider_get_float_value; + PFN_KODI_GUI_CONTROLS_SLIDER_GET_INT_VALUE_V1 kodi_gui_controls_slider_get_int_value; + PFN_KODI_GUI_CONTROLS_SLIDER_GET_PERCENTAGE_V1 kodi_gui_controls_slider_get_percentage; + PFN_KODI_GUI_CONTROLS_SLIDER_RESET_V1 kodi_gui_controls_slider_reset; + PFN_KODI_GUI_CONTROLS_SLIDER_SET_ENABLED_V1 kodi_gui_controls_slider_set_enabled; + PFN_KODI_GUI_CONTROLS_SLIDER_SET_FLOAT_INTERVAL_V1 kodi_gui_controls_slider_set_float_interval; + PFN_KODI_GUI_CONTROLS_SLIDER_SET_FLOAT_RANGE_V1 kodi_gui_controls_slider_set_float_range; + PFN_KODI_GUI_CONTROLS_SLIDER_SET_FLOAT_VALUE_V1 kodi_gui_controls_slider_set_float_value; + PFN_KODI_GUI_CONTROLS_SLIDER_SET_INT_INTERVAL_V1 kodi_gui_controls_slider_set_int_interval; + PFN_KODI_GUI_CONTROLS_SLIDER_SET_INT_RANGE_V1 kodi_gui_controls_slider_set_int_range; + PFN_KODI_GUI_CONTROLS_SLIDER_SET_INT_VALUE_V1 kodi_gui_controls_slider_set_int_value; + PFN_KODI_GUI_CONTROLS_SLIDER_SET_PERCENTAGE_V1 kodi_gui_controls_slider_set_percentage; + PFN_KODI_GUI_CONTROLS_SLIDER_SET_VISIBLE_V1 kodi_gui_controls_slider_set_visible; + + // gui/controls/spin.h + PFN_KODI_GUI_CONTROLS_SPIN_ADD_INT_LABEL_V1 kodi_gui_controls_spin_add_int_label; + PFN_KODI_GUI_CONTROLS_SPIN_ADD_STRING_LABEL_V1 kodi_gui_controls_spin_add_string_label; + PFN_KODI_GUI_CONTROLS_SPIN_GET_FLOAT_VALUE_V1 kodi_gui_controls_spin_get_float_value; + PFN_KODI_GUI_CONTROLS_SPIN_GET_INT_VALUE_V1 kodi_gui_controls_spin_get_int_value; + PFN_KODI_GUI_CONTROLS_SPIN_GET_STRING_VALUE_V1 kodi_gui_controls_spin_get_string_value; + PFN_KODI_GUI_CONTROLS_SPIN_RESET_V1 kodi_gui_controls_spin_reset; + PFN_KODI_GUI_CONTROLS_SPIN_SET_ENABLED_V1 kodi_gui_controls_spin_set_enabled; + PFN_KODI_GUI_CONTROLS_SPIN_SET_FLOAT_INTERVAL_V1 kodi_gui_controls_spin_set_float_interval; + PFN_KODI_GUI_CONTROLS_SPIN_SET_FLOAT_RANGE_V1 kodi_gui_controls_spin_set_float_range; + PFN_KODI_GUI_CONTROLS_SPIN_SET_FLOAT_VALUE_V1 kodi_gui_controls_spin_set_float_value; + PFN_KODI_GUI_CONTROLS_SPIN_SET_INT_RANGE_V1 kodi_gui_controls_spin_set_int_range; + PFN_KODI_GUI_CONTROLS_SPIN_SET_INT_VALUE_V1 kodi_gui_controls_spin_set_int_value; + PFN_KODI_GUI_CONTROLS_SPIN_SET_STRING_VALUE_V1 kodi_gui_controls_spin_set_string_value; + PFN_KODI_GUI_CONTROLS_SPIN_SET_TEXT_V1 kodi_gui_controls_spin_set_text; + PFN_KODI_GUI_CONTROLS_SPIN_SET_TYPE_V1 kodi_gui_controls_spin_set_type; + PFN_KODI_GUI_CONTROLS_SPIN_SET_VISIBLE_V1 kodi_gui_controls_spin_set_visible; + + // gui/controls/text_box.h + PFN_KODI_GUI_CONTROLS_TEXT_BOX_GET_TEXT_V1 kodi_gui_controls_text_box_get_text; + PFN_KODI_GUI_CONTROLS_TEXT_BOX_RESET_V1 kodi_gui_controls_text_box_reset; + PFN_KODI_GUI_CONTROLS_TEXT_BOX_SCROLL_V1 kodi_gui_controls_text_box_scroll; + PFN_KODI_GUI_CONTROLS_TEXT_BOX_SET_AUTO_SCROLLING_V1 + kodi_gui_controls_text_box_set_auto_scrolling; + PFN_KODI_GUI_CONTROLS_TEXT_BOX_SET_TEXT_V1 kodi_gui_controls_text_box_set_text; + PFN_KODI_GUI_CONTROLS_TEXT_BOX_SET_VISIBLE_V1 kodi_gui_controls_text_box_set_visible; + + // gui/dialogs/context_menu.h + PFN_KODI_GUI_DIALOGS_CONTEXT_MENU_OPEN_V1 kodi_gui_dialogs_context_menu_open; + + // gui/dialogs/extended_progress.h + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_DELETE_DIALOG_V1 + kodi_gui_dialogs_extended_progress_delete_dialog; + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_GET_PERCENTAGE_V1 + kodi_gui_dialogs_extended_progress_get_percentage; + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_GET_TEXT_V1 kodi_gui_dialogs_extended_progress_get_text; + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_GET_TITLE_V1 + kodi_gui_dialogs_extended_progress_get_title; + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_IS_FINISHED_V1 + kodi_gui_dialogs_extended_progress_is_finished; + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_MARK_FINISHED_V1 + kodi_gui_dialogs_extended_progress_mark_finished; + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_NEW_DIALOG_V1 + kodi_gui_dialogs_extended_progress_new_dialog; + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_SET_PERCENTAGE_V1 + kodi_gui_dialogs_extended_progress_set_percentage; + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_SET_PROGRESS_V1 + kodi_gui_dialogs_extended_progress_set_progress; + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_SET_TEXT_V1 kodi_gui_dialogs_extended_progress_set_text; + PFN_KODI_GUI_DIALOGS_EXTENDED_PROGRESS_SET_TITLE_V1 + kodi_gui_dialogs_extended_progress_set_title; + + // gui/dialogs/filebrowser.h + PFN_KODI_GUI_DIALOGS_FILE_BROWSER_CLEAR_FILE_LIST_V1 + kodi_gui_dialogs_file_browser_clear_file_list; + PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_DIRECTORY_V1 + kodi_gui_dialogs_file_browser_show_and_get_directory; + PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_FILE_FROM_DIR_V1 + kodi_gui_dialogs_file_browser_show_and_get_file_from_dir; + PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_FILE_LIST_V1 + kodi_gui_dialogs_file_browser_show_and_get_file_list; + PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_FILE_V1 + kodi_gui_dialogs_file_browser_show_and_get_file; + PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_IMAGE_LIST_V1 + kodi_gui_dialogs_file_browser_show_and_get_image_list; + PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_IMAGE_V1 + kodi_gui_dialogs_file_browser_show_and_get_image; + PFN_KODI_GUI_DIALOGS_FILE_BROWSER_SHOW_AND_GET_SOURCE_V1 + kodi_gui_dialogs_file_browser_show_and_get_source; + + // gui/dialogs/keyboard.h + PFN_KODI_GUI_DIALOGS_KEYBOARD_IS_KEYBOARD_ACTIVATED_V1 + kodi_gui_dialogs_keyboard_is_keyboard_activated; + PFN_KODI_GUI_DIALOGS_KEYBOARD_SEND_TEXT_TO_ACTIVE_KEYBOARD_V1 + kodi_gui_dialogs_keyboard_send_text_to_active_keyboard; + PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_GET_FILTER_V1 + kodi_gui_dialogs_keyboard_show_and_get_filter; + PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_GET_INPUT_V1 + kodi_gui_dialogs_keyboard_show_and_get_input; + PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_GET_INPUT_WITH_HEAD_V1 + kodi_gui_dialogs_keyboard_show_and_get_input_with_head; + PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_GET_NEW_PASSWORD_V1 + kodi_gui_dialogs_keyboard_show_and_get_new_password; + PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_GET_NEW_PASSWORD_WITH_HEAD_V1 + kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head; + PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_VERIFY_NEW_PASSWORD_V1 + kodi_gui_dialogs_keyboard_show_and_verify_new_password; + PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_VERIFY_NEW_PASSWORD_WITH_HEAD_V1 + kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head; + PFN_KODI_GUI_DIALOGS_KEYBOARD_SHOW_AND_VERIFY_PASSWORD_V1 + kodi_gui_dialogs_keyboard_show_and_verify_password; + + // gui/dialogs/numeric.h + PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_GET_DATE_V1 kodi_gui_dialogs_numeric_show_and_get_date; + PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_GET_IP_ADDRESS_V1 + kodi_gui_dialogs_numeric_show_and_get_ip_address; + PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_GET_NUMBER_V1 + kodi_gui_dialogs_numeric_show_and_get_number; + PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_GET_SECONDS_V1 + kodi_gui_dialogs_numeric_show_and_get_seconds; + PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_GET_TIME_V1 kodi_gui_dialogs_numeric_show_and_get_time; + PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_VERIFY_INPUT_V1 + kodi_gui_dialogs_numeric_show_and_verify_input; + PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_VERIFY_NEW_PASSWORD_V1 + kodi_gui_dialogs_numeric_show_and_verify_new_password; + PFN_KODI_GUI_DIALOGS_NUMERIC_SHOW_AND_VERIFY_PASSWORD_V1 + kodi_gui_dialogs_numeric_show_and_verify_password; + + // gui/dialogs/ok.h + PFN_KODI_GUI_DIALOGS_OK_SHOW_AND_GET_INPUT_LINE_TEXT_V1 + kodi_gui_dialogs_ok_show_and_get_input_line_text; + PFN_KODI_GUI_DIALOGS_OK_SHOW_AND_GET_INPUT_SINGLE_TEXT_V1 + kodi_gui_dialogs_ok_show_and_get_input_single_text; + + // gui/dialogs/progress.h + PFN_KODI_GUI_DIALOGS_PROGRESS_ABORT_V1 kodi_gui_dialogs_progress_abort; + PFN_KODI_GUI_DIALOGS_PROGRESS_DELETE_DIALOG_V1 kodi_gui_dialogs_progress_delete_dialog; + PFN_KODI_GUI_DIALOGS_PROGRESS_GET_PERCENTAGE_V1 kodi_gui_dialogs_progress_get_percentage; + PFN_KODI_GUI_DIALOGS_PROGRESS_IS_CANCELED_V1 kodi_gui_dialogs_progress_is_canceled; + PFN_KODI_GUI_DIALOGS_PROGRESS_NEW_DIALOG_V1 kodi_gui_dialogs_progress_new_dialog; + PFN_KODI_GUI_DIALOGS_PROGRESS_OPEN_V1 kodi_gui_dialogs_progress_open; + PFN_KODI_GUI_DIALOGS_PROGRESS_SET_CAN_CANCEL_V1 kodi_gui_dialogs_progress_set_can_cancel; + PFN_KODI_GUI_DIALOGS_PROGRESS_SET_HEADING_V1 kodi_gui_dialogs_progress_set_heading; + PFN_KODI_GUI_DIALOGS_PROGRESS_SET_LINE_V1 kodi_gui_dialogs_progress_set_line; + PFN_KODI_GUI_DIALOGS_PROGRESS_SET_PERCENTAGE_V1 kodi_gui_dialogs_progress_set_percentage; + PFN_KODI_GUI_DIALOGS_PROGRESS_SET_PROGRESS_ADVANCE_V1 + kodi_gui_dialogs_progress_set_progress_advance; + PFN_KODI_GUI_DIALOGS_PROGRESS_SET_PROGRESS_MAX_V1 kodi_gui_dialogs_progress_set_progress_max; + PFN_KODI_GUI_DIALOGS_PROGRESS_SHOW_PROGRESS_BAR_V1 kodi_gui_dialogs_progress_show_progress_bar; + + // gui/dialogs/select.h + PFN_KODI_GUI_DIALOGS_SELECT_OPEN_MULTI_SELECT_V1 kodi_gui_dialogs_select_open_multi_select; + PFN_KODI_GUI_DIALOGS_SELECT_OPEN_V1 kodi_gui_dialogs_select_open; + + // gui/dialogs/text_viewer.h + PFN_KODI_GUI_DIALOGS_TEXT_VIEWER_SHOW_V1 kodi_gui_dialogs_text_viewer_show; + + // gui/dialogs/yes_no.h + PFN_KODI_GUI_DIALOGS_YESNO_SHOW_AND_GET_INPUT_LINE_BUTTON_TEXT_V1 + kodi_gui_dialogs_yesno_show_and_get_input_line_button_text; + PFN_KODI_GUI_DIALOGS_YESNO_SHOW_AND_GET_INPUT_LINE_TEXT_V1 + kodi_gui_dialogs_yesno_show_and_get_input_line_text; + PFN_KODI_GUI_DIALOGS_YESNO_SHOW_AND_GET_INPUT_SINGLE_TEXT_V1 + kodi_gui_dialogs_yesno_show_and_get_input_single_text; + }; + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* C_API_DL_API_1_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/filesystem.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/filesystem.h index aedcf6434e378..78a45b2cfc062 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/filesystem.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/filesystem.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2018 Team Kodi + * Copyright (C) 2005-2020 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later @@ -9,8 +9,8 @@ #ifndef C_API_FILESYSTEM_H #define C_API_FILESYSTEM_H -#include -#include +#include "addon_base.h" + #include #ifdef _WIN32 // windows @@ -40,6 +40,9 @@ extern "C" { #endif /* __cplusplus */ + typedef void* KODI_FILE_HDL; + typedef void* KODI_HTTP_HEADER_HDL; + //¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ // "C" Definitions, structures and enumerators of filesystem //{{{ @@ -169,54 +172,24 @@ extern "C" //}}} - //¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ - // "C" Internal interface tables for intercommunications between addon and kodi - //{{{ - - struct KODI_HTTP_HEADER - { - void* handle; - - char* (*get_value)(void* kodiBase, void* handle, const char* param); - char** (*get_values)(void* kodiBase, void* handle, const char* param, int* length); - char* (*get_header)(void* kodiBase, void* handle); - char* (*get_mime_type)(void* kodiBase, void* handle); - char* (*get_charset)(void* kodiBase, void* handle); - char* (*get_proto_line)(void* kodiBase, void* handle); - }; - - struct STAT_STRUCTURE + struct VFS_STAT_STRUCTURE { - /// ID of device containing file uint32_t deviceId; - /// Total size, in bytes uint64_t size; - /// Time of last access time_t accessTime; - /// Time of last modification time_t modificationTime; - /// Time of last status change time_t statusTime; - /// The stat url is a directory bool isDirectory; - /// The stat url is a symbolic link bool isSymLink; - /// The stat url is block special bool isBlock; - /// The stat url is character special bool isCharacter; - /// The stat url is FIFO special bool isFifo; - /// The stat url is regular bool isRegular; - /// The stat url is socket bool isSocket; - /// The file serial number, which distinguishes this file from all other files on the same - /// device. uint64_t fileSerialNumber; }; - struct VFS_CACHE_STATUS_DATA + struct VFS_CACHE_STATUS { uint64_t forward; uint32_t maxrate; @@ -224,99 +197,149 @@ extern "C" uint32_t lowrate; }; - struct VFSProperty + struct VFS_PROPERTY { char* name; char* val; }; - struct VFSDirEntry + struct VFS_DIR_ENTRY { - char* label; //!< item label - char* title; //!< item title - char* path; //!< item path - unsigned int num_props; //!< Number of properties attached to item - struct VFSProperty* properties; //!< Properties - time_t date_time; //!< file creation date & time - bool folder; //!< Item is a folder - uint64_t size; //!< Size of file represented by item + char* label; + char* title; + char* path; + size_t num_props; + struct VFS_PROPERTY* properties; + time_t date_time; + bool folder; + uint64_t size; }; - typedef struct AddonToKodiFuncTable_kodi_filesystem - { - bool (*can_open_directory)(void* kodiBase, const char* url); - bool (*create_directory)(void* kodiBase, const char* path); - bool (*remove_directory)(void* kodiBase, const char* path); - bool (*directory_exists)(void* kodiBase, const char* path); - bool (*get_directory)(void* kodiBase, - const char* path, - const char* mask, - struct VFSDirEntry** items, - unsigned int* num_items); - void (*free_directory)(void* kodiBase, struct VFSDirEntry* items, unsigned int num_items); - - bool (*file_exists)(void* kodiBase, const char* filename, bool useCache); - bool (*stat_file)(void* kodiBase, const char* filename, struct STAT_STRUCTURE* buffer); - bool (*delete_file)(void* kodiBase, const char* filename); - bool (*rename_file)(void* kodiBase, const char* filename, const char* newFileName); - bool (*copy_file)(void* kodiBase, const char* filename, const char* dest); - - char* (*get_file_md5)(void* kodiBase, const char* filename); - char* (*get_cache_thumb_name)(void* kodiBase, const char* filename); - char* (*make_legal_filename)(void* kodiBase, const char* filename); - char* (*make_legal_path)(void* kodiBase, const char* path); - char* (*translate_special_protocol)(void* kodiBase, const char* strSource); - bool (*is_internet_stream)(void* kodiBase, const char* path, bool strictCheck); - bool (*is_on_lan)(void* kodiBase, const char* path); - bool (*is_remote)(void* kodiBase, const char* path); - bool (*is_local)(void* kodiBase, const char* path); - bool (*is_url)(void* kodiBase, const char* path); - bool (*get_http_header)(void* kodiBase, const char* url, struct KODI_HTTP_HEADER* headers); - bool (*get_mime_type)(void* kodiBase, const char* url, char** content, const char* useragent); - bool (*get_content_type)(void* kodiBase, - const char* url, - char** content, - const char* useragent); - bool (*get_cookies)(void* kodiBase, const char* url, char** cookies); - bool (*http_header_create)(void* kodiBase, struct KODI_HTTP_HEADER* headers); - void (*http_header_free)(void* kodiBase, struct KODI_HTTP_HEADER* headers); - - void* (*open_file)(void* kodiBase, const char* filename, unsigned int flags); - void* (*open_file_for_write)(void* kodiBase, const char* filename, bool overwrite); - ssize_t (*read_file)(void* kodiBase, void* file, void* ptr, size_t size); - bool (*read_file_string)(void* kodiBase, void* file, char* szLine, int iLineLength); - ssize_t (*write_file)(void* kodiBase, void* file, const void* ptr, size_t size); - void (*flush_file)(void* kodiBase, void* file); - int64_t (*seek_file)(void* kodiBase, void* file, int64_t position, int whence); - int (*truncate_file)(void* kodiBase, void* file, int64_t size); - int64_t (*get_file_position)(void* kodiBase, void* file); - int64_t (*get_file_length)(void* kodiBase, void* file); - double (*get_file_download_speed)(void* kodiBase, void* file); - void (*close_file)(void* kodiBase, void* file); - int (*get_file_chunk_size)(void* kodiBase, void* file); - bool (*io_control_get_seek_possible)(void* kodiBase, void* file); - bool (*io_control_get_cache_status)(void* kodiBase, - void* file, - struct VFS_CACHE_STATUS_DATA* status); - bool (*io_control_set_cache_rate)(void* kodiBase, void* file, uint32_t rate); - bool (*io_control_set_retry)(void* kodiBase, void* file, bool retry); - char** (*get_property_values)( - void* kodiBase, void* file, int type, const char* name, int* numValues); - - void* (*curl_create)(void* kodiBase, const char* url); - bool (*curl_add_option)( - void* kodiBase, void* file, int type, const char* name, const char* value); - bool (*curl_open)(void* kodiBase, void* file, unsigned int flags); - - bool (*get_disk_space)( - void* kodiBase, const char* path, uint64_t* capacity, uint64_t* free, uint64_t* available); - bool (*remove_directory_recursive)(void* kodiBase, const char* path); - } AddonToKodiFuncTable_kodi_filesystem; - - //}}} + /*!@{*/ + ATTR_DLL_EXPORT bool kodi_vfs_can_open_directory(const char* url) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_create_directory(const char* path) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_remove_directory(const char* path) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_remove_directory_recursive(const char* path) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_directory_exists(const char* path) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_get_directory(const char* path, + const char* mask, + struct VFS_DIR_ENTRY** items, + size_t* num_items) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_vfs_free_directory(struct VFS_DIR_ENTRY* items, size_t num_items) + __INTRODUCED_IN_KODI(1); + /*---AUTO_GEN_PARSE---*/ + /*!@}*/ + + /*!@{*/ + ATTR_DLL_EXPORT bool kodi_vfs_file_exists(const char* filename, bool useCache) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_stat_file(const char* filename, struct VFS_STAT_STRUCTURE* buffer) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_delete_file(const char* filename) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_rename_file(const char* filename, const char* newFileName) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_copy_file(const char* filename, const char* dest) + __INTRODUCED_IN_KODI(1); + /*!@}*/ + + /*!@{*/ + ATTR_DLL_EXPORT char* kodi_vfs_get_file_md5(const char* filename) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_vfs_get_cache_thumb_name(const char* filename) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_vfs_make_legal_filename(const char* filename) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_vfs_make_legal_path(const char* path) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_vfs_translate_special_protocol(const char* strSource) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_is_internet_stream(const char* path, bool strictCheck) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_is_on_lan(const char* path) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_is_remote(const char* path) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_is_local(const char* path) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_is_url(const char* path) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_get_mime_type(const char* url, + char** content, + const char* useragent) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_get_content_type(const char* url, + char** content, + const char* useragent) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_get_cookies(const char* url, char** cookies) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_get_disk_space(const char* path, + uint64_t* capacity, + uint64_t* free, + uint64_t* available) __INTRODUCED_IN_KODI(1); + /*!@}*/ + + /*!@{*/ + ATTR_DLL_EXPORT KODI_HTTP_HEADER_HDL kodi_vfs_http_header_open(const char* url) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_vfs_http_header_close(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_value(KODI_HTTP_HEADER_HDL hdl, const char* param) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char** kodi_vfs_http_header_get_values(KODI_HTTP_HEADER_HDL hdl, + const char* param, + size_t* length) __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_header(KODI_HTTP_HEADER_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_mime_type(KODI_HTTP_HEADER_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_charset(KODI_HTTP_HEADER_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_proto_line(KODI_HTTP_HEADER_HDL hdl) + __INTRODUCED_IN_KODI(1); + /*!@}*/ + + /*!@{*/ + ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_open(const char* filename, unsigned int flags) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_open_for_write(const char* filename, bool overwrite) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_curl_create(const char* url) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_file_curl_add_option(KODI_FILE_HDL hdl, + enum CURLOptiontype type, + const char* name, + const char* value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_file_curl_open(KODI_FILE_HDL hdl, unsigned int flags) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_vfs_file_close(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT ssize_t kodi_vfs_file_read(KODI_FILE_HDL hdl, uint8_t* ptr, size_t size) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_file_read_line(KODI_FILE_HDL hdl, char* szLine, size_t lineLength) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT ssize_t kodi_vfs_file_write(KODI_FILE_HDL hdl, const uint8_t* ptr, size_t size) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_vfs_file_flush(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int64_t kodi_vfs_file_seek(KODI_FILE_HDL hdl, int64_t position, int whence) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_vfs_file_truncate(KODI_FILE_HDL hdl, int64_t size) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int64_t kodi_vfs_file_get_position(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int64_t kodi_vfs_file_get_length(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_file_at_end(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT double kodi_vfs_file_get_download_speed(KODI_FILE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_vfs_file_get_chunk_size(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_get_seek_possible(KODI_FILE_HDL hdl) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_get_cache_status(KODI_FILE_HDL hdl, + struct VFS_CACHE_STATUS* status) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_set_cache_rate(KODI_FILE_HDL hdl, uint32_t rate) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_set_retry(KODI_FILE_HDL hdl, bool retry) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_vfs_file_get_property_value(KODI_FILE_HDL hdl, + enum FilePropertyTypes type, + const char* name) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char** kodi_vfs_file_get_property_values(KODI_FILE_HDL hdl, + enum FilePropertyTypes type, + const char* name, + size_t* length) __INTRODUCED_IN_KODI(1); + /*!@}*/ #ifdef __cplusplus -} /* extern "C" */ +} #endif /* __cplusplus */ #endif /* !C_API_FILESYSTEM_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/general.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/general.h index 2188db90bd6aa..f4b9c3b54d997 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/general.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/general.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2018 Team Kodi + * Copyright (C) 2005-2020 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later @@ -9,7 +9,7 @@ #ifndef C_API_GENERAL_H #define C_API_GENERAL_H -#include +#include "addon_base.h" #ifdef __cplusplus extern "C" @@ -69,56 +69,53 @@ extern "C" } LangFormats; //---------------------------------------------------------------------------- - /* - * For interface between add-on and kodi. - * - * This structure defines the addresses of functions stored inside Kodi which - * are then available for the add-on to call - * - * All function pointers there are used by the C++ interface functions below. - * You find the set of them on xbmc/addons/interfaces/General.cpp - * - * Note: For add-on development itself this is not needed - */ + typedef enum DigestType + { + DIGEST_MD5, + DIGEST_SHA1, + DIGEST_SHA256, + DIGEST_SHA512 + } DigestType; + typedef struct AddonKeyboardKeyTable { char* keys[STD_KB_BUTTONS_MAX_ROWS][STD_KB_BUTTONS_PER_ROW]; } AddonKeyboardKeyTable; - typedef struct AddonToKodiFuncTable_kodi - { - char* (*unknown_to_utf8)(void* kodiBase, const char* source, bool* ret, bool failOnBadChar); - char* (*get_language)(void* kodiBase, int format, bool region); - bool (*queue_notification)(void* kodiBase, - int type, - const char* header, - const char* message, - const char* imageFile, - unsigned int displayTime, - bool withSound, - unsigned int messageTime); - void (*get_md5)(void* kodiBase, const char* text, char* md5); - char* (*get_region)(void* kodiBase, const char* id); - void (*get_free_mem)(void* kodiBase, long* free, long* total, bool as_bytes); - int (*get_global_idle_time)(void* kodiBase); - bool (*is_addon_avilable)(void* kodiBase, const char* id, char** version, bool* enabled); - void (*kodi_version)(void* kodiBase, - char** compile_name, - int* major, - int* minor, - char** revision, - char** tag, - char** tagversion); - char* (*get_current_skin_id)(void* kodiBase); - bool (*get_keyboard_layout)(void* kodiBase, - char** layout_name, - int modifier_key, - struct AddonKeyboardKeyTable* layout); - bool (*change_keyboard_layout)(void* kodiBase, char** layout_name); - } AddonToKodiFuncTable_kodi; + ATTR_DLL_EXPORT char* kodi_get_localized_string(long label_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_get_free_mem(long* free, long* total, bool as_bytes) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_unknown_to_utf8(const char* source, bool* ret, bool failOnBadChar) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_get_language(enum LangFormats format, bool region) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_queue_notification(enum QueueMsg type, + const char* header, + const char* message, + const char* imageFile, + unsigned int displayTime, + bool withSound, + unsigned int messageTime) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_get_digest(enum DigestType type, const char* text) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_get_region(const char* id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_get_global_idle_time() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_is_addon_avilable(const char* id, char** version, bool* enabled) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_version( + char** compile_name, int* major, int* minor, char** revision, char** tag, char** tagversion) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_get_current_skin_id() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_get_keyboard_layout(int modifier_key, + char** layout_name, + struct AddonKeyboardKeyTable* layout) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_change_keyboard_layout(char** layout_name) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_play_sfx(const char* filename, bool use_cached) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_stop_sfx() __INTRODUCED_IN_KODI(1); #ifdef __cplusplus -} /* extern "C" */ +} #endif /* __cplusplus */ #endif /* !C_API_GENERAL_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/button.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/button.h index 46de2629d2ca7..a98a9bd461ae2 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/button.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/button.h @@ -9,22 +9,29 @@ #ifndef C_API_GUI_CONTROLS_BUTTON_H #define C_API_GUI_CONTROLS_BUTTON_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_button - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*set_enabled)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - void (*set_label)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label); - char* (*get_label)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_label2)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label); - char* (*get_label2)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - } AddonToKodiFuncTable_kodi_gui_control_button; + typedef void* KODI_GUI_CONTROL_HANDLE; + + ATTR_DLL_EXPORT void kodi_gui_controls_button_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_button_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_button_set_label(KODI_GUI_CONTROL_HANDLE handle, + const char* label) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_controls_button_get_label(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_button_set_label2(KODI_GUI_CONTROL_HANDLE handle, + const char* label) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_controls_button_get_label2(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/edit.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/edit.h index 571c7ce43cbb3..9f9e63d5dc876 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/edit.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/edit.h @@ -9,13 +9,15 @@ #ifndef C_API_GUI_CONTROLS_EDIT_H #define C_API_GUI_CONTROLS_EDIT_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ + typedef void* KODI_GUI_CONTROL_HANDLE; + //============================================================================ /// @ingroup cpp_kodi_gui_windows_controls_CEdit_Defs /// @{ @@ -52,23 +54,28 @@ extern "C" /// @} //---------------------------------------------------------------------------- - typedef struct AddonToKodiFuncTable_kodi_gui_control_edit - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*set_enabled)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - void (*set_label)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label); - char* (*get_label)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_text)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text); - char* (*get_text)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_cursor_position)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - unsigned int position); - unsigned int (*get_cursor_position)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_input_type)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - int type, - const char* heading); - } AddonToKodiFuncTable_kodi_gui_control_edit; + ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_label(KODI_GUI_CONTROL_HANDLE handle, + const char* label) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_controls_edit_get_label(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_text(KODI_GUI_CONTROL_HANDLE handle, + const char* text) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_controls_edit_get_text(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_cursor_position(KODI_GUI_CONTROL_HANDLE handle, + unsigned int position) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT unsigned int kodi_gui_controls_edit_get_cursor_position( + KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_input_type(KODI_GUI_CONTROL_HANDLE handle, + int type, + const char* heading) + __INTRODUCED_IN_KODI(1); + #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/fade_label.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/fade_label.h index dab45747121c4..282ccf87d5011 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/fade_label.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/fade_label.h @@ -9,21 +9,28 @@ #ifndef C_API_GUI_CONTROLS_FADE_LABEL_H #define C_API_GUI_CONTROLS_FADE_LABEL_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_fade_label - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*add_label)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text); - char* (*get_label)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_scrolling)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool scroll); - void (*reset)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - } AddonToKodiFuncTable_kodi_gui_control_fade_label; + typedef void* KODI_GUI_CONTROL_HANDLE; + + ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_add_label(KODI_GUI_CONTROL_HANDLE handle, + const char* text) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_controls_fade_label_get_label(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_set_scrolling(KODI_GUI_CONTROL_HANDLE handle, + bool scroll) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_reset(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/image.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/image.h index 257dd678fd522..a6d2febe85b7c 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/image.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/image.h @@ -9,24 +9,23 @@ #ifndef C_API_GUI_CONTROLS_IMAGE_H #define C_API_GUI_CONTROLS_IMAGE_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_image - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*set_filename)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* filename, - bool use_cache); - void (*set_color_diffuse)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - uint32_t color_diffuse); - } AddonToKodiFuncTable_kodi_gui_control_image; + typedef void* KODI_GUI_CONTROL_HANDLE; + + ATTR_DLL_EXPORT void kodi_gui_controls_image_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_image_set_filename(KODI_GUI_CONTROL_HANDLE handle, + const char* filename, + bool use_cache) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_image_set_color_diffuse(KODI_GUI_CONTROL_HANDLE handle, + uint32_t color_diffuse) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/label.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/label.h index 92af25ca8d4b7..5b9b87284f95b 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/label.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/label.h @@ -9,19 +9,21 @@ #ifndef C_API_GUI_CONTROLS_LABEL_H #define C_API_GUI_CONTROLS_LABEL_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_label - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*set_label)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text); - char* (*get_label)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - } AddonToKodiFuncTable_kodi_gui_control_label; + typedef void* KODI_GUI_CONTROL_HANDLE; + + ATTR_DLL_EXPORT void kodi_gui_controls_label_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_label_set_label(KODI_GUI_CONTROL_HANDLE handle, + const char* text) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_controls_label_get_label(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/progress.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/progress.h index 4f211fdf62765..4b411901d1781 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/progress.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/progress.h @@ -9,19 +9,22 @@ #ifndef C_API_GUI_CONTROLS_PROGRESS_H #define C_API_GUI_CONTROLS_PROGRESS_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_progress - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*set_percentage)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float percent); - float (*get_percentage)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - } AddonToKodiFuncTable_kodi_gui_control_progress; + typedef void* KODI_GUI_CONTROL_HANDLE; + + ATTR_DLL_EXPORT void kodi_gui_controls_progress_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_progress_set_percentage(KODI_GUI_CONTROL_HANDLE handle, + float percent) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT float kodi_gui_controls_progress_get_percentage(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/radio_button.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/radio_button.h index d652e6727f4c8..da5ad3daae7b3 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/radio_button.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/radio_button.h @@ -9,22 +9,31 @@ #ifndef C_API_GUI_CONTROLS_RADIO_BUTTON_H #define C_API_GUI_CONTROLS_RADIO_BUTTON_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_radio_button - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*set_enabled)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - void (*set_label)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text); - char* (*get_label)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_selected)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool selected); - bool (*is_selected)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - } AddonToKodiFuncTable_kodi_gui_control_radio_button; + typedef void* KODI_GUI_CONTROL_HANDLE; + + ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_label(KODI_GUI_CONTROL_HANDLE handle, + const char* text) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_controls_radio_button_get_label(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_selected(KODI_GUI_CONTROL_HANDLE handle, + bool selected) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_controls_radio_button_is_selected(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/rendering.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/rendering.h index 792a8d6df506b..10091145f8a9f 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/rendering.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/rendering.h @@ -9,25 +9,25 @@ #ifndef C_API_GUI_CONTROLS_RENDERING_H #define C_API_GUI_CONTROLS_RENDERING_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_rendering - { - void (*set_callbacks)( - KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - KODI_GUI_CLIENT_HANDLE clienthandle, - bool (*createCB)(KODI_GUI_CLIENT_HANDLE, int, int, int, int, ADDON_HARDWARE_CONTEXT), - void (*renderCB)(KODI_GUI_CLIENT_HANDLE), - void (*stopCB)(KODI_GUI_CLIENT_HANDLE), - bool (*dirtyCB)(KODI_GUI_CLIENT_HANDLE)); - void (*destroy)(void* kodiBase, KODI_GUI_CONTROL_HANDLE handle); - } AddonToKodiFuncTable_kodi_gui_control_rendering; + typedef void* KODI_GUI_CONTROL_HANDLE; + + // // ATTR_DLL_EXPORT void kodi_gui_controls_radio_rendering_set_callbacks( + // // KODI_GUI_CONTROL_HANDLE handle, + // // KODI_GUI_CLIENT_HANDLE clienthandle, + // // bool (*createCB)(KODI_GUI_CLIENT_HANDLE, int, int, int, int, ADDON_HARDWARE_CONTEXT), + // // void (*renderCB)(KODI_GUI_CLIENT_HANDLE), + // // void (*stopCB)(KODI_GUI_CLIENT_HANDLE), + // // bool (*dirtyCB)(KODI_GUI_CLIENT_HANDLE)) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_radio_rendering_destroy(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/settings_slider.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/settings_slider.h index 42992527cd7ef..9a13b836d397f 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/settings_slider.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/settings_slider.h @@ -9,35 +9,46 @@ #ifndef C_API_GUI_CONTROLS_SETTINGS_SLIDER_H #define C_API_GUI_CONTROLS_SETTINGS_SLIDER_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_settings_slider - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*set_enabled)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - void (*set_text)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* label); - void (*reset)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_int_range)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int start, int end); - void (*set_int_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int value); - int (*get_int_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_int_interval)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int interval); - void (*set_percentage)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float percent); - float (*get_percentage)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_float_range)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float start, - float end); - void (*set_float_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float value); - float (*get_float_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_float_interval)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float interval); - } AddonToKodiFuncTable_kodi_gui_control_settings_slider; + typedef void* KODI_GUI_CONTROL_HANDLE; + + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_text(KODI_GUI_CONTROL_HANDLE handle, + const char* label) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_reset(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_range( + KODI_GUI_CONTROL_HANDLE handle, int start, int end) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_value( + KODI_GUI_CONTROL_HANDLE handle, int value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_controls_settings_slider_get_int_value( + KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_interval( + KODI_GUI_CONTROL_HANDLE handle, int interval) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_percentage( + KODI_GUI_CONTROL_HANDLE handle, float percent) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT float kodi_gui_controls_settings_slider_get_percentage( + KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_range( + KODI_GUI_CONTROL_HANDLE handle, float start, float end) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_value( + KODI_GUI_CONTROL_HANDLE handle, float value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT float kodi_gui_controls_settings_slider_get_float_value( + KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_interval( + KODI_GUI_CONTROL_HANDLE handle, float interval) __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/slider.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/slider.h index 67c6c2fc33e95..621d63f57eb94 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/slider.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/slider.h @@ -9,35 +9,49 @@ #ifndef C_API_GUI_CONTROLS_SLIDER_H #define C_API_GUI_CONTROLS_SLIDER_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_slider - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*set_enabled)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - void (*reset)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - char* (*get_description)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_int_range)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int start, int end); - void (*set_int_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int value); - int (*get_int_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_int_interval)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int interval); - void (*set_percentage)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float percent); - float (*get_percentage)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_float_range)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float start, - float end); - void (*set_float_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float value); - float (*get_float_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_float_interval)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float interval); - } AddonToKodiFuncTable_kodi_gui_control_slider; + typedef void* KODI_GUI_CONTROL_HANDLE; + + ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_slider_reset(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_controls_slider_get_description(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_range(KODI_GUI_CONTROL_HANDLE handle, + int start, + int end) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_value(KODI_GUI_CONTROL_HANDLE handle, + int value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_controls_slider_get_int_value(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_interval(KODI_GUI_CONTROL_HANDLE handle, + int interval) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_percentage(KODI_GUI_CONTROL_HANDLE handle, + float percent) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT float kodi_gui_controls_slider_get_percentage(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_range(KODI_GUI_CONTROL_HANDLE handle, + float start, + float end) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_value(KODI_GUI_CONTROL_HANDLE handle, + float value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT float kodi_gui_controls_slider_get_float_value(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_interval(KODI_GUI_CONTROL_HANDLE handle, + float interval) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/spin.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/spin.h index 0373636afa965..db1b1116046e3 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/spin.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/spin.h @@ -9,45 +9,54 @@ #ifndef C_API_GUI_CONTROLS_SPIN_H #define C_API_GUI_CONTROLS_SPIN_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_spin - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*set_enabled)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool enabled); - void (*set_text)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text); - void (*reset)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_type)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int type); - void (*add_string_label)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label, - const char* value); - void (*set_string_value)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* value); - char* (*get_string_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*add_int_label)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - const char* label, - int value); - void (*set_int_range)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int start, int end); - void (*set_int_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int value); - int (*get_int_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_float_range)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float start, - float end); - void (*set_float_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, float value); - float (*get_float_value)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_float_interval)(KODI_HANDLE kodiBase, - KODI_GUI_CONTROL_HANDLE handle, - float interval); - } AddonToKodiFuncTable_kodi_gui_control_spin; + typedef void* KODI_GUI_CONTROL_HANDLE; + + ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_text(KODI_GUI_CONTROL_HANDLE handle, + const char* text) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_reset(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_type(KODI_GUI_CONTROL_HANDLE handle, int type) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_add_string_label(KODI_GUI_CONTROL_HANDLE handle, + const char* label, + const char* value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_string_value(KODI_GUI_CONTROL_HANDLE handle, + const char* value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_controls_spin_get_string_value(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_add_int_label(KODI_GUI_CONTROL_HANDLE handle, + const char* label, + int value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_int_range(KODI_GUI_CONTROL_HANDLE handle, + int start, + int end) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_int_value(KODI_GUI_CONTROL_HANDLE handle, + int value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_controls_spin_get_int_value(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_range(KODI_GUI_CONTROL_HANDLE handle, + float start, + float end) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_value(KODI_GUI_CONTROL_HANDLE handle, + float value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT float kodi_gui_controls_spin_get_float_value(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_interval(KODI_GUI_CONTROL_HANDLE handle, + float interval) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/text_box.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/text_box.h index 333689e0b2547..6267e06286be7 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/text_box.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/controls/text_box.h @@ -9,23 +9,29 @@ #ifndef C_API_GUI_CONTROLS_TEXT_BOX_H #define C_API_GUI_CONTROLS_TEXT_BOX_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_control_text_box - { - void (*set_visible)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, bool visible); - void (*reset)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*set_text)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, const char* text); - char* (*get_text)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle); - void (*scroll)(KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, unsigned int scroll); - void (*set_auto_scrolling)( - KODI_HANDLE kodiBase, KODI_GUI_CONTROL_HANDLE handle, int delay, int time, int repeat); - } AddonToKodiFuncTable_kodi_gui_control_text_box; + typedef void* KODI_GUI_CONTROL_HANDLE; + + ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_text_box_reset(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_text(KODI_GUI_CONTROL_HANDLE handle, + const char* text) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_controls_text_box_get_text(KODI_GUI_CONTROL_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_text_box_scroll(KODI_GUI_CONTROL_HANDLE handle, + unsigned int position) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_auto_scrolling( + KODI_GUI_CONTROL_HANDLE handle, int delay, int time, int repeat) __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/context_menu.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/context_menu.h index 130d831e5bb3b..c4c8cd41b333e 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/context_menu.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/context_menu.h @@ -9,20 +9,16 @@ #ifndef C_API_GUI_DIALOGS_CONTEXT_MENU_H #define C_API_GUI_DIALOGS_CONTEXT_MENU_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_dialogContextMenu - { - int (*open)(KODI_HANDLE kodiBase, - const char* heading, - const char* entries[], - unsigned int size); - } AddonToKodiFuncTable_kodi_gui_dialogContextMenu; + ATTR_DLL_EXPORT int kodi_gui_dialogs_context_menu_open(const char* heading, + const char* entries[], + size_t size) __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/extended_progress.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/extended_progress.h index 0992d5c2288b0..d4132b4cacc5e 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/extended_progress.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/extended_progress.h @@ -9,30 +9,43 @@ #ifndef C_API_GUI_DIALOGS_EXTENDED_PROGRESS_H #define C_API_GUI_DIALOGS_EXTENDED_PROGRESS_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_dialogExtendedProgress - { - KODI_GUI_HANDLE (*new_dialog)(KODI_HANDLE kodiBase, const char* title); - void (*delete_dialog)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - char* (*get_title)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - void (*set_title)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, const char* title); - char* (*get_text)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - void (*set_text)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, const char* text); - bool (*is_finished)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - void (*mark_finished)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - float (*get_percentage)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - void (*set_percentage)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, float percentage); - void (*set_progress)(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - int currentItem, - int itemCount); - } AddonToKodiFuncTable_kodi_gui_dialogExtendedProgress; + typedef void* KODI_GUI_HANDLE; + + ATTR_DLL_EXPORT KODI_GUI_HANDLE kodi_gui_dialogs_extended_progress_new_dialog(const char* title) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_delete_dialog(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_dialogs_extended_progress_get_title(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_title(KODI_GUI_HANDLE handle, + const char* title) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_dialogs_extended_progress_get_text(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_text(KODI_GUI_HANDLE handle, + const char* text) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_extended_progress_is_finished(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_mark_finished(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT float kodi_gui_dialogs_extended_progress_get_percentage(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_percentage(KODI_GUI_HANDLE handle, + float percentage) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_progress(KODI_GUI_HANDLE handle, + int currentItem, + int itemCount) + __INTRODUCED_IN_KODI(1); + #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/filebrowser.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/filebrowser.h index ef3945b27468b..97fbbc0dad865 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/filebrowser.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/filebrowser.h @@ -9,64 +9,64 @@ #ifndef C_API_GUI_DIALOGS_FILEBROWSER_H #define C_API_GUI_DIALOGS_FILEBROWSER_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_dialogFileBrowser - { - bool (*show_and_get_directory)(KODI_HANDLE kodiBase, - const char* shares, - const char* heading, - const char* path_in, - char** path_out, - bool writeOnly); - bool (*show_and_get_file)(KODI_HANDLE kodiBase, - const char* shares, - const char* mask, - const char* heading, - const char* path_in, - char** path_out, - bool use_thumbs, - bool use_file_directories); - bool (*show_and_get_file_from_dir)(KODI_HANDLE kodiBase, - const char* directory, - const char* mask, - const char* heading, - const char* path_in, - char** path_out, - bool use_thumbs, - bool use_file_directories, - bool singleList); - bool (*show_and_get_file_list)(KODI_HANDLE kodiBase, - const char* shares, - const char* mask, - const char* heading, - char*** file_list, - unsigned int* entries, - bool use_thumbs, - bool use_file_directories); - bool (*show_and_get_source)(KODI_HANDLE kodiBase, - const char* path_in, - char** path_out, - bool allow_network_shares, - const char* additional_share, - const char* type); - bool (*show_and_get_image)(KODI_HANDLE kodiBase, - const char* shares, - const char* heading, - const char* path_in, - char** path_out); - bool (*show_and_get_image_list)(KODI_HANDLE kodiBase, - const char* shares, - const char* heading, - char*** file_list, - unsigned int* entries); - void (*clear_file_list)(KODI_HANDLE kodiBase, char*** file_list, unsigned int entries); - } AddonToKodiFuncTable_kodi_gui_dialogFileBrowser; + ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_directory(const char* shares, + const char* heading, + const char* path_in, + char** path_out, + bool write_only) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file(const char* shares, + const char* mask, + const char* heading, + const char* path_in, + char** path_out, + bool use_thumbs, + bool use_file_directories) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file_from_dir( + const char* directory, + const char* mask, + const char* heading, + const char* path_in, + char** path_out, + bool use_thumbs, + bool use_file_directories, + bool single_list) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file_list( + const char* shares, + const char* mask, + const char* heading, + char*** file_list, + size_t* entries, + bool use_thumbs, + bool use_file_directories) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_source( + const char* path_in, + char** path_out, + bool allow_network_shares, + const char* additional_share, + const char* type) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_image(const char* shares, + const char* heading, + const char* path_in, + char** path_out) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_image_list(const char* shares, + const char* heading, + char*** file_list, + size_t* entries) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_file_browser_clear_file_list(char*** file_list, + size_t entries) + __INTRODUCED_IN_KODI(1); + /*---AUTO_GEN_PARSE---*/ #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/keyboard.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/keyboard.h index f84dc204fefeb..eb8469e35e969 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/keyboard.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/keyboard.h @@ -9,61 +9,54 @@ #ifndef C_API_GUI_DIALOGS_KEYBOARD_H #define C_API_GUI_DIALOGS_KEYBOARD_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_dialogKeyboard - { - bool (*show_and_get_input_with_head)(KODI_HANDLE kodiBase, - const char* text_in, - char** text_out, - const char* heading, - bool allow_empty_result, - bool hiddenInput, - unsigned int auto_close_ms); - bool (*show_and_get_input)(KODI_HANDLE kodiBase, - const char* text_in, - char** text_out, - bool allow_empty_result, - unsigned int auto_close_ms); - bool (*show_and_get_new_password_with_head)(KODI_HANDLE kodiBase, - const char* password_in, - char** password_out, - const char* heading, - bool allow_empty_result, - unsigned int auto_close_ms); - bool (*show_and_get_new_password)(KODI_HANDLE kodiBase, - const char* password_in, - char** password_out, - unsigned int auto_close_ms); - bool (*show_and_verify_new_password_with_head)(KODI_HANDLE kodiBase, - char** password_out, - const char* heading, - bool allow_empty_result, - unsigned int auto_close_ms); - bool (*show_and_verify_new_password)(KODI_HANDLE kodiBase, - char** password_out, - unsigned int auto_close_ms); - int (*show_and_verify_password)(KODI_HANDLE kodiBase, - const char* password_in, - char** password_out, - const char* heading, - int retries, - unsigned int auto_close_ms); - bool (*show_and_get_filter)(KODI_HANDLE kodiBase, - const char* text_in, - char** text_out, - bool searching, - unsigned int auto_close_ms); - bool (*send_text_to_active_keyboard)(KODI_HANDLE kodiBase, - const char* text, - bool close_keyboard); - bool (*is_keyboard_activated)(KODI_HANDLE kodiBase); - } AddonToKodiFuncTable_kodi_gui_dialogKeyboard; + ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_input_with_head( + const char* text_in, + char** text_out, + const char* heading, + bool allow_empty_result, + bool hidden_input, + unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_input(const char* text_in, + char** text_out, + bool allow_empty_result, + unsigned int auto_close_ms) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head( + const char* password_in, + char** password_out, + const char* heading, + bool allow_empty_result, + unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_new_password( + const char* password_in, char** password_out, unsigned int auto_close_ms) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head( + char** password_out, const char* heading, bool allow_empty_result, unsigned int auto_close_ms) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_verify_new_password( + char** password_out, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_dialogs_keyboard_show_and_verify_password(const char* password_in, + char** password_out, + const char* heading, + int retries, + unsigned int auto_close_ms) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_filter(const char* text_in, + char** text_out, + bool searching, + unsigned int auto_close_ms) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_send_text_to_active_keyboard(const char* text, + bool close_keyboard) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_is_keyboard_activated() __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/numeric.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/numeric.h index 08aaf25d86bc8..d1f64b6bd52be 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/numeric.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/numeric.h @@ -9,41 +9,43 @@ #ifndef C_API_GUI_DIALOGS_NUMERIC_H #define C_API_GUI_DIALOGS_NUMERIC_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_dialogNumeric - { - bool (*show_and_verify_new_password)(KODI_HANDLE kodiBase, char** password); - int (*show_and_verify_password)(KODI_HANDLE kodiBase, - const char* password, - const char* heading, - int retries); - bool (*show_and_verify_input)(KODI_HANDLE kodiBase, - const char* verify_in, - char** verify_out, - const char* heading, - bool verify_input); - bool (*show_and_get_time)(KODI_HANDLE kodiBase, struct tm* time, const char* heading); - bool (*show_and_get_date)(KODI_HANDLE kodiBase, struct tm* date, const char* heading); - bool (*show_and_get_ip_address)(KODI_HANDLE kodiBase, - const char* ip_address_in, - char** ip_address_out, - const char* heading); - bool (*show_and_get_number)(KODI_HANDLE kodiBase, - const char* input_in, - char** input_out, - const char* heading, - unsigned int auto_close_ms); - bool (*show_and_get_seconds)(KODI_HANDLE kodiBase, - const char* time_in, - char** time_out, - const char* heading); - } AddonToKodiFuncTable_kodi_gui_dialogNumeric; + ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_verify_new_password(char** password) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_dialogs_numeric_show_and_verify_password(const char* password, + const char* heading, + int retries) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_verify_input(const char* verify_in, + char** verify_out, + const char* heading, + bool verify_input) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_time(struct tm* time, + const char* heading) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_date(struct tm* date, + const char* heading) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_ip_address(const char* ip_address_in, + char** ip_address_out, + const char* heading) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_number(const char* number_in, + char** number_out, + const char* heading, + unsigned int auto_close_ms) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_seconds(const char* time_in, + char** time_out, + const char* heading) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/ok.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/ok.h index 45fe0fc458fcf..a52c20910826e 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/ok.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/ok.h @@ -9,24 +9,21 @@ #ifndef C_API_GUI_DIALOGS_OK_H #define C_API_GUI_DIALOGS_OK_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_dialogOK - { - void (*show_and_get_input_single_text)(KODI_HANDLE kodiBase, - const char* heading, - const char* text); - void (*show_and_get_input_line_text)(KODI_HANDLE kodiBase, - const char* heading, - const char* line0, - const char* line1, - const char* line2); - } AddonToKodiFuncTable_kodi_gui_dialogOK; + ATTR_DLL_EXPORT void kodi_gui_dialogs_ok_show_and_get_input_single_text(const char* heading, + const char* text) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_ok_show_and_get_input_line_text(const char* heading, + const char* line0, + const char* line1, + const char* line2) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/progress.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/progress.h index 60a003ab7b104..5413812d130a6 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/progress.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/progress.h @@ -9,32 +9,46 @@ #ifndef C_API_GUI_DIALOGS_PROGRESS_H #define C_API_GUI_DIALOGS_PROGRESS_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_dialogProgress - { - KODI_GUI_HANDLE (*new_dialog)(KODI_HANDLE kodiBase); - void (*delete_dialog)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - void (*open)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - void (*set_heading)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, const char* heading); - void (*set_line)(KODI_HANDLE kodiBase, - KODI_GUI_HANDLE handle, - unsigned int lineNo, - const char* line); - void (*set_can_cancel)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, bool canCancel); - bool (*is_canceled)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - void (*set_percentage)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, int percentage); - int (*get_percentage)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - void (*show_progress_bar)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, bool pnOff); - void (*set_progress_max)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, int max); - void (*set_progress_advance)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle, int nSteps); - bool (*abort)(KODI_HANDLE kodiBase, KODI_GUI_HANDLE handle); - } AddonToKodiFuncTable_kodi_gui_dialogProgress; + typedef void* KODI_GUI_HANDLE; + + ATTR_DLL_EXPORT KODI_GUI_HANDLE kodi_gui_dialogs_progress_new_dialog() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_delete_dialog(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_open(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_heading(KODI_GUI_HANDLE handle, + const char* heading) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_line(KODI_GUI_HANDLE handle, + unsigned int line_no, + const char* line) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_can_cancel(KODI_GUI_HANDLE handle, + bool can_cancel) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_progress_is_canceled(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_percentage(KODI_GUI_HANDLE handle, + int percentage) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_dialogs_progress_get_percentage(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_show_progress_bar(KODI_GUI_HANDLE handle, + bool on_off) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_progress_max(KODI_GUI_HANDLE handle, int max) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_progress_advance(KODI_GUI_HANDLE handle, + int n_steps) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_progress_abort(KODI_GUI_HANDLE handle) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/select.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/select.h index 79635d775e008..a04a0d1cebc44 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/select.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/select.h @@ -9,29 +9,25 @@ #ifndef C_API_GUI_DIALOGS_SELECT_H #define C_API_GUI_DIALOGS_SELECT_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_dialogSelect - { - int (*open)(KODI_HANDLE kodiBase, - const char* heading, - const char* entries[], - unsigned int size, - int selected, - unsigned int autoclose); - bool (*open_multi_select)(KODI_HANDLE kodiBase, - const char* heading, - const char* entryIDs[], - const char* entryNames[], - bool entriesSelected[], - unsigned int size, - unsigned int autoclose); - } AddonToKodiFuncTable_kodi_gui_dialogSelect; + ATTR_DLL_EXPORT int kodi_gui_dialogs_select_open(const char* heading, + const char* entries[], + size_t size, + int selected, + unsigned int autoclose) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_select_open_multi_select(const char* heading, + const char* entryIDs[], + const char* entryNames[], + uint8_t entriesSelected[], + size_t size, + unsigned int autoclose) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/text_viewer.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/text_viewer.h index 4a1cfe687c7a6..3e6eb112b9afb 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/text_viewer.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/text_viewer.h @@ -9,17 +9,15 @@ #ifndef C_API_GUI_DIALOGS_TEXT_VIEWER_H #define C_API_GUI_DIALOGS_TEXT_VIEWER_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_dialogTextViewer - { - void (*open)(KODI_HANDLE kodiBase, const char* heading, const char* text); - } AddonToKodiFuncTable_kodi_gui_dialogTextViewer; + ATTR_DLL_EXPORT void kodi_gui_dialogs_text_viewer_show(const char* heading, const char* text) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/yes_no.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/yes_no.h index 8558acbc465b1..711966414cd82 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/yes_no.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/dialogs/yes_no.h @@ -9,37 +9,34 @@ #ifndef C_API_GUI_DIALOGS_YES_NO_H #define C_API_GUI_DIALOGS_YES_NO_H -#include "../definitions.h" +#include "../../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_dialogYesNo - { - bool (*show_and_get_input_single_text)(KODI_HANDLE kodiBase, - const char* heading, - const char* text, - bool* canceled, - const char* noLabel, - const char* yesLabel); - bool (*show_and_get_input_line_text)(KODI_HANDLE kodiBase, - const char* heading, - const char* line0, - const char* line1, - const char* line2, - const char* noLabel, - const char* yesLabel); - bool (*show_and_get_input_line_button_text)(KODI_HANDLE kodiBase, - const char* heading, - const char* line0, - const char* line1, - const char* line2, - bool* canceled, - const char* noLabel, - const char* yesLabel); - } AddonToKodiFuncTable_kodi_gui_dialogYesNo; + ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_single_text(const char* heading, + const char* text, + bool* canceled, + const char* noLabel, + const char* yesLabel) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_line_text(const char* heading, + const char* line0, + const char* line1, + const char* line2, + const char* noLabel, + const char* yesLabel) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_line_button_text( + const char* heading, + const char* line0, + const char* line1, + const char* line2, + bool* canceled, + const char* noLabel, + const char* yesLabel) __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/general.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/general.h index 676986725f401..f041111077ad2 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/general.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/general.h @@ -9,24 +9,21 @@ #ifndef C_API_GUI_GENERAL_H #define C_API_GUI_GENERAL_H -#include "definitions.h" +#include "../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_general - { - void (*lock)(); - void (*unlock)(); - int (*get_screen_height)(KODI_HANDLE kodiBase); - int (*get_screen_width)(KODI_HANDLE kodiBase); - int (*get_video_resolution)(KODI_HANDLE kodiBase); - int (*get_current_window_dialog_id)(KODI_HANDLE kodiBase); - int (*get_current_window_id)(KODI_HANDLE kodiBase); - ADDON_HARDWARE_CONTEXT (*get_hw_context)(KODI_HANDLE kodiBase); - } AddonToKodiFuncTable_kodi_gui_general; + ATTR_DLL_EXPORT void kodi_gui_lock() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_unlock() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_get_screen_height() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_get_screen_width() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT float kodi_gui_get_video_resolution() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_get_current_window_dialog_id() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_get_current_window_id() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT ADDON_HARDWARE_CONTEXT kodi_gui_get_hw_context() __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/input/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/input/CMakeLists.txt index eb7dde09c9fab..70788a3c9b035 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/input/CMakeLists.txt +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/input/CMakeLists.txt @@ -2,6 +2,7 @@ # See xbmc/addons/kodi-dev-kit/tools/code-generator.py. set(HEADERS + action.h action_ids.h ) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/input/action.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/input/action.h new file mode 100644 index 0000000000000..7749ba7374ce6 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/input/action.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#ifndef C_API_GUI_ACTION_H +#define C_API_GUI_ACTION_H + +#include "action_ids.h" + +#include + +#define ADDON_ACTION_AMOUNT_MAX 6 // Must be at least 6 + +struct KODI_ADDON_ACTION_DATA +{ + enum ADDON_ACTION id; + const char* name; + float amount[ADDON_ACTION_AMOUNT_MAX]; + float repeat; + unsigned int hold_time; + unsigned int button_code; + wchar_t unicode; + const char* text; +}; + +#endif /* !C_API_GUI_ACTION_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/list_item.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/list_item.h index d2120ac355ada..c4f24c1b0c6ef 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/list_item.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/list_item.h @@ -9,41 +9,48 @@ #ifndef C_API_GUI_LIST_ITEM_H #define C_API_GUI_LIST_ITEM_H -#include "definitions.h" +#include "../addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - typedef struct AddonToKodiFuncTable_kodi_gui_listItem - { - KODI_GUI_LISTITEM_HANDLE(*create) - (KODI_HANDLE kodiBase, - const char* label, - const char* label2, - const char* path); - void (*destroy)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle); - - char* (*get_label)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle); - void (*set_label)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* label); - char* (*get_label2)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle); - void (*set_label2)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* label); - char* (*get_art)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* type); - void (*set_art)(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* type, - const char* image); - char* (*get_path)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle); - void (*set_path)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* path); - char* (*get_property)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, const char* key); - void (*set_property)(KODI_HANDLE kodiBase, - KODI_GUI_LISTITEM_HANDLE handle, - const char* key, - const char* value); - void (*select)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle, bool select); - bool (*is_selected)(KODI_HANDLE kodiBase, KODI_GUI_LISTITEM_HANDLE handle); - } AddonToKodiFuncTable_kodi_gui_listItem; + typedef void* KODI_GUI_LISTITEM_HANDLE; + + ATTR_DLL_EXPORT KODI_GUI_LISTITEM_HANDLE kodi_gui_listitem_create(const char* label, + const char* label2, + const char* path) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_listitem_destroy(KODI_GUI_LISTITEM_HANDLE handle) + __INTRODUCED_IN_KODI(1); + + ATTR_DLL_EXPORT char* kodi_gui_listitem_get_label(KODI_GUI_LISTITEM_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_listitem_set_label(KODI_GUI_LISTITEM_HANDLE handle, + const char* label) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_listitem_get_label2(KODI_GUI_LISTITEM_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_listitem_set_label2(KODI_GUI_LISTITEM_HANDLE handle, + const char* label) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_listitem_get_art(KODI_GUI_LISTITEM_HANDLE handle, const char* type) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_listitem_set_art(KODI_GUI_LISTITEM_HANDLE handle, + const char* type, + const char* image) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_listitem_get_path(KODI_GUI_LISTITEM_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_listitem_set_path(KODI_GUI_LISTITEM_HANDLE handle, const char* path) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_listitem_get_property(KODI_GUI_LISTITEM_HANDLE handle, + const char* key) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_listitem_set_property(KODI_GUI_LISTITEM_HANDLE handle, + const char* key, + const char* value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_listitem_select(KODI_GUI_LISTITEM_HANDLE handle, bool select) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_listitem_is_selected(KODI_GUI_LISTITEM_HANDLE handle) + __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/window.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/window.h index d7181c0538bb9..43ca955d009ca 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/window.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/gui/window.h @@ -9,8 +9,10 @@ #ifndef C_API_GUI_WINDOW_H #define C_API_GUI_WINDOW_H -#include "definitions.h" +#include "../addon_base.h" +#include "input/action.h" #include "input/action_ids.h" +#include "list_item.h" #include @@ -22,157 +24,157 @@ extern "C" { #endif /* __cplusplus */ + typedef void* KODI_GUI_WINDOW_HANDLE; + typedef void* KODI_GUI_CLIENT_HANDLE; + typedef void* KODI_GUI_CONTROL_HANDLE; + typedef struct gui_context_menu_pair { unsigned int id; char name[ADDON_MAX_CONTEXT_ENTRY_NAME_LENGTH]; } gui_context_menu_pair; - typedef struct AddonToKodiFuncTable_kodi_gui_window - { - /* Window creation functions */ - KODI_GUI_WINDOW_HANDLE(*create) - (KODI_HANDLE kodiBase, - const char* xml_filename, - const char* default_skin, - bool as_dialog, - bool is_media); - void (*destroy)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - - void (*set_callbacks)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - KODI_GUI_CLIENT_HANDLE clienthandle, - bool (*CBInit)(KODI_GUI_CLIENT_HANDLE), - bool (*CBFocus)(KODI_GUI_CLIENT_HANDLE, int), - bool (*CBClick)(KODI_GUI_CLIENT_HANDLE, int), - bool (*CBOnAction)(KODI_GUI_CLIENT_HANDLE, enum ADDON_ACTION), - void (*CBGetContextButtons)( - KODI_GUI_CLIENT_HANDLE, int, gui_context_menu_pair*, unsigned int*), - bool (*CBOnContextButton)(KODI_GUI_CLIENT_HANDLE, int, unsigned int)); - bool (*show)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - bool (*close)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - bool (*do_modal)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - - /* Window control functions */ - bool (*set_focus_id)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - int (*get_focus_id)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - void (*set_control_label)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - const char* label); - void (*set_control_visible)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - bool visible); - void (*set_control_selected)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int control_id, - bool selected); - - /* Window property functions */ - void (*set_property)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - const char* value); - void (*set_property_int)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - int value); - void (*set_property_bool)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - bool value); - void (*set_property_double)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - double value); - char* (*get_property)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, const char* key); - int (*get_property_int)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, const char* key); - bool (*get_property_bool)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, const char* key); - double (*get_property_double)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key); - void (*clear_properties)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - void (*clear_property)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, const char* key); - - /* List item functions */ - void (*clear_item_list)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - void (*add_list_item)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - KODI_GUI_LISTITEM_HANDLE item, - int list_position); - void (*remove_list_item_from_position)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int list_position); - void (*remove_list_item)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - KODI_GUI_LISTITEM_HANDLE item); - KODI_GUI_LISTITEM_HANDLE(*get_list_item) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int list_position); - void (*set_current_list_position)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - int list_position); - int (*get_current_list_position)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - int (*get_list_size)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - void (*set_container_property)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* key, - const char* value); - void (*set_container_content)(KODI_HANDLE kodiBase, - KODI_GUI_WINDOW_HANDLE handle, - const char* value); - int (*get_current_container_id)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - - /* Various functions */ - void (*mark_dirty_region)(KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle); - - /* GUI control access functions */ - KODI_GUI_CONTROL_HANDLE(*get_control_button) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_edit) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_fade_label) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_image) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_label) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_progress) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_radio_button) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_render_addon) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_settings_slider) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_slider) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_spin) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_text_box) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_dummy1) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_dummy2) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_dummy3) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_dummy4) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_dummy5) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_dummy6) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_dummy7) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_dummy8) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_dummy9) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - KODI_GUI_CONTROL_HANDLE(*get_control_dummy10) - (KODI_HANDLE kodiBase, KODI_GUI_WINDOW_HANDLE handle, int control_id); - /* This above used to add new get_control_* functions */ - } AddonToKodiFuncTable_kodi_gui_window; + // typedef bool(ATTR_APIENTRYP PFN_KODI_GUI_WINDOW_INIT_V1)(KODI_GUI_CLIENT_HANDLE clienthandle); + // typedef bool(ATTR_APIENTRYP PFN_KODI_GUI_WINDOW_FOCUS_V1)(KODI_GUI_CLIENT_HANDLE clienthandle, + // int control_id); + // typedef bool(ATTR_APIENTRYP PFN_KODI_GUI_WINDOW_CLICK_V1)(KODI_GUI_CLIENT_HANDLE clienthandle, + // int control_id); + // typedef bool(ATTR_APIENTRYP PFN_KODI_GUI_WINDOW_ON_ACTION_V1)(KODI_GUI_CLIENT_HANDLE clienthandle, + // enum ADDON_ACTION action); + // typedef void(ATTR_APIENTRYP PFN_KODI_GUI_WINDOW_GET_CONTEXT_BUTTONS_V1)( + // KODI_GUI_CLIENT_HANDLE clienthandle, + // int control_id, + // struct gui_context_menu_pair* entries, + // size_t* amount); + // typedef bool(ATTR_APIENTRYP PFN_KODI_GUI_WINDOW_ON_CONTEXT_BUTTON_V1)( + // KODI_GUI_CLIENT_HANDLE clienthandle, int control_id, size_t selected); + + /* Window creation functions */ + ATTR_DLL_EXPORT KODI_GUI_WINDOW_HANDLE kodi_gui_window_create(KODI_HANDLE kodiBase, + const char* xml_filename, + const char* default_skin, + bool as_dialog, + bool is_media) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_destroy(KODI_GUI_WINDOW_HANDLE handle) + __INTRODUCED_IN_KODI(1); + + // ATTR_DLL_EXPORT void kodi_gui_window_set_callbacks( + // KODI_GUI_WINDOW_HANDLE handle, + // KODI_GUI_CLIENT_HANDLE clienthandle, + // PFN_KODI_GUI_WINDOW_INIT_V1 cb_init, + // PFN_KODI_GUI_WINDOW_FOCUS_V1 cb_focus, + // PFN_KODI_GUI_WINDOW_CLICK_V1 cb_click, + // PFN_KODI_GUI_WINDOW_ON_ACTION_V1 cb_on_action, + // PFN_KODI_GUI_WINDOW_GET_CONTEXT_BUTTONS_V1 cb_get_context_buttons, + // PFN_KODI_GUI_WINDOW_ON_CONTEXT_BUTTON_V1 cb_on_context_button) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_window_show(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_window_close(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_window_do_modal(KODI_GUI_WINDOW_HANDLE handle) + __INTRODUCED_IN_KODI(1); + + /* Window control functions */ + ATTR_DLL_EXPORT bool kodi_gui_window_set_focus_id(KODI_GUI_WINDOW_HANDLE handle, int control_id) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_window_get_focus_id(KODI_GUI_WINDOW_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_set_control_label(KODI_GUI_WINDOW_HANDLE handle, + int control_id, + const char* label) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_set_control_visible(KODI_GUI_WINDOW_HANDLE handle, + int control_id, + bool visible) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_set_control_selected(KODI_GUI_WINDOW_HANDLE handle, + int control_id, + bool selected) __INTRODUCED_IN_KODI(1); + + /* Window property functions */ + ATTR_DLL_EXPORT void kodi_gui_window_set_property(KODI_GUI_WINDOW_HANDLE handle, + const char* key, + const char* value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_set_property_int(KODI_GUI_WINDOW_HANDLE handle, + const char* key, + int value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_set_property_bool(KODI_GUI_WINDOW_HANDLE handle, + const char* key, + bool value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_set_property_double(KODI_GUI_WINDOW_HANDLE handle, + const char* key, + double value) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_gui_window_get_property(KODI_GUI_WINDOW_HANDLE handle, const char* key) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_window_get_property_int(KODI_GUI_WINDOW_HANDLE handle, + const char* key) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_gui_window_get_property_bool(KODI_GUI_WINDOW_HANDLE handle, + const char* key) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT double kodi_gui_window_get_property_double(KODI_GUI_WINDOW_HANDLE handle, + const char* key) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_clear_properties(KODI_GUI_WINDOW_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_clear_property(KODI_GUI_WINDOW_HANDLE handle, + const char* key) __INTRODUCED_IN_KODI(1); + + /* List item functions */ + ATTR_DLL_EXPORT void kodi_gui_window_clear_item_list(KODI_GUI_WINDOW_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_add_list_item(KODI_GUI_WINDOW_HANDLE handle, + KODI_GUI_LISTITEM_HANDLE item, + int list_position) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_remove_list_item_from_position(KODI_GUI_WINDOW_HANDLE handle, + int list_position) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_remove_list_item(KODI_GUI_WINDOW_HANDLE handle, + KODI_GUI_LISTITEM_HANDLE item) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_LISTITEM_HANDLE kodi_gui_window_get_list_item( + KODI_GUI_WINDOW_HANDLE handle, int list_position) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_set_current_list_position(KODI_GUI_WINDOW_HANDLE handle, + int list_position) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_window_get_current_list_position(KODI_GUI_WINDOW_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_window_get_list_size(KODI_GUI_WINDOW_HANDLE handle) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_set_container_property(KODI_GUI_WINDOW_HANDLE handle, + const char* key, + const char* value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT void kodi_gui_window_set_container_content(KODI_GUI_WINDOW_HANDLE handle, + const char* value) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT int kodi_gui_window_get_current_container_id(KODI_GUI_WINDOW_HANDLE handle) + __INTRODUCED_IN_KODI(1); + + /* Various functions */ + ATTR_DLL_EXPORT void kodi_gui_window_mark_dirty_region(KODI_GUI_WINDOW_HANDLE handle) + __INTRODUCED_IN_KODI(1); + + /* GUI control access functions */ + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_button( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_edit( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_fade_label( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_image( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_label( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_progress( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_radio_button( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_render_addon( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_settings_slider( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_slider( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_spin( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_text_box( + KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); #ifdef __cplusplus } /* extern "C" */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/monitor.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/monitor.h new file mode 100644 index 0000000000000..68d7fa1248b1a --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/monitor.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#ifndef C_API_MONITOR_H +#define C_API_MONITOR_H + +#include "addon_base.h" + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + ATTR_DLL_EXPORT bool kodi_monitor_wait_for_abort(double timeout) __INTRODUCED_IN_KODI(1); + /*---AUTO_GEN_PARSE---*/ + + ATTR_DLL_EXPORT bool kodi_monitor_abort_requested() __INTRODUCED_IN_KODI(1); + /*---AUTO_GEN_PARSE---*/ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* !C_API_MONITOR_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/network.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/network.h index 8bd987be605ab..064259d7ff7bd 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/network.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/network.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2018 Team Kodi + * Copyright (C) 2005-2020 Team Kodi * This file is part of Kodi - https://kodi.tv * * SPDX-License-Identifier: GPL-2.0-or-later @@ -9,38 +9,29 @@ #ifndef C_API_NETWORK_H #define C_API_NETWORK_H -#include +#include "addon_base.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ - /* - * For interface between add-on and kodi. - * - * This structure defines the addresses of functions stored inside Kodi which - * are then available for the add-on to call - * - * All function pointers there are used by the C++ interface functions below. - * You find the set of them on xbmc/addons/interfaces/General.cpp - * - * Note: For add-on development itself this is not needed - */ - typedef struct AddonToKodiFuncTable_kodi_network - { - bool (*wake_on_lan)(void* kodiBase, const char* mac); - char* (*get_ip_address)(void* kodiBase); - char* (*dns_lookup)(void* kodiBase, const char* url, bool* ret); - char* (*url_encode)(void* kodiBase, const char* url); - char* (*get_hostname)(void* kodiBase); - bool (*is_local_host)(void* kodiBase, const char* hostname); - bool (*is_host_on_lan)(void* kodiBase, const char* hostname, bool offLineCheck); - char* (*get_user_agent)(void* kodiBase); - } AddonToKodiFuncTable_kodi_network; +#if __KODI_API__ >= 1 + + ATTR_DLL_EXPORT bool kodi_network_wake_on_lan(const char* mac) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_network_get_ip_address() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_network_dns_lookup(const char* url, bool* ret) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_network_url_encode(const char* url) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_network_get_hostname() __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_network_is_local_host(const char* hostname) __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT bool kodi_network_is_host_on_lan(const char* hostname, bool offLineCheck) + __INTRODUCED_IN_KODI(1); + ATTR_DLL_EXPORT char* kodi_network_get_user_agent() __INTRODUCED_IN_KODI(1); + +#endif /* __KODI_API__ >= 1 */ #ifdef __cplusplus -} /* extern "C" */ +} #endif /* __cplusplus */ -#endif /* C_API_NETWORK_H */ +#endif /* !C_API_NETWORK_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/c-api/version.h b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/version.h new file mode 100644 index 0000000000000..7bdcd0f75bc3a --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/include/kodi/c-api/version.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#ifndef C_API_VERSION_H +#define C_API_VERSION_H + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/** + * Major version of this KDK. + * + * For example: 1 for r1. + */ +#define __KDK_MAJOR__ 1 + +/** + * Minor version of this KDK. + * + * For example: 0 for r1 and 1 for r1b. + */ +#define __KDK_MINOR__ 0 + +/** + * Set to 0 if this is a release build, or 1 for beta 1, + * 2 for beta 2, and so on. + */ +#define __KDK_BETA__ 0 + +/** + * Set to 1 if this is a canary build, 0 if not. + */ +#define __KDK_CANARY__ 1 + +#define __KODI_API_FUTURE__ 10000 + +#ifndef __KODI_API__ +#define __KODI_API__ __KODI_API_FUTURE__ +#endif + +#define __KODI_API_1__ 1 + +#ifndef __INTRODUCED_IN_KODI +#define __INTRODUCED_IN_KODI(api_level) +#endif +#ifndef __DEPRECATED_IN_KODI +#define __DEPRECATED_IN_KODI(api_level) +#endif +#ifndef __REMOVED_IN_KODI +#define __REMOVED_IN_KODI(api_level) +#endif + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* !C_API_VERSION_H */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/General.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/General.h index 3aaa854ae5094..632720176a623 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/General.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/General.h @@ -35,7 +35,7 @@ namespace gui inline void ATTR_DLL_LOCAL Lock() { using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->general->lock(); + CPrivateBase::ifc.toKodi->kodi_gui->general->lock(); } //------------------------------------------------------------------------------ @@ -46,7 +46,7 @@ inline void ATTR_DLL_LOCAL Lock() inline void ATTR_DLL_LOCAL Unlock() { using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->general->unlock(); + CPrivateBase::ifc.toKodi->kodi_gui->general->unlock(); } //------------------------------------------------------------------------------ @@ -59,8 +59,8 @@ inline void ATTR_DLL_LOCAL Unlock() inline int ATTR_DLL_LOCAL GetScreenHeight() { using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->general->get_screen_height( - CPrivateBase::m_interface->toKodi->kodiBase); + return CPrivateBase::ifc.toKodi->kodi_gui->general->get_screen_height( + CPrivateBase::ifc.toKodi->kodiBase); } //------------------------------------------------------------------------------ @@ -73,8 +73,8 @@ inline int ATTR_DLL_LOCAL GetScreenHeight() inline int ATTR_DLL_LOCAL GetScreenWidth() { using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->general->get_screen_width( - CPrivateBase::m_interface->toKodi->kodiBase); + return CPrivateBase::ifc.toKodi->kodi_gui->general->get_screen_width( + CPrivateBase::ifc.toKodi->kodiBase); } //------------------------------------------------------------------------------ @@ -87,8 +87,8 @@ inline int ATTR_DLL_LOCAL GetScreenWidth() inline int ATTR_DLL_LOCAL GetVideoResolution() { using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->general->get_video_resolution( - CPrivateBase::m_interface->toKodi->kodiBase); + return CPrivateBase::ifc.toKodi->kodi_gui->general->get_video_resolution( + CPrivateBase::ifc.toKodi->kodiBase); } //------------------------------------------------------------------------------ @@ -111,8 +111,8 @@ inline int ATTR_DLL_LOCAL GetVideoResolution() inline int ATTR_DLL_LOCAL GetCurrentWindowDialogId() { using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->general->get_current_window_dialog_id( - CPrivateBase::m_interface->toKodi->kodiBase); + return CPrivateBase::ifc.toKodi->kodi_gui->general->get_current_window_dialog_id( + CPrivateBase::ifc.toKodi->kodiBase); } //------------------------------------------------------------------------------ @@ -135,8 +135,8 @@ inline int ATTR_DLL_LOCAL GetCurrentWindowDialogId() inline int ATTR_DLL_LOCAL GetCurrentWindowId() { using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->general->get_current_window_id( - CPrivateBase::m_interface->toKodi->kodiBase); + return CPrivateBase::ifc.toKodi->kodi_gui->general->get_current_window_id( + CPrivateBase::ifc.toKodi->kodiBase); } //------------------------------------------------------------------------------ @@ -165,8 +165,8 @@ inline int ATTR_DLL_LOCAL GetCurrentWindowId() inline kodi::HardwareContext GetHWContext() { using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->general->get_hw_context( - CPrivateBase::m_interface->toKodi->kodiBase); + return CPrivateBase::ifc.toKodi->kodi_gui->general->get_hw_context( + CPrivateBase::ifc.toKodi->kodiBase); } //------------------------------------------------------------------------------ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/ListItem.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/ListItem.h index 0d3e057113178..8eed9eff68655 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/ListItem.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/ListItem.h @@ -30,7 +30,7 @@ class ATTR_DLL_LOCAL CAddonGUIControlBase protected: explicit CAddonGUIControlBase(CAddonGUIControlBase* window) : m_controlHandle(nullptr), - m_interface(::kodi::addon::CPrivateBase::m_interface->toKodi), + m_interface(::kodi::addon::CPrivateBase::ifc.toKodi), m_Window(window) { } diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ContextMenu.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ContextMenu.h index 93d75cbbe0e92..0d7cbe53c0d80 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ContextMenu.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ContextMenu.h @@ -13,6 +13,8 @@ #ifdef __cplusplus +#include + namespace kodi { namespace gui @@ -67,15 +69,13 @@ namespace ContextMenu /// inline int ATTR_DLL_LOCAL Show(const std::string& heading, const std::vector& entries) { - using namespace ::kodi::addon; - unsigned int size = static_cast(entries.size()); + const size_t size = entries.size(); const char** cEntries = static_cast(malloc(size * sizeof(const char**))); for (unsigned int i = 0; i < size; ++i) { cEntries[i] = entries[i].c_str(); } - int ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogContextMenu->open( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), cEntries, size); + int ret = kodi::dl::api.kodi_gui_dialogs_context_menu_open(heading.c_str(), cEntries, size); free(cEntries); return ret; } @@ -115,15 +115,13 @@ inline int ATTR_DLL_LOCAL Show(const std::string& heading, const std::vector>& entries) { - using namespace ::kodi::addon; - unsigned int size = static_cast(entries.size()); + const size_t size = entries.size(); const char** cEntries = static_cast(malloc(size * sizeof(const char**))); for (unsigned int i = 0; i < size; ++i) { cEntries[i] = entries[i].second.c_str(); } - int ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogContextMenu->open( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), cEntries, size); + int ret = kodi::dl::api.kodi_gui_dialogs_context_menu_open(heading.c_str(), cEntries, size); free(cEntries); return ret; } @@ -163,15 +161,13 @@ inline int ATTR_DLL_LOCAL Show(const std::string& heading, inline int ATTR_DLL_LOCAL Show(const std::string& heading, const std::vector>& entries) { - using namespace ::kodi::addon; - unsigned int size = static_cast(entries.size()); + const size_t size = entries.size(); const char** cEntries = static_cast(malloc(size * sizeof(const char**))); for (unsigned int i = 0; i < size; ++i) { cEntries[i] = entries[i].second.c_str(); } - int ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogContextMenu->open( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), cEntries, size); + int ret = kodi::dl::api.kodi_gui_dialogs_context_menu_open(heading.c_str(), cEntries, size); free(cEntries); return ret; } diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ExtendedProgress.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ExtendedProgress.h index 3c21877c327c9..40272af983c73 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ExtendedProgress.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/ExtendedProgress.h @@ -13,6 +13,8 @@ #ifdef __cplusplus +#include + namespace kodi { namespace gui @@ -66,10 +68,7 @@ class ATTR_DLL_LOCAL CExtendedProgress /// explicit CExtendedProgress(const std::string& title = "") { - using namespace ::kodi::addon; - m_DialogHandle = - CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->new_dialog( - CPrivateBase::m_interface->toKodi->kodiBase, title.c_str()); + m_DialogHandle = kodi::dl::api.kodi_gui_dialogs_extended_progress_new_dialog(title.c_str()); if (!m_DialogHandle) kodi::Log(ADDON_LOG_FATAL, "kodi::gui::CDialogExtendedProgress can't create window class from Kodi !!!"); @@ -82,10 +81,8 @@ class ATTR_DLL_LOCAL CExtendedProgress /// ~CExtendedProgress() { - using namespace ::kodi::addon; if (m_DialogHandle) - CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->delete_dialog( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); + kodi::dl::api.kodi_gui_dialogs_extended_progress_delete_dialog(m_DialogHandle); } //---------------------------------------------------------------------------- @@ -97,16 +94,13 @@ class ATTR_DLL_LOCAL CExtendedProgress /// std::string Title() const { - using namespace ::kodi::addon; std::string text; - char* strMsg = CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->get_title( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); + char* strMsg = kodi::dl::api.kodi_gui_dialogs_extended_progress_get_title(m_DialogHandle); if (strMsg != nullptr) { if (std::strlen(strMsg)) text = strMsg; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - strMsg); + free(strMsg); } return text; } @@ -120,9 +114,7 @@ class ATTR_DLL_LOCAL CExtendedProgress /// void SetTitle(const std::string& title) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->set_title( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, title.c_str()); + kodi::dl::api.kodi_gui_dialogs_extended_progress_set_title(m_DialogHandle, title.c_str()); } //---------------------------------------------------------------------------- @@ -134,16 +126,13 @@ class ATTR_DLL_LOCAL CExtendedProgress /// std::string Text() const { - using namespace ::kodi::addon; std::string text; - char* strMsg = CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->get_text( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); + char* strMsg = kodi::dl::api.kodi_gui_dialogs_extended_progress_get_text(m_DialogHandle); if (strMsg != nullptr) { if (std::strlen(strMsg)) text = strMsg; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - strMsg); + free(strMsg); } return text; } @@ -157,9 +146,7 @@ class ATTR_DLL_LOCAL CExtendedProgress /// void SetText(const std::string& text) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->set_text( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, text.c_str()); + kodi::dl::api.kodi_gui_dialogs_extended_progress_set_text(m_DialogHandle, text.c_str()); } //---------------------------------------------------------------------------- @@ -171,9 +158,7 @@ class ATTR_DLL_LOCAL CExtendedProgress /// bool IsFinished() const { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->is_finished( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); + return kodi::dl::api.kodi_gui_dialogs_extended_progress_is_finished(m_DialogHandle); } //---------------------------------------------------------------------------- @@ -183,9 +168,7 @@ class ATTR_DLL_LOCAL CExtendedProgress /// void MarkFinished() { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->mark_finished( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); + kodi::dl::api.kodi_gui_dialogs_extended_progress_mark_finished(m_DialogHandle); } //---------------------------------------------------------------------------- @@ -197,9 +180,7 @@ class ATTR_DLL_LOCAL CExtendedProgress /// float Percentage() const { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->get_percentage( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); + return kodi::dl::api.kodi_gui_dialogs_extended_progress_get_percentage(m_DialogHandle); } //---------------------------------------------------------------------------- @@ -211,9 +192,7 @@ class ATTR_DLL_LOCAL CExtendedProgress /// void SetPercentage(float percentage) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->set_percentage( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, percentage); + kodi::dl::api.kodi_gui_dialogs_extended_progress_set_percentage(m_DialogHandle, percentage); } //---------------------------------------------------------------------------- @@ -226,9 +205,8 @@ class ATTR_DLL_LOCAL CExtendedProgress /// void SetProgress(int currentItem, int itemCount) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogExtendedProgress->set_progress( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, currentItem, itemCount); + kodi::dl::api.kodi_gui_dialogs_extended_progress_set_progress(m_DialogHandle, currentItem, + itemCount); } //---------------------------------------------------------------------------- diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/FileBrowser.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/FileBrowser.h index b7550f2c23c73..cff8ef41c573f 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/FileBrowser.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/FileBrowser.h @@ -13,6 +13,9 @@ #ifdef __cplusplus +#include +#include + namespace kodi { namespace gui @@ -72,17 +75,14 @@ inline bool ATTR_DLL_LOCAL ShowAndGetDirectory(const std::string& shares, std::string& path, bool writeOnly = false) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_directory( - CPrivateBase::m_interface->toKodi->kodiBase, shares.c_str(), heading.c_str(), path.c_str(), - &retString, writeOnly); + bool ret = kodi::dl::api.kodi_gui_dialogs_file_browser_show_and_get_directory( + shares.c_str(), heading.c_str(), path.c_str(), &retString, writeOnly); if (retString != nullptr) { if (std::strlen(retString)) path = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -109,17 +109,15 @@ inline bool ATTR_DLL_LOCAL ShowAndGetFile(const std::string& shares, bool useThumbs = false, bool useFileDirectories = false) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_file( - CPrivateBase::m_interface->toKodi->kodiBase, shares.c_str(), mask.c_str(), heading.c_str(), - path.c_str(), &retString, useThumbs, useFileDirectories); + bool ret = kodi::dl::api.kodi_gui_dialogs_file_browser_show_and_get_file( + shares.c_str(), mask.c_str(), heading.c_str(), path.c_str(), &retString, useThumbs, + useFileDirectories); if (retString != nullptr) { if (std::strlen(retString)) path = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -149,18 +147,15 @@ inline bool ATTR_DLL_LOCAL ShowAndGetFileFromDir(const std::string& directory, bool useFileDirectories = false, bool singleList = false) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = - CPrivateBase::m_interface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_file_from_dir( - CPrivateBase::m_interface->toKodi->kodiBase, directory.c_str(), mask.c_str(), - heading.c_str(), path.c_str(), &retString, useThumbs, useFileDirectories, singleList); + bool ret = kodi::dl::api.kodi_gui_dialogs_file_browser_show_and_get_file_from_dir( + directory.c_str(), mask.c_str(), heading.c_str(), path.c_str(), &retString, useThumbs, + useFileDirectories, singleList); if (retString != nullptr) { if (std::strlen(retString)) path = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -186,18 +181,16 @@ inline bool ATTR_DLL_LOCAL ShowAndGetFileList(const std::string& shares, bool useThumbs = false, bool useFileDirectories = false) { - using namespace ::kodi::addon; char** list = nullptr; - unsigned int listSize = 0; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_file_list( - CPrivateBase::m_interface->toKodi->kodiBase, shares.c_str(), mask.c_str(), heading.c_str(), - &list, &listSize, useThumbs, useFileDirectories); + size_t listSize = 0; + bool ret = kodi::dl::api.kodi_gui_dialogs_file_browser_show_and_get_file_list( + shares.c_str(), mask.c_str(), heading.c_str(), &list, &listSize, useThumbs, + useFileDirectories); if (ret) { - for (unsigned int i = 0; i < listSize; ++i) + for (size_t i = 0; i < listSize; ++i) fileList.emplace_back(list[i]); - CPrivateBase::m_interface->toKodi->kodi_gui->dialogFileBrowser->clear_file_list( - CPrivateBase::m_interface->toKodi->kodiBase, &list, listSize); + kodi::dl::api.kodi_gui_dialogs_file_browser_clear_file_list(&list, listSize); } return ret; } @@ -220,17 +213,14 @@ inline bool ATTR_DLL_LOCAL ShowAndGetSource(std::string& path, const std::string& additionalShare = "", const std::string& type = "") { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_source( - CPrivateBase::m_interface->toKodi->kodiBase, path.c_str(), &retString, allowNetworkShares, - additionalShare.c_str(), type.c_str()); + bool ret = kodi::dl::api.kodi_gui_dialogs_file_browser_show_and_get_source( + path.c_str(), &retString, allowNetworkShares, additionalShare.c_str(), type.c_str()); if (retString != nullptr) { if (std::strlen(retString)) path = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -249,17 +239,14 @@ inline bool ATTR_DLL_LOCAL ShowAndGetImage(const std::string& shares, const std::string& heading, std::string& path) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_image( - CPrivateBase::m_interface->toKodi->kodiBase, shares.c_str(), heading.c_str(), path.c_str(), - &retString); + bool ret = kodi::dl::api.kodi_gui_dialogs_file_browser_show_and_get_image( + shares.c_str(), heading.c_str(), path.c_str(), &retString); if (retString != nullptr) { if (std::strlen(retString)) path = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -278,24 +265,22 @@ inline bool ATTR_DLL_LOCAL ShowAndGetImageList(const std::string& shares, const std::string& heading, std::vector& file_list) { - using namespace ::kodi::addon; char** list = nullptr; - unsigned int listSize = 0; - bool ret = - CPrivateBase::m_interface->toKodi->kodi_gui->dialogFileBrowser->show_and_get_image_list( - CPrivateBase::m_interface->toKodi->kodiBase, shares.c_str(), heading.c_str(), &list, - &listSize); + size_t listSize = 0; + bool ret = kodi::dl::api.kodi_gui_dialogs_file_browser_show_and_get_image_list( + shares.c_str(), heading.c_str(), &list, &listSize); if (ret) { - for (unsigned int i = 0; i < listSize; ++i) + for (size_t i = 0; i < listSize; ++i) file_list.emplace_back(list[i]); - CPrivateBase::m_interface->toKodi->kodi_gui->dialogFileBrowser->clear_file_list( - CPrivateBase::m_interface->toKodi->kodiBase, &list, listSize); + kodi::dl::api.kodi_gui_dialogs_file_browser_clear_file_list(&list, listSize); } return ret; } //------------------------------------------------------------------------------ -}; // namespace FileBrowser + + +} /* namespace FileBrowser */ } /* namespace dialogs */ } /* namespace gui */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Keyboard.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Keyboard.h index 9aded507007b0..ba59544691607 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Keyboard.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Keyboard.h @@ -13,6 +13,8 @@ #ifdef __cplusplus +#include + namespace kodi { namespace gui @@ -77,17 +79,13 @@ inline bool ATTR_DLL_LOCAL ShowAndGetInput(std::string& text, bool hiddenInput = false, unsigned int autoCloseMs = 0) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = - CPrivateBase::m_interface->toKodi->kodi_gui->dialogKeyboard->show_and_get_input_with_head( - CPrivateBase::m_interface->toKodi->kodiBase, text.c_str(), &retString, heading.c_str(), - allowEmptyResult, hiddenInput, autoCloseMs); + bool ret = kodi::dl::api.kodi_gui_dialogs_keyboard_show_and_get_input_with_head( + text.c_str(), &retString, heading.c_str(), allowEmptyResult, hiddenInput, autoCloseMs); if (retString != nullptr) { text = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -111,16 +109,13 @@ inline bool ATTR_DLL_LOCAL ShowAndGetInput(std::string& text, bool allowEmptyResult, unsigned int autoCloseMs = 0) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogKeyboard->show_and_get_input( - CPrivateBase::m_interface->toKodi->kodiBase, text.c_str(), &retString, allowEmptyResult, - autoCloseMs); + bool ret = kodi::dl::api.kodi_gui_dialogs_keyboard_show_and_get_input( + text.c_str(), &retString, allowEmptyResult, autoCloseMs); if (retString != nullptr) { text = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -145,17 +140,14 @@ inline bool ATTR_DLL_LOCAL ShowAndGetNewPassword(std::string& newPassword, bool allowEmptyResult, unsigned int autoCloseMs = 0) { - using namespace ::kodi::addon; + ; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogKeyboard - ->show_and_get_new_password_with_head( - CPrivateBase::m_interface->toKodi->kodiBase, newPassword.c_str(), &retString, - heading.c_str(), allowEmptyResult, autoCloseMs); + bool ret = kodi::dl::api.kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head( + newPassword.c_str(), &retString, heading.c_str(), allowEmptyResult, autoCloseMs); if (retString != nullptr) { newPassword = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -176,15 +168,13 @@ inline bool ATTR_DLL_LOCAL ShowAndGetNewPassword(std::string& newPassword, inline bool ATTR_DLL_LOCAL ShowAndGetNewPassword(std::string& newPassword, unsigned int autoCloseMs = 0) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogKeyboard->show_and_get_new_password( - CPrivateBase::m_interface->toKodi->kodiBase, newPassword.c_str(), &retString, autoCloseMs); + bool ret = kodi::dl::api.kodi_gui_dialogs_keyboard_show_and_get_new_password( + newPassword.c_str(), &retString, autoCloseMs); if (retString != nullptr) { newPassword = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -251,17 +241,13 @@ inline bool ATTR_DLL_LOCAL ShowAndVerifyNewPassword(std::string& newPassword, bool allowEmptyResult, unsigned int autoCloseMs = 0) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogKeyboard - ->show_and_verify_new_password_with_head( - CPrivateBase::m_interface->toKodi->kodiBase, &retString, heading.c_str(), - allowEmptyResult, autoCloseMs); + bool ret = kodi::dl::api.kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head( + &retString, heading.c_str(), allowEmptyResult, autoCloseMs); if (retString != nullptr) { newPassword = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -282,16 +268,13 @@ inline bool ATTR_DLL_LOCAL ShowAndVerifyNewPassword(std::string& newPassword, inline bool ATTR_DLL_LOCAL ShowAndVerifyNewPassword(std::string& newPassword, unsigned int autoCloseMs = 0) { - using namespace ::kodi::addon; char* retString = nullptr; bool ret = - CPrivateBase::m_interface->toKodi->kodi_gui->dialogKeyboard->show_and_verify_new_password( - CPrivateBase::m_interface->toKodi->kodiBase, &retString, autoCloseMs); + kodi::dl::api.kodi_gui_dialogs_keyboard_show_and_verify_new_password(&retString, autoCloseMs); if (retString != nullptr) { newPassword = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -316,16 +299,13 @@ inline int ATTR_DLL_LOCAL ShowAndVerifyPassword(std::string& password, int retries, unsigned int autoCloseMs = 0) { - using namespace ::kodi::addon; char* retString = nullptr; - int ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogKeyboard->show_and_verify_password( - CPrivateBase::m_interface->toKodi->kodiBase, password.c_str(), &retString, heading.c_str(), - retries, autoCloseMs); + int ret = kodi::dl::api.kodi_gui_dialogs_keyboard_show_and_verify_password( + password.c_str(), &retString, heading.c_str(), retries, autoCloseMs); if (retString != nullptr) { password = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -350,16 +330,13 @@ inline bool ATTR_DLL_LOCAL ShowAndGetFilter(std::string& text, bool searching, unsigned int autoCloseMs = 0) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogKeyboard->show_and_get_filter( - CPrivateBase::m_interface->toKodi->kodiBase, text.c_str(), &retString, searching, - autoCloseMs); + bool ret = kodi::dl::api.kodi_gui_dialogs_keyboard_show_and_get_filter(text.c_str(), &retString, + searching, autoCloseMs); if (retString != nullptr) { text = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -377,9 +354,8 @@ inline bool ATTR_DLL_LOCAL ShowAndGetFilter(std::string& text, inline bool ATTR_DLL_LOCAL SendTextToActiveKeyboard(const std::string& text, bool closeKeyboard = false) { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogKeyboard->send_text_to_active_keyboard( - CPrivateBase::m_interface->toKodi->kodiBase, text.c_str(), closeKeyboard); + return kodi::dl::api.kodi_gui_dialogs_keyboard_send_text_to_active_keyboard(text.c_str(), + closeKeyboard); } //------------------------------------------------------------------------------ @@ -391,9 +367,7 @@ inline bool ATTR_DLL_LOCAL SendTextToActiveKeyboard(const std::string& text, /// inline bool ATTR_DLL_LOCAL IsKeyboardActivated() { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogKeyboard->is_keyboard_activated( - CPrivateBase::m_interface->toKodi->kodiBase); + return kodi::dl::api.kodi_gui_dialogs_keyboard_is_keyboard_activated(); } //------------------------------------------------------------------------------ }; // namespace Keyboard diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Numeric.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Numeric.h index 54b77206f7e84..9229d2d1e2814 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Numeric.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Numeric.h @@ -49,15 +49,12 @@ namespace Numeric /// inline bool ATTR_DLL_LOCAL ShowAndVerifyNewPassword(std::string& newPassword) { - using namespace ::kodi::addon; char* pw = nullptr; - bool ret = - CPrivateBase::m_interface->toKodi->kodi_gui->dialogNumeric->show_and_verify_new_password( - CPrivateBase::m_interface->toKodi->kodiBase, &pw); + bool ret = kodi::dl::api.kodi_gui_dialogs_numeric_show_and_verify_new_password(&pw); if (pw != nullptr) { newPassword = pw; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, pw); + free(pw); } return ret; } @@ -126,9 +123,8 @@ inline int ATTR_DLL_LOCAL ShowAndVerifyPassword(const std::string& password, const std::string& heading, int retries) { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogNumeric->show_and_verify_password( - CPrivateBase::m_interface->toKodi->kodiBase, password.c_str(), heading.c_str(), retries); + return kodi::dl::api.kodi_gui_dialogs_numeric_show_and_verify_password(password.c_str(), + heading.c_str(), retries); } //------------------------------------------------------------------------------ @@ -147,16 +143,13 @@ inline bool ATTR_DLL_LOCAL ShowAndVerifyInput(std::string& toVerify, const std::string& heading, bool verifyInput) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogNumeric->show_and_verify_input( - CPrivateBase::m_interface->toKodi->kodiBase, toVerify.c_str(), &retString, heading.c_str(), - verifyInput); + bool ret = kodi::dl::api.kodi_gui_dialogs_numeric_show_and_verify_input( + toVerify.c_str(), &retString, heading.c_str(), verifyInput); if (retString != nullptr) { toVerify = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -194,9 +187,7 @@ inline bool ATTR_DLL_LOCAL ShowAndVerifyInput(std::string& toVerify, /// inline bool ATTR_DLL_LOCAL ShowAndGetTime(tm& time, const std::string& heading) { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogNumeric->show_and_get_time( - CPrivateBase::m_interface->toKodi->kodiBase, &time, heading.c_str()); + return kodi::dl::api.kodi_gui_dialogs_numeric_show_and_get_time(&time, heading.c_str()); } //------------------------------------------------------------------------------ @@ -232,9 +223,7 @@ inline bool ATTR_DLL_LOCAL ShowAndGetTime(tm& time, const std::string& heading) /// inline bool ATTR_DLL_LOCAL ShowAndGetDate(tm& date, const std::string& heading) { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogNumeric->show_and_get_date( - CPrivateBase::m_interface->toKodi->kodiBase, &date, heading.c_str()); + return kodi::dl::api.kodi_gui_dialogs_numeric_show_and_get_date(&date, heading.c_str()); } //------------------------------------------------------------------------------ @@ -250,15 +239,13 @@ inline bool ATTR_DLL_LOCAL ShowAndGetDate(tm& date, const std::string& heading) /// inline bool ATTR_DLL_LOCAL ShowAndGetIPAddress(std::string& ipAddress, const std::string& heading) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogNumeric->show_and_get_ip_address( - CPrivateBase::m_interface->toKodi->kodiBase, ipAddress.c_str(), &retString, heading.c_str()); + bool ret = kodi::dl::api.kodi_gui_dialogs_numeric_show_and_get_ip_address( + ipAddress.c_str(), &retString, heading.c_str()); if (retString != nullptr) { ipAddress = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -297,16 +284,13 @@ inline bool ATTR_DLL_LOCAL ShowAndGetNumber(std::string& input, const std::string& heading, unsigned int autoCloseTimeoutMs = 0) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogNumeric->show_and_get_number( - CPrivateBase::m_interface->toKodi->kodiBase, input.c_str(), &retString, heading.c_str(), - autoCloseTimeoutMs); + bool ret = kodi::dl::api.kodi_gui_dialogs_numeric_show_and_get_number( + input.c_str(), &retString, heading.c_str(), autoCloseTimeoutMs); if (retString != nullptr) { input = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } @@ -324,15 +308,13 @@ inline bool ATTR_DLL_LOCAL ShowAndGetNumber(std::string& input, /// inline bool ATTR_DLL_LOCAL ShowAndGetSeconds(std::string& time, const std::string& heading) { - using namespace ::kodi::addon; char* retString = nullptr; - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogNumeric->show_and_get_seconds( - CPrivateBase::m_interface->toKodi->kodiBase, time.c_str(), &retString, heading.c_str()); + bool ret = kodi::dl::api.kodi_gui_dialogs_numeric_show_and_get_seconds(time.c_str(), &retString, + heading.c_str()); if (retString != nullptr) { time = retString; - CPrivateBase::m_interface->toKodi->free_string(CPrivateBase::m_interface->toKodi->kodiBase, - retString); + free(retString); } return ret; } diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/OK.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/OK.h index a9fcb3fd3f7e4..3901e3b77cd72 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/OK.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/OK.h @@ -54,9 +54,7 @@ namespace OK /// inline void ATTR_DLL_LOCAL ShowAndGetInput(const std::string& heading, const std::string& text) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogOK->show_and_get_input_single_text( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), text.c_str()); + kodi::dl::api.kodi_gui_dialogs_ok_show_and_get_input_single_text(heading.c_str(), text.c_str()); } //------------------------------------------------------------------------------ @@ -85,10 +83,8 @@ inline void ATTR_DLL_LOCAL ShowAndGetInput(const std::string& heading, const std::string& line1, const std::string& line2) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogOK->show_and_get_input_line_text( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), line0.c_str(), line1.c_str(), - line2.c_str()); + kodi::dl::api.kodi_gui_dialogs_ok_show_and_get_input_line_text(heading.c_str(), line0.c_str(), + line1.c_str(), line2.c_str()); } //------------------------------------------------------------------------------ } // namespace OK diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Progress.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Progress.h index 3dfd8badbf45e..775f6a1336999 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Progress.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Progress.h @@ -58,9 +58,7 @@ class ATTR_DLL_LOCAL CProgress /// CProgress() { - using namespace ::kodi::addon; - m_DialogHandle = CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->new_dialog( - CPrivateBase::m_interface->toKodi->kodiBase); + m_DialogHandle = kodi::dl::api.kodi_gui_dialogs_progress_new_dialog(); if (!m_DialogHandle) kodi::Log(ADDON_LOG_FATAL, "kodi::gui::dialogs::CProgress can't create window class from Kodi !!!"); @@ -73,10 +71,8 @@ class ATTR_DLL_LOCAL CProgress /// ~CProgress() { - using namespace ::kodi::addon; if (m_DialogHandle) - CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->delete_dialog( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); + kodi::dl::api.kodi_gui_dialogs_progress_delete_dialog(m_DialogHandle); } //---------------------------------------------------------------------------- @@ -84,12 +80,7 @@ class ATTR_DLL_LOCAL CProgress /// @ingroup cpp_kodi_gui_dialogs_CProgress /// @brief To open the dialog /// - void Open() - { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->open( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); - } + void Open() { kodi::dl::api.kodi_gui_dialogs_progress_open(m_DialogHandle); } //---------------------------------------------------------------------------- //============================================================================ @@ -100,9 +91,7 @@ class ATTR_DLL_LOCAL CProgress /// void SetHeading(const std::string& heading) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->set_heading( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, heading.c_str()); + kodi::dl::api.kodi_gui_dialogs_progress_set_heading(m_DialogHandle, heading.c_str()); } //---------------------------------------------------------------------------- @@ -115,9 +104,7 @@ class ATTR_DLL_LOCAL CProgress /// void SetLine(unsigned int iLine, const std::string& line) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->set_line( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, iLine, line.c_str()); + kodi::dl::api.kodi_gui_dialogs_progress_set_line(m_DialogHandle, iLine, line.c_str()); } //---------------------------------------------------------------------------- @@ -129,9 +116,7 @@ class ATTR_DLL_LOCAL CProgress /// void SetCanCancel(bool canCancel) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->set_can_cancel( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, canCancel); + kodi::dl::api.kodi_gui_dialogs_progress_set_can_cancel(m_DialogHandle, canCancel); } //---------------------------------------------------------------------------- @@ -143,9 +128,7 @@ class ATTR_DLL_LOCAL CProgress /// bool IsCanceled() const { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->is_canceled( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); + return kodi::dl::api.kodi_gui_dialogs_progress_is_canceled(m_DialogHandle); } //---------------------------------------------------------------------------- @@ -157,9 +140,7 @@ class ATTR_DLL_LOCAL CProgress /// void SetPercentage(int percentage) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->set_percentage( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, percentage); + kodi::dl::api.kodi_gui_dialogs_progress_set_percentage(m_DialogHandle, percentage); } //---------------------------------------------------------------------------- @@ -171,9 +152,7 @@ class ATTR_DLL_LOCAL CProgress /// int GetPercentage() const { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->get_percentage( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); + return kodi::dl::api.kodi_gui_dialogs_progress_get_percentage(m_DialogHandle); } //---------------------------------------------------------------------------- @@ -185,9 +164,7 @@ class ATTR_DLL_LOCAL CProgress /// void ShowProgressBar(bool onOff) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->show_progress_bar( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, onOff); + kodi::dl::api.kodi_gui_dialogs_progress_show_progress_bar(m_DialogHandle, onOff); } //---------------------------------------------------------------------------- @@ -199,9 +176,7 @@ class ATTR_DLL_LOCAL CProgress /// void SetProgressMax(int max) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->set_progress_max( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, max); + kodi::dl::api.kodi_gui_dialogs_progress_set_progress_max(m_DialogHandle, max); } //---------------------------------------------------------------------------- @@ -213,9 +188,7 @@ class ATTR_DLL_LOCAL CProgress /// void SetProgressAdvance(int steps = 1) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->set_progress_advance( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle, steps); + kodi::dl::api.kodi_gui_dialogs_progress_set_progress_advance(m_DialogHandle, steps); } //---------------------------------------------------------------------------- @@ -225,12 +198,7 @@ class ATTR_DLL_LOCAL CProgress /// /// @return True if aborted /// - bool Abort() - { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogProgress->abort( - CPrivateBase::m_interface->toKodi->kodiBase, m_DialogHandle); - } + bool Abort() { return kodi::dl::api.kodi_gui_dialogs_progress_abort(m_DialogHandle); } //---------------------------------------------------------------------------- private: diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Select.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Select.h index 09bccc31af9a3..7479517250449 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Select.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/Select.h @@ -13,6 +13,8 @@ #ifdef __cplusplus +#include + namespace kodi { namespace gui @@ -115,9 +117,8 @@ inline int ATTR_DLL_LOCAL Show(const std::string& heading, { cEntries[i] = entries[i].c_str(); } - int ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogSelect->open( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), cEntries, size, selected, - autoclose); + int ret = kodi::dl::api.kodi_gui_dialogs_select_open(heading.c_str(), cEntries, size, selected, + autoclose); free(cEntries); return ret; } @@ -167,7 +168,6 @@ inline int ATTR_DLL_LOCAL Show(const std::string& heading, int selected = -1, unsigned int autoclose = 0) { - using namespace ::kodi::addon; unsigned int size = static_cast(entries.size()); const char** cEntries = static_cast(malloc(size * sizeof(const char*))); for (unsigned int i = 0; i < size; ++i) @@ -176,9 +176,8 @@ inline int ATTR_DLL_LOCAL Show(const std::string& heading, if (selected == -1 && entries[i].selected) selected = i; } - int ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogSelect->open( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), cEntries, size, selected, - autoclose); + int ret = kodi::dl::api.kodi_gui_dialogs_select_open(heading.c_str(), cEntries, size, selected, + autoclose); if (ret >= 0) { entries[ret].selected = true; @@ -235,20 +234,18 @@ ShowMultiSelect(const std::string& heading, std::vector& entries, int autoclose = 0) { - using namespace ::kodi::addon; unsigned int size = static_cast(entries.size()); const char** cEntryIDs = static_cast(malloc(size * sizeof(const char*))); const char** cEntryNames = static_cast(malloc(size * sizeof(const char*))); - bool* cEntriesSelected = static_cast(malloc(size * sizeof(bool))); + uint8_t* cEntriesSelected = static_cast(malloc(size * sizeof(uint8_t))); for (unsigned int i = 0; i < size; ++i) { cEntryIDs[i] = entries[i].id.c_str(); cEntryNames[i] = entries[i].name.c_str(); cEntriesSelected[i] = entries[i].selected; } - bool ret = CPrivateBase::m_interface->toKodi->kodi_gui->dialogSelect->open_multi_select( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), cEntryIDs, cEntryNames, - cEntriesSelected, size, autoclose); + bool ret = kodi::dl::api.kodi_gui_dialogs_select_open_multi_select( + heading.c_str(), cEntryIDs, cEntryNames, cEntriesSelected, size, autoclose); if (ret) { for (unsigned int i = 0; i < size; ++i) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/TextViewer.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/TextViewer.h index 7c2e6ca8046ca..94d437732eb61 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/TextViewer.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/TextViewer.h @@ -94,9 +94,7 @@ namespace TextViewer /// inline void ATTR_DLL_LOCAL Show(const std::string& heading, const std::string& text) { - using namespace ::kodi::addon; - CPrivateBase::m_interface->toKodi->kodi_gui->dialogTextViewer->open( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), text.c_str()); + kodi::dl::api.kodi_gui_dialogs_text_viewer_show(heading.c_str(), text.c_str()); } //------------------------------------------------------------------------------ }; // namespace TextViewer diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/YesNo.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/YesNo.h index e4d3d1201e09d..3678604eb0852 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/YesNo.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/dialogs/YesNo.h @@ -77,10 +77,8 @@ inline bool ATTR_DLL_LOCAL ShowAndGetInput(const std::string& heading, const std::string& noLabel = "", const std::string& yesLabel = "") { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogYesNo->show_and_get_input_single_text( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), text.c_str(), &canceled, - noLabel.c_str(), yesLabel.c_str()); + return kodi::dl::api.kodi_gui_dialogs_yesno_show_and_get_input_single_text( + heading.c_str(), text.c_str(), &canceled, noLabel.c_str(), yesLabel.c_str()); } //------------------------------------------------------------------------------ @@ -121,10 +119,9 @@ inline bool ATTR_DLL_LOCAL ShowAndGetInput(const std::string& heading, const std::string& noLabel = "", const std::string& yesLabel = "") { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogYesNo->show_and_get_input_line_text( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), line0.c_str(), line1.c_str(), - line2.c_str(), noLabel.c_str(), yesLabel.c_str()); + return kodi::dl::api.kodi_gui_dialogs_yesno_show_and_get_input_line_text( + heading.c_str(), line0.c_str(), line1.c_str(), line2.c_str(), noLabel.c_str(), + yesLabel.c_str()); } //------------------------------------------------------------------------------ @@ -171,11 +168,9 @@ inline bool ATTR_DLL_LOCAL ShowAndGetInput(const std::string& heading, const std::string& noLabel = "", const std::string& yesLabel = "") { - using namespace ::kodi::addon; - return CPrivateBase::m_interface->toKodi->kodi_gui->dialogYesNo - ->show_and_get_input_line_button_text( - CPrivateBase::m_interface->toKodi->kodiBase, heading.c_str(), line0.c_str(), - line1.c_str(), line2.c_str(), &canceled, noLabel.c_str(), yesLabel.c_str()); + return kodi::dl::api.kodi_gui_dialogs_yesno_show_and_get_input_line_button_text( + heading.c_str(), line0.c_str(), line1.c_str(), line2.c_str(), &canceled, noLabel.c_str(), + yesLabel.c_str()); } //------------------------------------------------------------------------------ }; // namespace YesNo diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/gl/GLonDX.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/gl/GLonDX.h index 9ba76eacc3653..508726a7846d4 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/gl/GLonDX.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/gl/GLonDX.h @@ -12,13 +12,14 @@ #if defined(WIN32) && defined(HAS_ANGLE) +#include "../../AddonBase.h" +#include "../../gui/General.h" + #include #include #include #include #include -#include -#include #include #pragma comment(lib, "d3dcompiler.lib") diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/gl/Shader.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/gl/Shader.h index ae78b7c36032f..88fb8241cfb15 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/gl/Shader.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/gl/Shader.h @@ -12,13 +12,13 @@ #ifdef __cplusplus +#include "../../AddonBase.h" +#include "../../Filesystem.h" + #include #include #include -#include -#include - #define LOG_SIZE 1024 #define GLchar char @@ -51,7 +51,7 @@ class ATTR_DLL_LOCAL CShader file.c_str()); return false; } - size_t len = source.Read(buffer, sizeof(buffer)); + size_t len = source.Read(reinterpret_cast(buffer), sizeof(buffer)); m_source.assign(buffer); m_source[len] = 0; source.Close(); diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/input/Action.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/input/Action.h new file mode 100644 index 0000000000000..50875093fa913 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/input/Action.h @@ -0,0 +1,343 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "../../c-api/gui/input/action.h" +#include "ActionIDs.h" + +#ifdef __cplusplus + +#include + +namespace kodi +{ + +namespace addon +{ + class CInstanceWeb; +} /* namespace addon */ + +namespace gui +{ + +class CWindow; + +namespace input +{ + +/// @defgroup cpp_kodi_gui_Defs_CAction class CAction +/// @ingroup cpp_kodi_gui_Defs +/// @brief **Action signal class**\n +/// Class e to manage given actions calls from Kodi. +/// +/// This used by @ref kodi::gui::CWindow::OnAction() and partly on +/// other parts. +/// +///@{ +class CAction +{ +public: + //============================================================================ + /// @brief Default constructor with values set to default/empty. + /// + CAction() = default; + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Constructor for unicode date e.g. from Keyboard. + /// + /// @param[in] actionID ID to use, see @ref ADDON_ACTION about possible values + /// @param[in] unicode Unicode character to give on construction + /// + CAction(ADDON_ACTION actionID, wchar_t unicode) + : m_id(actionID), + m_unicode(unicode) + { + } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Constructor with set also used name. + /// + /// @param[in] actionID ID to use, see @ref ADDON_ACTION about possible values + /// @param[in] name Action name to set + /// + CAction(ADDON_ACTION actionID, const std::string& name) + : m_id(actionID), + m_name(name) + { + } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Constructor about joystick analog signals. + /// + /// @param[in] actionID ID to use, see @ref ADDON_ACTION about possible values + /// @param[in] amount1 + /// @param[in] amount2 + /// @param[in] name ]optional] Action name to set + /// @param[in] holdTime ]optional] Time how long the key was pressed + /// + CAction(ADDON_ACTION actionID, + float amount1 = 1.0f, + float amount2 = 0.0f, + const std::string& name = "", + unsigned int holdTime = 0) + : m_id(actionID), + m_name(name), + m_holdTime(holdTime) + { + m_amount[0] = amount1; + m_amount[1] = amount2; + } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Constructor about joystick analog signals. + /// + /// @param[in] actionID ID to use, see @ref ADDON_ACTION about possible values + /// @param[in] state + /// @param[in] posX + /// @param[in] posY + /// @param[in] offsetX + /// @param[in] offsetY + /// @param[in] posX + /// @param[in] velocityX + /// @param[in] velocityY + /// @param[in] name ]optional] Action name to set + /// + CAction(ADDON_ACTION actionID, + unsigned int state, + float posX, + float posY, + float offsetX, + float offsetY, + float velocityX = 0.0f, + float velocityY = 0.0f, + const std::string& name = "") + : m_id(actionID), + m_name(name), + m_holdTime(state) + { + m_amount[0] = posX; + m_amount[1] = posY; + m_amount[2] = offsetX; + m_amount[3] = offsetY; + m_amount[4] = velocityX; + m_amount[5] = velocityY; + } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Clone constructor. + /// + CAction(const CAction& other) { *this = other; } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Copy class to another. + /// + /// + CAction& operator=(const CAction& rhs) + { + if (this != &rhs) + { + m_id = rhs.m_id; + for (unsigned int i = 0; i < ADDON_ACTION_AMOUNT_MAX; i++) + m_amount[i] = rhs.m_amount[i]; + m_name = rhs.m_name; + m_repeat = rhs.m_repeat; + m_buttonCode = rhs.m_buttonCode; + m_unicode = rhs.m_unicode; + m_holdTime = rhs.m_holdTime; + m_text = rhs.m_text; + } + return *this; + } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Identifier of the action. + /// + /// @return id of the action + /// + ADDON_ACTION GetID() const { return m_id; } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Is this an action from the mouse. + /// + /// @return true if this is a mouse action, false otherwise + /// + bool IsMouse() const + { + return (m_id >= ADDON_ACTION_MOUSE_START && m_id <= ADDON_ACTION_MOUSE_END); + } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Check action is gesture signal. + /// + /// @return True if gesture, false otherwise + /// + bool IsGesture() const + { + return (m_id >= ADDON_ACTION_GESTURE_NOTIFY && m_id <= ADDON_ACTION_GESTURE_END); + } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Check action is analog signal. + /// + /// @return True if analog, false otherwise + /// + bool IsAnalog() const + { + switch (m_id) + { + case ADDON_ACTION_ANALOG_SEEK_FORWARD: + case ADDON_ACTION_ANALOG_SEEK_BACK: + case ADDON_ACTION_SCROLL_UP: + case ADDON_ACTION_SCROLL_DOWN: + case ADDON_ACTION_ANALOG_FORWARD: + case ADDON_ACTION_ANALOG_REWIND: + case ADDON_ACTION_ANALOG_MOVE: + case ADDON_ACTION_ANALOG_MOVE_X_LEFT: + case ADDON_ACTION_ANALOG_MOVE_X_RIGHT: + case ADDON_ACTION_ANALOG_MOVE_Y_UP: + case ADDON_ACTION_ANALOG_MOVE_Y_DOWN: + case ADDON_ACTION_CURSOR_LEFT: + case ADDON_ACTION_CURSOR_RIGHT: + case ADDON_ACTION_VOLUME_UP: + case ADDON_ACTION_VOLUME_DOWN: + case ADDON_ACTION_ZOOM_IN: + case ADDON_ACTION_ZOOM_OUT: + return true; + default: + return false; + } + } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Human-readable name of the action. + /// + /// @return name of the action + /// + const std::string& GetName() const { return m_name; } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Text of the action if any. + /// + /// @return text payload of this action. + /// + const std::string& GetText() const { return m_text; } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Set the text payload of the action. + /// + /// @param text to be set + /// + void SetText(const std::string& text) { m_text = text; } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Get an amount associated with this action. + /// + /// @param[in] index [optional] index of amount to retrieve, defaults to 0 + /// @return an amount associated with this action + /// + float GetAmount(unsigned int index = 0) const + { + return (index < ADDON_ACTION_AMOUNT_MAX) ? m_amount[index] : 0; + } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Reset all amount values to zero. + /// + void ClearAmount() + { + for (float& amount : m_amount) + amount = 0; + } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Unicode value associated with this action. + /// + /// @return unicode value associated with this action, for keyboard input. + /// + wchar_t GetUnicode() const { return m_unicode; } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Time in ms that the key has been held. + /// + /// @return time that the key has been held down in ms. + /// + unsigned int GetHoldTime() const { return m_holdTime; } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Time since last repeat in ms. + /// + /// @return time since last repeat in ms. Returns 0 if unknown. + /// + float GetRepeat() const { return m_repeat; } + //---------------------------------------------------------------------------- + + //============================================================================ + /// @brief Button code that triggered this action. + /// + /// @return button code + /// + unsigned int GetButtonCode() const { return m_buttonCode; } + //---------------------------------------------------------------------------- + +private: + friend class kodi::gui::CWindow; + friend class kodi::addon::CInstanceWeb; + + CAction(const KODI_ADDON_ACTION_DATA* addonData) + { + if (!addonData) + return; + + m_id = addonData->id; + m_name = addonData->name; + m_repeat = addonData->repeat; + m_holdTime = addonData->hold_time; + m_buttonCode = addonData->button_code; + m_unicode = addonData->unicode; + m_text = addonData->text; + for (unsigned int i = 0; i < ADDON_ACTION_AMOUNT_MAX; ++i) + m_amount[i] = addonData->amount[i]; + } + + ADDON_ACTION m_id = ADDON_ACTION_NONE; + std::string m_name; + + float m_amount[ADDON_ACTION_AMOUNT_MAX] = {}; + + float m_repeat = 0.0f; + unsigned int m_holdTime = 0; + unsigned int m_buttonCode = 0; + wchar_t m_unicode = 0; + std::string m_text; +}; +///@} + +} /* namespace input */ +} /* namespace gui */ +} /* namespace kodi */ + +#endif /* __cplusplus */ diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/input/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/include/kodi/gui/input/CMakeLists.txt index 769cad2456942..bf94a4779f9e9 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/input/CMakeLists.txt +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/input/CMakeLists.txt @@ -2,6 +2,7 @@ # See xbmc/addons/kodi-dev-kit/tools/code-generator.py. set(HEADERS + Action.h ActionIDs.h ) diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/gui/renderHelper.h b/xbmc/addons/kodi-dev-kit/include/kodi/gui/renderHelper.h index f369205e86ad9..ba17b5583d6a9 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/gui/renderHelper.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/gui/renderHelper.h @@ -64,14 +64,14 @@ namespace gui inline std::shared_ptr ATTR_DLL_LOCAL GetRenderHelper() { using namespace ::kodi::addon; - if (static_cast(CPrivateBase::m_interface->addonBase)->m_renderHelper) - return static_cast(CPrivateBase::m_interface->addonBase)->m_renderHelper; + if (kodi::dl::local.addonBase->m_renderHelper) + return kodi::dl::local.addonBase->m_renderHelper; std::shared_ptr renderHelper(new CRenderHelper()); if (!renderHelper->Init()) return nullptr; - static_cast(CPrivateBase::m_interface->addonBase)->m_renderHelper = + kodi::dl::local.addonBase->m_renderHelper = renderHelper; // Hold on base for other types return renderHelper; } diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/tools/DllHelper.h b/xbmc/addons/kodi-dev-kit/include/kodi/tools/DllHelper.h index 2003171f324a3..bb34400bd1941 100644 --- a/xbmc/addons/kodi-dev-kit/include/kodi/tools/DllHelper.h +++ b/xbmc/addons/kodi-dev-kit/include/kodi/tools/DllHelper.h @@ -10,11 +10,13 @@ #ifdef __cplusplus +#include "../AddonBase.h" +#include "../Filesystem.h" +#include "../General.h" + #include #include -#include -#include //============================================================================== /// @ingroup cpp_kodi_tools_CDllHelper diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/versions.h b/xbmc/addons/kodi-dev-kit/include/kodi/versions.h deleted file mode 100644 index bbfad40f4f548..0000000000000 --- a/xbmc/addons/kodi-dev-kit/include/kodi/versions.h +++ /dev/null @@ -1,517 +0,0 @@ -/* - * Copyright (C) 2016-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -#pragma once - -#ifndef KODI_VERSIONS_H -#define KODI_VERSIONS_H - -#include - -#define STR_HELPER(x) #x -#define STR(x) STR_HELPER(x) - -/* - *------------------------------------------------------------------------------ - * Some parts on headers are only be used for Kodi itself and internally (not - * for add-on development). - * - * For this reason also no doxygen part with "///" defined there. - * ----------------------------------------------------------------------------- - */ - -/* - * Versions of all add-on globals and instances are defined below. - * - * This is added here and not in related header to prevent not - * needed includes during compile. Also have it here a better - * overview. - */ - -// Ignore clang here, as this must be good in overview and as the main reason, -// because cmake uses this area in this form to perform its addon dependency -// check. -// clang-format off -#define ADDON_GLOBAL_VERSION_MAIN "2.0.1" -#define ADDON_GLOBAL_VERSION_MAIN_MIN "2.0.0" -#define ADDON_GLOBAL_VERSION_MAIN_XML_ID "kodi.binary.global.main" -#define ADDON_GLOBAL_VERSION_MAIN_DEPENDS "AddonBase.h" \ - "addon-instance/" \ - "c-api/addon_base.h" - -#define ADDON_GLOBAL_VERSION_GENERAL "1.0.5" -#define ADDON_GLOBAL_VERSION_GENERAL_MIN "1.0.4" -#define ADDON_GLOBAL_VERSION_GENERAL_XML_ID "kodi.binary.global.general" -#define ADDON_GLOBAL_VERSION_GENERAL_DEPENDS "General.h" - -#define ADDON_GLOBAL_VERSION_GUI "5.15.0" -#define ADDON_GLOBAL_VERSION_GUI_MIN "5.15.0" -#define ADDON_GLOBAL_VERSION_GUI_XML_ID "kodi.binary.global.gui" -#define ADDON_GLOBAL_VERSION_GUI_DEPENDS "c-api/gui/input/action_ids.h" \ - "c-api/gui/" \ - "gui/" - -#define ADDON_GLOBAL_VERSION_AUDIOENGINE "1.1.1" -#define ADDON_GLOBAL_VERSION_AUDIOENGINE_MIN "1.1.0" -#define ADDON_GLOBAL_VERSION_AUDIOENGINE_XML_ID "kodi.binary.global.audioengine" -#define ADDON_GLOBAL_VERSION_AUDIOENGINE_DEPENDS "AudioEngine.h" \ - "c-api/audio_engine.h" - -#define ADDON_GLOBAL_VERSION_FILESYSTEM "1.1.7" -#define ADDON_GLOBAL_VERSION_FILESYSTEM_MIN "1.1.7" -#define ADDON_GLOBAL_VERSION_FILESYSTEM_XML_ID "kodi.binary.global.filesystem" -#define ADDON_GLOBAL_VERSION_FILESYSTEM_DEPENDS "Filesystem.h" \ - "c-api/filesystem.h" \ - "gui/gl/Shader.h" \ - "tools/DllHelper.h" - -#define ADDON_GLOBAL_VERSION_NETWORK "1.0.4" -#define ADDON_GLOBAL_VERSION_NETWORK_MIN "1.0.0" -#define ADDON_GLOBAL_VERSION_NETWORK_XML_ID "kodi.binary.global.network" -#define ADDON_GLOBAL_VERSION_NETWORK_DEPENDS "Network.h" \ - "c-api/network.h" - -#define ADDON_GLOBAL_VERSION_TOOLS "1.0.4" -#define ADDON_GLOBAL_VERSION_TOOLS_MIN "1.0.0" -#define ADDON_GLOBAL_VERSION_TOOLS_XML_ID "kodi.binary.global.tools" -#define ADDON_GLOBAL_VERSION_TOOLS_DEPENDS "tools/DllHelper.h" \ - "tools/EndTime.h" \ - "tools/StringUtils.h" \ - "tools/Thread.h" \ - "tools/Timer.h" - -#define ADDON_INSTANCE_VERSION_AUDIODECODER "4.0.0" -#define ADDON_INSTANCE_VERSION_AUDIODECODER_MIN "4.0.0" -#define ADDON_INSTANCE_VERSION_AUDIODECODER_XML_ID "kodi.binary.instance.audiodecoder" -#define ADDON_INSTANCE_VERSION_AUDIODECODER_DEPENDS "c-api/addon-instance/audiodecoder.h" \ - "addon-instance/AudioDecoder.h" - -#define ADDON_INSTANCE_VERSION_AUDIOENCODER "3.0.0" -#define ADDON_INSTANCE_VERSION_AUDIOENCODER_MIN "3.0.0" -#define ADDON_INSTANCE_VERSION_AUDIOENCODER_XML_ID "kodi.binary.instance.audioencoder" -#define ADDON_INSTANCE_VERSION_AUDIOENCODER_DEPENDS "c-api/addon-instance/audioencoder.h" \ - "addon-instance/AudioEncoder.h" - -#define ADDON_INSTANCE_VERSION_GAME "3.0.0" -#define ADDON_INSTANCE_VERSION_GAME_MIN "3.0.0" -#define ADDON_INSTANCE_VERSION_GAME_XML_ID "kodi.binary.instance.game" -#define ADDON_INSTANCE_VERSION_GAME_DEPENDS "addon-instance/Game.h" - -#define ADDON_INSTANCE_VERSION_IMAGEDECODER "3.0.0" -#define ADDON_INSTANCE_VERSION_IMAGEDECODER_MIN "3.0.0" -#define ADDON_INSTANCE_VERSION_IMAGEDECODER_XML_ID "kodi.binary.instance.imagedecoder" -#define ADDON_INSTANCE_VERSION_IMAGEDECODER_DEPENDS "c-api/addon-instance/imagedecoder.h" \ - "addon-instance/ImageDecoder.h" - -#define ADDON_INSTANCE_VERSION_INPUTSTREAM "3.1.0" -#define ADDON_INSTANCE_VERSION_INPUTSTREAM_MIN "3.1.0" -#define ADDON_INSTANCE_VERSION_INPUTSTREAM_XML_ID "kodi.binary.instance.inputstream" -#define ADDON_INSTANCE_VERSION_INPUTSTREAM_DEPENDS "c-api/addon-instance/inputstream.h" \ - "c-api/addon-instance/inputstream/demux_packet.h" \ - "c-api/addon-instance/inputstream/stream_codec.h" \ - "c-api/addon-instance/inputstream/stream_constants.h" \ - "c-api/addon-instance/inputstream/stream_crypto.h" \ - "c-api/addon-instance/inputstream/timing_constants.h" \ - "addon-instance/Inputstream.h" \ - "addon-instance/inputstream/DemuxPacket.h" \ - "addon-instance/inputstream/StreamCodec.h" \ - "addon-instance/inputstream/StreamConstants.h" \ - "addon-instance/inputstream/StreamCrypto.h" \ - "addon-instance/inputstream/TimingConstants.h" - -#define ADDON_INSTANCE_VERSION_PERIPHERAL "2.0.0" -#define ADDON_INSTANCE_VERSION_PERIPHERAL_MIN "2.0.0" -#define ADDON_INSTANCE_VERSION_PERIPHERAL_XML_ID "kodi.binary.instance.peripheral" -#define ADDON_INSTANCE_VERSION_PERIPHERAL_DEPENDS "addon-instance/Peripheral.h" \ - "addon-instance/PeripheralUtils.h" - -#define ADDON_INSTANCE_VERSION_PVR "8.1.0" -#define ADDON_INSTANCE_VERSION_PVR_MIN "8.0.0" -#define ADDON_INSTANCE_VERSION_PVR_XML_ID "kodi.binary.instance.pvr" -#define ADDON_INSTANCE_VERSION_PVR_DEPENDS "c-api/addon-instance/pvr.h" \ - "c-api/addon-instance/pvr/pvr_providers.h" \ - "c-api/addon-instance/pvr/pvr_channel_groups.h" \ - "c-api/addon-instance/pvr/pvr_channels.h" \ - "c-api/addon-instance/pvr/pvr_defines.h" \ - "c-api/addon-instance/pvr/pvr_edl.h" \ - "c-api/addon-instance/pvr/pvr_epg.h" \ - "c-api/addon-instance/pvr/pvr_general.h" \ - "c-api/addon-instance/pvr/pvr_menu_hook.h" \ - "c-api/addon-instance/pvr/pvr_recordings.h" \ - "c-api/addon-instance/pvr/pvr_stream.h" \ - "c-api/addon-instance/pvr/pvr_timers.h" \ - "addon-instance/PVR.h" \ - "addon-instance/pvr/ChannelGroups.h" \ - "addon-instance/pvr/Channels.h" \ - "addon-instance/pvr/EDL.h" \ - "addon-instance/pvr/EPG.h" \ - "addon-instance/pvr/General.h" \ - "addon-instance/pvr/MenuHook.h" \ - "addon-instance/pvr/Recordings.h" \ - "addon-instance/pvr/Stream.h" \ - "addon-instance/pvr/Timers.h" - -#define ADDON_INSTANCE_VERSION_SCREENSAVER "2.2.0" -#define ADDON_INSTANCE_VERSION_SCREENSAVER_MIN "2.2.0" -#define ADDON_INSTANCE_VERSION_SCREENSAVER_XML_ID "kodi.binary.instance.screensaver" -#define ADDON_INSTANCE_VERSION_SCREENSAVER_DEPENDS "c-api/addon-instance/screensaver.h" \ - "addon-instance/Screensaver.h" - -#define ADDON_INSTANCE_VERSION_VFS "3.0.1" -#define ADDON_INSTANCE_VERSION_VFS_MIN "3.0.1" -#define ADDON_INSTANCE_VERSION_VFS_XML_ID "kodi.binary.instance.vfs" -#define ADDON_INSTANCE_VERSION_VFS_DEPENDS "c-api/addon-instance/vfs.h" \ - "addon-instance/VFS.h" - -#define ADDON_INSTANCE_VERSION_VISUALIZATION "3.0.0" -#define ADDON_INSTANCE_VERSION_VISUALIZATION_MIN "3.0.0" -#define ADDON_INSTANCE_VERSION_VISUALIZATION_XML_ID "kodi.binary.instance.visualization" -#define ADDON_INSTANCE_VERSION_VISUALIZATION_DEPENDS "addon-instance/Visualization.h" \ - "c-api/addon-instance/visualization.h" - -#define ADDON_INSTANCE_VERSION_VIDEOCODEC "2.0.2" -#define ADDON_INSTANCE_VERSION_VIDEOCODEC_MIN "2.0.1" -#define ADDON_INSTANCE_VERSION_VIDEOCODEC_XML_ID "kodi.binary.instance.videocodec" -#define ADDON_INSTANCE_VERSION_VIDEOCODEC_DEPENDS "c-api/addon-instance/video_codec.h" \ - "c-api/addon-instance/inputstream/stream_codec.h" \ - "c-api/addon-instance/inputstream/stream_crypto.h" \ - "addon-instance/VideoCodec.h" \ - "addon-instance/inputstream/StreamCodec.h" \ - "addon-instance/inputstream/StreamCrypto.h" \ -// clang-format on - -//============================================================================== -/// @ingroup cpp_kodi_addon_addonbase_Defs -/// @defgroup cpp_kodi_addon_addonbase_Defs_ADDON_TYPE enum ADDON_TYPE -/// **The currently available instance types for Kodi add-ons**\n -/// This identifies the associated API part on the interface in Kodi and in the -/// addon. -/// -/// \internal -/// @note For add of new types take a new number on end. To change -/// existing numbers can be make problems on already compiled add-ons. -/// \endinternal -/// -///@{ -typedef enum ADDON_TYPE -{ - /* addon global parts */ - ADDON_GLOBAL_MAIN = 0, - ADDON_GLOBAL_GUI = 1, - ADDON_GLOBAL_AUDIOENGINE = 2, - ADDON_GLOBAL_GENERAL = 3, - ADDON_GLOBAL_NETWORK = 4, - ADDON_GLOBAL_FILESYSTEM = 5, - ADDON_GLOBAL_TOOLS = 6, - // Last used global id, used in loops to check versions. - // Need to change if new global type becomes added! - ADDON_GLOBAL_MAX = 6, - - /* addon type instances */ - - /// Audio decoder instance, see @ref cpp_kodi_addon_audiodecoder "kodi::addon::CInstanceAudioDecoder" - ADDON_INSTANCE_AUDIODECODER = 102, - - /// Audio encoder instance, see @ref cpp_kodi_addon_audioencoder "kodi::addon::CInstanceAudioEncoder" - ADDON_INSTANCE_AUDIOENCODER = 103, - - /// Game instance, see @ref cpp_kodi_addon_game "kodi::addon::CInstanceGame" - ADDON_INSTANCE_GAME = 104, - - /// Input stream instance, see @ref cpp_kodi_addon_inputstream "kodi::addon::CInstanceInputStream" - ADDON_INSTANCE_INPUTSTREAM = 105, - - /// Peripheral instance, see @ref cpp_kodi_addon_peripheral "kodi::addon::CInstancePeripheral" - ADDON_INSTANCE_PERIPHERAL = 106, - - /// Game instance, see @ref cpp_kodi_addon_pvr "kodi::addon::CInstancePVRClient" - ADDON_INSTANCE_PVR = 107, - - /// PVR client instance, see @ref cpp_kodi_addon_screensaver "kodi::addon::CInstanceScreensaver" - ADDON_INSTANCE_SCREENSAVER = 108, - - /// Music visualization instance, see @ref cpp_kodi_addon_visualization "kodi::addon::CInstanceVisualization" - ADDON_INSTANCE_VISUALIZATION = 109, - - /// Virtual Filesystem (VFS) instance, see @ref cpp_kodi_addon_vfs "kodi::addon::CInstanceVFS" - ADDON_INSTANCE_VFS = 110, - - /// Image Decoder instance, see @ref cpp_kodi_addon_imagedecoder "kodi::addon::CInstanceImageDecoder" - ADDON_INSTANCE_IMAGEDECODER = 111, - - /// Video Decoder instance, see @ref cpp_kodi_addon_videocodec "kodi::addon::CInstanceVideoCodec" - ADDON_INSTANCE_VIDEOCODEC = 112, -} ADDON_TYPE; -///@} -//------------------------------------------------------------------------------ - -#ifdef __cplusplus -extern "C" { -namespace kodi { -namespace addon { -#endif - -/// -/// This is used from Kodi to get the active version of add-on parts. -/// It is compiled in add-on and also in Kodi itself, with this can be Kodi -/// compare the version from him with them on add-on. -/// -/// @param[in] type The with 'enum ADDON_TYPE' type to ask -/// @return version The current version of asked type -/// -inline const char* GetTypeVersion(int type) -{ - /* - * #ifdef's below becomes set by cmake, no set by hand needed. - */ - switch (type) - { - /* addon global parts */ - case ADDON_GLOBAL_MAIN: - return ADDON_GLOBAL_VERSION_MAIN; -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_GLOBAL_VERSION_GENERAL_USED) - case ADDON_GLOBAL_GENERAL: - return ADDON_GLOBAL_VERSION_GENERAL; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_GLOBAL_VERSION_GUI_USED) - case ADDON_GLOBAL_GUI: - return ADDON_GLOBAL_VERSION_GUI; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_GLOBAL_VERSION_AUDIOENGINE_USED) - case ADDON_GLOBAL_AUDIOENGINE: - return ADDON_GLOBAL_VERSION_AUDIOENGINE; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_GLOBAL_VERSION_FILESYSTEM_USED) - case ADDON_GLOBAL_FILESYSTEM: - return ADDON_GLOBAL_VERSION_FILESYSTEM; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_GLOBAL_VERSION_NETWORK_USED) - case ADDON_GLOBAL_NETWORK: - return ADDON_GLOBAL_VERSION_NETWORK; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_GLOBAL_VERSION_TOOLS_USED) - case ADDON_GLOBAL_TOOLS: - return ADDON_GLOBAL_VERSION_TOOLS; -#endif - - /* addon type instances */ -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_AUDIODECODER_USED) - case ADDON_INSTANCE_AUDIODECODER: - return ADDON_INSTANCE_VERSION_AUDIODECODER; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_AUDIOENCODER_USED) - case ADDON_INSTANCE_AUDIOENCODER: - return ADDON_INSTANCE_VERSION_AUDIOENCODER; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_GAME_USED) - case ADDON_INSTANCE_GAME: - return ADDON_INSTANCE_VERSION_GAME; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_IMAGEDECODER_USED) - case ADDON_INSTANCE_IMAGEDECODER: - return ADDON_INSTANCE_VERSION_IMAGEDECODER; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_INPUTSTREAM_USED) - case ADDON_INSTANCE_INPUTSTREAM: - return ADDON_INSTANCE_VERSION_INPUTSTREAM; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_PERIPHERAL_USED) - case ADDON_INSTANCE_PERIPHERAL: - return ADDON_INSTANCE_VERSION_PERIPHERAL; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_PVR_USED) - case ADDON_INSTANCE_PVR: - return ADDON_INSTANCE_VERSION_PVR; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_SCREENSAVER_USED) - case ADDON_INSTANCE_SCREENSAVER: - return ADDON_INSTANCE_VERSION_SCREENSAVER; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_VFS_USED) - case ADDON_INSTANCE_VFS: - return ADDON_INSTANCE_VERSION_VFS; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_VISUALIZATION_USED) - case ADDON_INSTANCE_VISUALIZATION: - return ADDON_INSTANCE_VERSION_VISUALIZATION; -#endif -#if !defined(BUILD_KODI_ADDON) || defined(ADDON_INSTANCE_VERSION_VIDEOCODEC_USED) - case ADDON_INSTANCE_VIDEOCODEC: - return ADDON_INSTANCE_VERSION_VIDEOCODEC; -#endif - } - return "0.0.0"; -} - -/// -/// This is used from Kodi to get the minimum supported version of add-on parts. -/// It is compiled in add-on and also in Kodi itself, with this can be Kodi -/// compare the version from him with them on add-on. -/// -/// @param[in] type The with 'enum ADDON_TYPE' type to ask -/// @return version The minimum version of asked type -/// -inline const char* GetTypeMinVersion(int type) -{ - switch (type) - { - /* addon global parts */ - case ADDON_GLOBAL_MAIN: - return ADDON_GLOBAL_VERSION_MAIN_MIN; - case ADDON_GLOBAL_GUI: - return ADDON_GLOBAL_VERSION_GUI_MIN; - case ADDON_GLOBAL_GENERAL: - return ADDON_GLOBAL_VERSION_GENERAL_MIN; - case ADDON_GLOBAL_AUDIOENGINE: - return ADDON_GLOBAL_VERSION_AUDIOENGINE_MIN; - case ADDON_GLOBAL_FILESYSTEM: - return ADDON_GLOBAL_VERSION_FILESYSTEM_MIN; - case ADDON_GLOBAL_NETWORK: - return ADDON_GLOBAL_VERSION_NETWORK_MIN; - case ADDON_GLOBAL_TOOLS: - return ADDON_GLOBAL_VERSION_TOOLS_MIN; - - /* addon type instances */ - case ADDON_INSTANCE_AUDIODECODER: - return ADDON_INSTANCE_VERSION_AUDIODECODER_MIN; - case ADDON_INSTANCE_AUDIOENCODER: - return ADDON_INSTANCE_VERSION_AUDIOENCODER_MIN; - case ADDON_INSTANCE_GAME: - return ADDON_INSTANCE_VERSION_GAME_MIN; - case ADDON_INSTANCE_IMAGEDECODER: - return ADDON_INSTANCE_VERSION_IMAGEDECODER_MIN; - case ADDON_INSTANCE_INPUTSTREAM: - return ADDON_INSTANCE_VERSION_INPUTSTREAM_MIN; - case ADDON_INSTANCE_PERIPHERAL: - return ADDON_INSTANCE_VERSION_PERIPHERAL_MIN; - case ADDON_INSTANCE_PVR: - return ADDON_INSTANCE_VERSION_PVR_MIN; - case ADDON_INSTANCE_SCREENSAVER: - return ADDON_INSTANCE_VERSION_SCREENSAVER_MIN; - case ADDON_INSTANCE_VFS: - return ADDON_INSTANCE_VERSION_VFS_MIN; - case ADDON_INSTANCE_VISUALIZATION: - return ADDON_INSTANCE_VERSION_VISUALIZATION_MIN; - case ADDON_INSTANCE_VIDEOCODEC: - return ADDON_INSTANCE_VERSION_VIDEOCODEC_MIN; - } - return "0.0.0"; -} - -/// -/// Function used internally on add-on and in Kodi itself to get name -/// about given type. -/// -/// @param[in] type The with 'enum ADDON_TYPE' defined type to ask -/// @return Name of the asked instance type -/// -inline const char* GetTypeName(int type) -{ - switch (type) - { - /* addon global parts */ - case ADDON_GLOBAL_MAIN: - return "Addon"; - case ADDON_GLOBAL_GUI: - return "GUI"; - case ADDON_GLOBAL_GENERAL: - return "General"; - case ADDON_GLOBAL_AUDIOENGINE: - return "AudioEngine"; - case ADDON_GLOBAL_FILESYSTEM: - return "Filesystem"; - case ADDON_GLOBAL_NETWORK: - return "Network"; - case ADDON_GLOBAL_TOOLS: - return "Tools"; - - /* addon type instances */ - case ADDON_INSTANCE_AUDIODECODER: - return "AudioDecoder"; - case ADDON_INSTANCE_AUDIOENCODER: - return "AudioEncoder"; - case ADDON_INSTANCE_GAME: - return "Game"; - case ADDON_INSTANCE_IMAGEDECODER: - return "ImageDecoder"; - case ADDON_INSTANCE_INPUTSTREAM: - return "Inputstream"; - case ADDON_INSTANCE_PERIPHERAL: - return "Peripheral"; - case ADDON_INSTANCE_PVR: - return "PVR"; - case ADDON_INSTANCE_SCREENSAVER: - return "ScreenSaver"; - case ADDON_INSTANCE_VISUALIZATION: - return "Visualization"; - case ADDON_INSTANCE_VIDEOCODEC: - return "VideoCodec"; - } - return "unknown"; -} - -/// -/// Function used internally on add-on and in Kodi itself to get id number -/// about given type name. -/// -/// @param[in] name The type name string to ask -/// @return Id number of the asked instance type -/// -/// @warning String must be lower case here! -/// -inline int GetTypeId(const char* name) -{ - if (name) - { - if (strcmp(name, "addon") == 0) - return ADDON_GLOBAL_MAIN; - else if (strcmp(name, "general") == 0) - return ADDON_GLOBAL_GENERAL; - else if (strcmp(name, "gui") == 0) - return ADDON_GLOBAL_GUI; - else if (strcmp(name, "audioengine") == 0) - return ADDON_GLOBAL_AUDIOENGINE; - else if (strcmp(name, "filesystem") == 0) - return ADDON_GLOBAL_FILESYSTEM; - else if (strcmp(name, "network") == 0) - return ADDON_GLOBAL_NETWORK; - else if (strcmp(name, "tools") == 0) - return ADDON_GLOBAL_TOOLS; - else if (strcmp(name, "audiodecoder") == 0) - return ADDON_INSTANCE_AUDIODECODER; - else if (strcmp(name, "audioencoder") == 0) - return ADDON_INSTANCE_AUDIOENCODER; - else if (strcmp(name, "game") == 0) - return ADDON_INSTANCE_GAME; - else if (strcmp(name, "imagedecoder") == 0) - return ADDON_INSTANCE_IMAGEDECODER; - else if (strcmp(name, "inputstream") == 0) - return ADDON_INSTANCE_INPUTSTREAM; - else if (strcmp(name, "peripheral") == 0) - return ADDON_INSTANCE_PERIPHERAL; - else if (strcmp(name, "pvr") == 0) - return ADDON_INSTANCE_PVR; - else if (strcmp(name, "screensaver") == 0) - return ADDON_INSTANCE_SCREENSAVER; - else if (strcmp(name, "vfs") == 0) - return ADDON_INSTANCE_VFS; - else if (strcmp(name, "visualization") == 0) - return ADDON_INSTANCE_VISUALIZATION; - else if (strcmp(name, "videocodec") == 0) - return ADDON_INSTANCE_VIDEOCODEC; - } - return -1; -} - -#ifdef __cplusplus -} /* namespace addon */ -} /* namespace kodi */ -} /* extern "C" */ -#endif - -#endif /* !KODI_VERSIONS_H */ diff --git a/xbmc/addons/kodi-dev-kit/src/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/CMakeLists.txt new file mode 100644 index 0000000000000..74c6492a1f6c0 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/CMakeLists.txt @@ -0,0 +1,2 @@ +add_subdirectory(shared) + diff --git a/xbmc/addons/kodi-dev-kit/src/addon/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/CMakeLists.txt new file mode 100644 index 0000000000000..df050db6a3a53 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/CMakeLists.txt @@ -0,0 +1,98 @@ +# Addon helper library generator to allow operation between him and Kodi +# +# WARNING: This CMakeLists.txt is not complete autogenerated and need edited by +# hand. +# +project(kodidevkit) + +include(../../cmake/Macros.cmake) + +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}) + +include_directories(${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/../..) + +message(STATUS "kodidevkit Version: ${__KDK_MAJOR__}.${__KDK_MINOR__}.${__KDK_BETA__}") + +if(APP_RENDER_SYSTEM STREQUAL "gl" OR NOT APP_RENDER_SYSTEM) + find_package(OpenGl REQUIRED) + find_package(EGL REQUIRED) + set(${PROJECT_NAME}_DEPLIBS ${OPENGL_LIBRARIES} ${EGL_LIBRARIES}) + set(${PROJECT_NAME}_INCLUDES ${OPENGL_INCLUDE_DIR} ${EGL_INCLUDE_DIR}) + set(${PROJECT_NAME}_DEFINITIONS ${OPENGL_DEFINITIONS}) +else() + find_package(OpenGLES REQUIRED) + set(${PROJECT_NAME}_DEPLIBS ${OPENGLES_LIBRARIES}) + set(${PROJECT_NAME}_INCLUDES ${OPENGLES_INCLUDE_DIR}) + set(${PROJECT_NAME}_DEFINITIONS ${OPENGLES_DEFINITIONS}) +endif() + +#---AUTO_GEN_PARSE--- +add_subdirectory(api) +add_subdirectory(api/addon-instance) +add_subdirectory(api/dl) +add_subdirectory(api/gui) +add_subdirectory(api/gui/controls) +add_subdirectory(api/gui/dialogs) +add_subdirectory(core) +add_subdirectory(third_party/backward-cpp) +#---AUTO_GEN_PARSE--- + +cmake_parse_arguments(arg "WRAPPED" "DEVKIT_OUTPUT_DIRECTORY" "" ${ARGN}) +if(arg_DEVKIT_OUTPUT_DIRECTORY) + set(DEVKIT_OUTPUT_DIRECTORY ${arg_DEVKIT_OUTPUT_DIRECTORY}) +else() + set(DEVKIT_OUTPUT_DIRECTORY "addons/kodi.binary.devkit") +endif() + +if(CORE_SYSTEM_NAME STREQUAL windows) + set(OUTPUT_NAME ${CMAKE_SHARED_LIBRARY_PREFIX}${PROJECT_NAME}) +else() + set(OUTPUT_NAME ${CMAKE_SHARED_LIBRARY_PREFIX}${PROJECT_NAME}-${ARCH}) +endif() + +set(DEVKIT_LIBRARY ${OUTPUT_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX} CACHE STRING "Library used for dev-kit") + +add_library(${PROJECT_NAME} SHARED ${DEV_KIT_HEADER} + ${DEVKIT_OBJECTS} + $ + $) +add_backward(${PROJECT_NAME}) +target_compile_definitions(${PROJECT_NAME} PRIVATE ${BACKWARD_DEFINITIONS} ${${PROJECT_NAME}_DEFINITIONS}) +set_target_properties(${PROJECT_NAME} PROPERTIES C_VISIBILITY_PRESET hidden + CXX_VISIBILITY_PRESET hidden + VISIBILITY_INLINES_HIDDEN ON + POSITION_INDEPENDENT_CODE ON + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY} + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY} + OUTPUT_NAME ${OUTPUT_NAME} PREFIX "") +target_include_directories(${PROJECT_NAME} PRIVATE ${${PROJECT_NAME}_INCLUDES}) +foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES}) + string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG) + set_target_properties(${name} PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY} + RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY}) +endforeach() + +if(CORE_SYSTEM_NAME STREQUAL android) + message(FATAL_ERROR "OS currently not supported and in TODO!!!") +elseif(CORE_SYSTEM_NAME STREQUAL darwin_embedded) + add_definitions(-DKODI_INHIBIT_SHARED) + message(FATAL_ERROR "OS currently not supported and in TODO!!!") +elseif(CORE_SYSTEM_NAME STREQUAL freebsd) + message(FATAL_ERROR "OS currently not supported and in TODO!!!") +elseif(CORE_SYSTEM_NAME STREQUAL linux) + target_link_libraries(${PROJECT_NAME} PRIVATE -static-libgcc -static-libstdc++ m c rt pthread ${${PROJECT_NAME}_DEPLIBS} dw) + #target_link_libraries(${PROJECT_NAME} PUBLIC stdc++ gcc pthread m c rt ) + + # Remove as splitted dwarf not works currently in included "backward-cpp" and further should on + # user installed add-ons some debug infos available. + remove_flag_from_target(${PROJECT_NAME} -gsplit-dwarf) +elseif(CORE_SYSTEM_NAME STREQUAL osx) + message(FATAL_ERROR "OS currently not supported and in TODO!!!") +elseif(CORE_SYSTEM_NAME STREQUAL windows) + message(FATAL_ERROR "OS currently not supported and in TODO!!!") +else() + message(FATAL_ERROR "Not supported OS '${CORE_SYSTEM_NAME}' used for kodi-dev-kit!") +endif() + +set(LIBRARY_FILES ${LIBRARY_FILES} ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY}/${OUTPUT_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX} CACHE STRING "" FORCE) diff --git a/xbmc/addons/kodi-dev-kit/src/addon/FindEGL.cmake b/xbmc/addons/kodi-dev-kit/src/addon/FindEGL.cmake new file mode 100644 index 0000000000000..b00fe08a25f95 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/FindEGL.cmake @@ -0,0 +1,48 @@ +#.rst: +# FindEGL +# ------- +# Finds the EGL library +# +# This will define the following variables:: +# +# EGL_FOUND - system has EGL +# EGL_INCLUDE_DIRS - the EGL include directory +# EGL_LIBRARIES - the EGL libraries +# EGL_DEFINITIONS - the EGL definitions +# +# and the following imported targets:: +# +# EGL::EGL - The EGL library + +if(PKG_CONFIG_FOUND) + pkg_check_modules(PC_EGL egl QUIET) +endif() + +find_path(EGL_INCLUDE_DIR EGL/egl.h + PATHS ${PC_EGL_INCLUDEDIR}) + +find_library(EGL_LIBRARY NAMES EGL egl + PATHS ${PC_EGL_LIBDIR}) + +set(EGL_VERSION ${PC_EGL_VERSION}) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(EGL + REQUIRED_VARS EGL_LIBRARY EGL_INCLUDE_DIR + VERSION_VAR EGL_VERSION) + +if(EGL_FOUND) + set(EGL_LIBRARIES ${EGL_LIBRARY}) + set(EGL_INCLUDE_DIRS ${EGL_INCLUDE_DIR}) + set(EGL_DEFINITIONS -DHAS_EGL=1) + + if(NOT TARGET EGL::EGL) + add_library(EGL::EGL UNKNOWN IMPORTED) + set_target_properties(EGL::EGL PROPERTIES + IMPORTED_LOCATION "${EGL_LIBRARY}" + INTERFACE_INCLUDE_DIRECTORIES "${EGL_INCLUDE_DIR}" + INTERFACE_COMPILE_DEFINITIONS HAS_EGL=1) + endif() +endif() + +mark_as_advanced(EGL_INCLUDE_DIR EGL_LIBRARY) diff --git a/xbmc/addons/kodi-dev-kit/src/addon/FindOpenGl.cmake b/xbmc/addons/kodi-dev-kit/src/addon/FindOpenGl.cmake new file mode 100644 index 0000000000000..616325083cb52 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/FindOpenGl.cmake @@ -0,0 +1,40 @@ +#.rst: +# FindOpenGl +# ---------- +# Finds the FindOpenGl library +# +# This will define the following variables:: +# +# OPENGL_FOUND - system has OpenGl +# OPENGL_INCLUDE_DIRS - the OpenGl include directory +# OPENGL_LIBRARIES - the OpenGl libraries +# OPENGL_DEFINITIONS - the OpenGl definitions + +if(PKG_CONFIG_FOUND) + pkg_check_modules(PC_OPENGL gl QUIET) +endif() + +if(NOT CORE_SYSTEM_NAME STREQUAL osx) + find_path(OPENGL_INCLUDE_DIR GL/gl.h + PATHS ${PC_OPENGL_gl_INCLUDEDIR}) + find_library(OPENGL_gl_LIBRARY NAMES GL + PATHS ${PC_OPENGL_gl_LIBDIR}) +else() + find_library(OPENGL_gl_LIBRARY NAMES OpenGL + PATHS ${CMAKE_OSX_SYSROOT}/System/Library + PATH_SUFFIXES Frameworks + NO_DEFAULT_PATH) + set(OPENGL_INCLUDE_DIR ${OPENGL_gl_LIBRARY}/Headers) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(OpenGl + REQUIRED_VARS OPENGL_gl_LIBRARY OPENGL_INCLUDE_DIR) +message(FATAL_ERROR "ffff ${DEPLIBS}") +if(OPENGL_FOUND) + set(OPENGL_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR}) + set(OPENGL_LIBRARIES ${OPENGL_gl_LIBRARY} EGL) + set(OPENGL_DEFINITIONS -DHAS_GL=1) +endif() + +mark_as_advanced(OPENGL_INCLUDE_DIR OPENGL_gl_LIBRARY) diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/api/CMakeLists.txt new file mode 100644 index 0000000000000..344ba50f72e90 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/CMakeLists.txt @@ -0,0 +1,24 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + addon_base.cpp + audio_engine.cpp + filesystem.cpp + general.cpp + monitor.cpp + network.cpp +) + +set(HEADERS + addon_base.h + audio_engine.h + filesystem.h + general.h + monitor.h + network.h +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_api) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/CMakeLists.txt new file mode 100644 index 0000000000000..6c0d50afe0c23 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/CMakeLists.txt @@ -0,0 +1,36 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + audiodecoder.cpp + audioencoder.cpp + game.cpp + imagedecoder.cpp + inputstream.cpp + peripheral.cpp + pvr.cpp + screensaver.cpp + vfs.cpp + videocodec.cpp + visualization.cpp + web.cpp +) + +set(HEADERS + audiodecoder.h + audioencoder.h + game.h + imagedecoder.h + inputstream.h + peripheral.h + pvr.h + screensaver.h + vfs.h + videocodec.h + visualization.h + web.h +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_api_addon-instance) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audiodecoder.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audiodecoder.cpp new file mode 100644 index 0000000000000..e1a4d3ed1bbfc --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audiodecoder.cpp @@ -0,0 +1,296 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "audiodecoder.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_audiodecoder_h::InitDirect( + directFuncToAddon_addoninstance_audiodecoder_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_audiodecoder_supports_file_v1 = kodi_addon_audiodecoder_supports_file_v1; + ifcToAddon->kodi_addon_audiodecoder_init_v1 = kodi_addon_audiodecoder_init_v1; + ifcToAddon->kodi_addon_audiodecoder_read_pcm_v1 = kodi_addon_audiodecoder_read_pcm_v1; + ifcToAddon->kodi_addon_audiodecoder_seek_v1 = kodi_addon_audiodecoder_seek_v1; + ifcToAddon->kodi_addon_audiodecoder_read_tag_v1 = kodi_addon_audiodecoder_read_tag_v1; + ifcToAddon->kodi_addon_audiodecoder_track_count_v1 = kodi_addon_audiodecoder_track_count_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_audiodecoder_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_audiodecoder_h) + return false; + + switch (func) + { + case funcChild_kodi_addon_audiodecoder_supports_file_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_SUPPORTS_FILE_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audiodecoder_supports_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audiodecoder_supports_file_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_audiodecoder_supports_file_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& file = std::get<1>(t); + bool auto_gen_ret = + kodi_addon_audiodecoder_supports_file_v1(this, auto_gen_hdl, file.c_str()); + + msgpack::pack(out, msgChild_OUT_kodi_addon_audiodecoder_supports_file_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_audiodecoder_init_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_INIT_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file, unsigned int filecache, int* channels, int* samplerate, int* bitspersample, int64_t* totaltime, int* bitrate, enum AudioEngineDataFormat* format, enum AudioEngineChannel info[AUDIOENGINE_CH_MAX]); + // Tuple in: typedef std::tuple> msgChild__IN_kodi_addon_audiodecoder_init_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple> msgChild_OUT_kodi_addon_audiodecoder_init_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_audiodecoder_init_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& file = std::get<1>(t); + unsigned int filecache = std::get<2>(t); + int channels = std::get<3>(t); + int samplerate = std::get<4>(t); + int bitspersample = std::get<5>(t); + int64_t totaltime = std::get<6>(t); + int bitrate = std::get<7>(t); + enum AudioEngineDataFormat format = std::get<8>(t); + std::array& info = std::get<9>(t); + bool auto_gen_ret = kodi_addon_audiodecoder_init_v1( + this, auto_gen_hdl, file.c_str(), filecache, &channels, &samplerate, &bitspersample, + &totaltime, &bitrate, &format, info.data()); + + msgpack::pack(out, msgChild_OUT_kodi_addon_audiodecoder_init_v1( + auto_gen_ret, channels, samplerate, bitspersample, totaltime, bitrate, + format, info)); + return true; + } + case funcChild_kodi_addon_audiodecoder_read_pcm_v1: + { + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_READ_PCM_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, uint8_t* buffer, size_t size, size_t* actualsize); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audiodecoder_read_pcm_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_audiodecoder_read_pcm_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_audiodecoder_read_pcm_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + size_t size = std::get<1>(t); + size_t actualsize = std::get<2>(t); + std::vector buffer(size); + int auto_gen_ret = + kodi_addon_audiodecoder_read_pcm_v1(this, auto_gen_hdl, buffer.data(), size, &actualsize); + + msgpack::pack( + out, msgChild_OUT_kodi_addon_audiodecoder_read_pcm_v1(auto_gen_ret, buffer, actualsize)); + return true; + } + case funcChild_kodi_addon_audiodecoder_seek_v1: + { + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_SEEK_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, int64_t time); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audiodecoder_seek_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audiodecoder_seek_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_audiodecoder_seek_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + int64_t time = std::get<1>(t); + int64_t auto_gen_ret = kodi_addon_audiodecoder_seek_v1(this, auto_gen_hdl, time); + + msgpack::pack(out, msgChild_OUT_kodi_addon_audiodecoder_seek_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_audiodecoder_read_tag_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_READ_TAG_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file, struct KODI_ADDON_AUDIODECODER_INFO_TAG* tag); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audiodecoder_read_tag_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audiodecoder_read_tag_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_audiodecoder_read_tag_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& file = std::get<1>(t); + struct KODI_ADDON_AUDIODECODER_INFO_TAG tag = {}; + bool auto_gen_ret = + kodi_addon_audiodecoder_read_tag_v1(this, auto_gen_hdl, file.c_str(), &tag); + + msgpack::pack(out, msgChild_OUT_kodi_addon_audiodecoder_read_tag_v1(auto_gen_ret, &tag)); + IFC_KODI_ADDON_AUDIODECODER_INFO_TAG::CleanCStructure(&tag); + return true; + } + case funcChild_kodi_addon_audiodecoder_track_count_v1: + { + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIODECODER_TRACK_COUNT_V1)(const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audiodecoder_track_count_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audiodecoder_track_count_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_audiodecoder_track_count_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& file = std::get<1>(t); + int auto_gen_ret = kodi_addon_audiodecoder_track_count_v1(this, auto_gen_hdl, file.c_str()); + + msgpack::pack(out, msgChild_OUT_kodi_addon_audiodecoder_track_count_v1(auto_gen_ret)); + return true; + } + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +bool CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_supports_file_v1( + void* thisClassHdl, const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_audiodecoder.v1.supports_file) + { + auto_gen_ret = + union_data->types.kodi_addon_audiodecoder.v1.supports_file(union_data->hdl, file); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_init_v1( + void* thisClassHdl, + const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file, + unsigned int filecache, + int* channels, + int* samplerate, + int* bitspersample, + int64_t* totaltime, + int* bitrate, + enum AudioEngineDataFormat* format, + enum AudioEngineChannel info[AUDIOENGINE_CH_MAX]) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_audiodecoder.v1.init) + { + auto_gen_ret = union_data->types.kodi_addon_audiodecoder.v1.init( + union_data->hdl, file, filecache, channels, samplerate, bitspersample, totaltime, bitrate, + format, info); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_read_pcm_v1( + void* thisClassHdl, + const KODI_ADDON_AUDIODECODER_HDL hdl, + uint8_t* buffer, + size_t size, + size_t* actualsize) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_audiodecoder.v1.read_pcm) + { + auto_gen_ret = union_data->types.kodi_addon_audiodecoder.v1.read_pcm(union_data->hdl, buffer, + size, actualsize); + } + return auto_gen_ret; +} + +int64_t CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_seek_v1( + void* thisClassHdl, const KODI_ADDON_AUDIODECODER_HDL hdl, int64_t time) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int64_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_audiodecoder.v1.seek) + { + auto_gen_ret = union_data->types.kodi_addon_audiodecoder.v1.seek(union_data->hdl, time); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_read_tag_v1( + void* thisClassHdl, + const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file, + struct KODI_ADDON_AUDIODECODER_INFO_TAG* tag) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_audiodecoder.v1.read_tag) + { + auto_gen_ret = + union_data->types.kodi_addon_audiodecoder.v1.read_tag(union_data->hdl, file, tag); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_audiodecoder_h::kodi_addon_audiodecoder_track_count_v1( + void* thisClassHdl, const KODI_ADDON_AUDIODECODER_HDL hdl, const char* file) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_audiodecoder.v1.track_count) + { + auto_gen_ret = union_data->types.kodi_addon_audiodecoder.v1.track_count(union_data->hdl, file); + } + return auto_gen_ret; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audiodecoder.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audiodecoder.h new file mode 100644 index 0000000000000..e883a056347c8 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audiodecoder.h @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/audiodecoder.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_audiodecoder_h; +struct directFuncToKodi_addoninstance_audiodecoder_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_audiodecoder_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_audiodecoder_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_audiodecoder_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static bool kodi_addon_audiodecoder_supports_file_v1(void* thisClassHdl, + const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file); // Added with API 1 + + static bool kodi_addon_audiodecoder_init_v1( + void* thisClassHdl, + const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file, + unsigned int filecache, + int* channels, + int* samplerate, + int* bitspersample, + int64_t* totaltime, + int* bitrate, + enum AudioEngineDataFormat* format, + enum AudioEngineChannel info[AUDIOENGINE_CH_MAX]); // Added with API 1 + + static int kodi_addon_audiodecoder_read_pcm_v1(void* thisClassHdl, + const KODI_ADDON_AUDIODECODER_HDL hdl, + uint8_t* buffer, + size_t size, + size_t* actualsize); // Added with API 1 + + static int64_t kodi_addon_audiodecoder_seek_v1(void* thisClassHdl, + const KODI_ADDON_AUDIODECODER_HDL hdl, + int64_t time); // Added with API 1 + + static bool kodi_addon_audiodecoder_read_tag_v1( + void* thisClassHdl, + const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file, + struct KODI_ADDON_AUDIODECODER_INFO_TAG* tag); // Added with API 1 + + static int kodi_addon_audiodecoder_track_count_v1(void* thisClassHdl, + const KODI_ADDON_AUDIODECODER_HDL hdl, + const char* file); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audioencoder.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audioencoder.cpp new file mode 100644 index 0000000000000..6170db9109e30 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audioencoder.cpp @@ -0,0 +1,237 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "audioencoder.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_audioencoder_h::InitDirect( + directFuncToAddon_addoninstance_audioencoder_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_audioencoder_start_v1 = kodi_addon_audioencoder_start_v1; + ifcToAddon->kodi_addon_audioencoder_encode_v1 = kodi_addon_audioencoder_encode_v1; + ifcToAddon->kodi_addon_audioencoder_finish_v1 = kodi_addon_audioencoder_finish_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_audioencoder_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_audioencoder_h) + return false; + + switch (func) + { + case funcChild_kodi_addon_audioencoder_start_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIOENCODER_START_V1)(KODI_ADDON_AUDIOENCODER_HDL hdl, const struct KODI_ADDON_AUDIOENCODER_INFO_TAG* tag); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audioencoder_start_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audioencoder_start_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_audioencoder_start_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_AUDIOENCODER_INFO_TAG tag; + std::get<1>(t).SetCStructure(&tag); + bool auto_gen_ret = kodi_addon_audioencoder_start_v1(this, auto_gen_hdl, &tag); + + msgpack::pack(out, msgChild_OUT_kodi_addon_audioencoder_start_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_audioencoder_encode_v1: + { + // Original API call: typedef ssize_t(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIOENCODER_ENCODE_V1)(KODI_ADDON_AUDIOENCODER_HDL hdl, const uint8_t* pbt_stream, size_t num_bytes_read); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_audioencoder_encode_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audioencoder_encode_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_audioencoder_encode_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::vector& pbt_stream = std::get<1>(t); + size_t num_bytes_read = std::get<2>(t); + ssize_t auto_gen_ret = + kodi_addon_audioencoder_encode_v1(this, auto_gen_hdl, pbt_stream.data(), num_bytes_read); + + msgpack::pack(out, msgChild_OUT_kodi_addon_audioencoder_encode_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_audioencoder_finish_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_AUDIOENCODER_FINISH_V1)(KODI_ADDON_AUDIOENCODER_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_audioencoder_finish_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_audioencoder_finish_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_audioencoder_finish_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + bool auto_gen_ret = kodi_addon_audioencoder_finish_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_audioencoder_finish_v1(auto_gen_ret)); + return true; + } + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +bool CHdl_kodi_addoninstance_audioencoder_h::kodi_addon_audioencoder_start_v1( + void* thisClassHdl, + KODI_ADDON_AUDIOENCODER_HDL hdl, + const struct KODI_ADDON_AUDIOENCODER_INFO_TAG* tag) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_audioencoder.v1.start) + { + auto_gen_ret = union_data->types.kodi_addon_audioencoder.v1.start(union_data->hdl, tag); + } + return auto_gen_ret; +} + +ssize_t CHdl_kodi_addoninstance_audioencoder_h::kodi_addon_audioencoder_encode_v1( + void* thisClassHdl, + KODI_ADDON_AUDIOENCODER_HDL hdl, + const uint8_t* pbt_stream, + size_t num_bytes_read) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + ssize_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_audioencoder.v1.encode) + { + auto_gen_ret = union_data->types.kodi_addon_audioencoder.v1.encode(union_data->hdl, pbt_stream, + num_bytes_read); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_audioencoder_h::kodi_addon_audioencoder_finish_v1( + void* thisClassHdl, KODI_ADDON_AUDIOENCODER_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_audioencoder.v1.finish) + { + auto_gen_ret = union_data->types.kodi_addon_audioencoder.v1.finish(union_data->hdl); + } + return auto_gen_ret; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT ssize_t kodi_addon_audioencoder_write(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const uint8_t* data, + size_t len) +{ + // Original API call: ATTR_DLL_EXPORT ssize_t kodi_addon_audioencoder_write(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const uint8_t* data, size_t len) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple, size_t> msgParent__IN_kodi_addon_audioencoder_write_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_audioencoder_write_v1; /* Autogenerated */ + + if (hdl == nullptr || data == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_audioencoder_write_v1( + PtrValue(hdl), std::vector(data, data + len), len)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_audioencoder_h, funcParent_kodi_addon_audioencoder_write_v1, in, + out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_audioencoder_write_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_audioencoder_h; + return auto_gen_group.kodi_addon_audioencoder_write_v1(auto_gen_group.thisClassHdl, hdl, data, + len); +} + +ATTR_DLL_EXPORT ssize_t kodi_addon_audioencoder_seek(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + ssize_t pos, + int whence) +{ + // Original API call: ATTR_DLL_EXPORT ssize_t kodi_addon_audioencoder_seek(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, ssize_t pos, int whence) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_audioencoder_seek_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_audioencoder_seek_v1; /* Autogenerated */ + + if (hdl == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_audioencoder_seek_v1(PtrValue(hdl), pos, whence)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_audioencoder_h, funcParent_kodi_addon_audioencoder_seek_v1, in, + out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_audioencoder_seek_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_audioencoder_h; + return auto_gen_group.kodi_addon_audioencoder_seek_v1(auto_gen_group.thisClassHdl, hdl, pos, + whence); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audioencoder.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audioencoder.h new file mode 100644 index 0000000000000..3df4065531c52 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/audioencoder.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/audioencoder.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_audioencoder_h; +struct directFuncToKodi_addoninstance_audioencoder_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_audioencoder_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_audioencoder_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_audioencoder_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static bool kodi_addon_audioencoder_start_v1( + void* thisClassHdl, + KODI_ADDON_AUDIOENCODER_HDL hdl, + const struct KODI_ADDON_AUDIOENCODER_INFO_TAG* tag); // Added with API 1 + + static ssize_t kodi_addon_audioencoder_encode_v1(void* thisClassHdl, + KODI_ADDON_AUDIOENCODER_HDL hdl, + const uint8_t* pbt_stream, + size_t num_bytes_read); // Added with API 1 + + static bool kodi_addon_audioencoder_finish_v1( + void* thisClassHdl, KODI_ADDON_AUDIOENCODER_HDL hdl); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/game.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/game.cpp new file mode 100644 index 0000000000000..3dbe5705ecc42 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/game.cpp @@ -0,0 +1,818 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "game.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_game_h::InitDirect(directFuncToAddon_addoninstance_game_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_game_create_v1 = kodi_addon_game_create_v1; + ifcToAddon->kodi_addon_game_destroy_v1 = kodi_addon_game_destroy_v1; + ifcToAddon->kodi_addon_game_load_game_v1 = kodi_addon_game_load_game_v1; + ifcToAddon->kodi_addon_game_load_game_special_v1 = kodi_addon_game_load_game_special_v1; + ifcToAddon->kodi_addon_game_load_standalone_v1 = kodi_addon_game_load_standalone_v1; + ifcToAddon->kodi_addon_game_unload_game_v1 = kodi_addon_game_unload_game_v1; + ifcToAddon->kodi_addon_game_get_game_timing_v1 = kodi_addon_game_get_game_timing_v1; + ifcToAddon->kodi_addon_game_get_region_v1 = kodi_addon_game_get_region_v1; + ifcToAddon->kodi_addon_game_requires_game_loop_v1 = kodi_addon_game_requires_game_loop_v1; + ifcToAddon->kodi_addon_game_run_frame_v1 = kodi_addon_game_run_frame_v1; + ifcToAddon->kodi_addon_game_reset_v1 = kodi_addon_game_reset_v1; + ifcToAddon->kodi_addon_game_hw_context_reset_v1 = kodi_addon_game_hw_context_reset_v1; + ifcToAddon->kodi_addon_game_hw_context_destroy_v1 = kodi_addon_game_hw_context_destroy_v1; + ifcToAddon->kodi_addon_game_has_feature_v1 = kodi_addon_game_has_feature_v1; + ifcToAddon->kodi_addon_game_get_topology_v1 = kodi_addon_game_get_topology_v1; + ifcToAddon->kodi_addon_game_free_topology_v1 = kodi_addon_game_free_topology_v1; + ifcToAddon->kodi_addon_game_set_controller_layouts_v1 = kodi_addon_game_set_controller_layouts_v1; + ifcToAddon->kodi_addon_game_enable_keyboard_v1 = kodi_addon_game_enable_keyboard_v1; + ifcToAddon->kodi_addon_game_enable_mouse_v1 = kodi_addon_game_enable_mouse_v1; + ifcToAddon->kodi_addon_game_connect_controller_v1 = kodi_addon_game_connect_controller_v1; + ifcToAddon->kodi_addon_game_input_event_v1 = kodi_addon_game_input_event_v1; + ifcToAddon->kodi_addon_game_serialize_size_v1 = kodi_addon_game_serialize_size_v1; + ifcToAddon->kodi_addon_game_serialize_v1 = kodi_addon_game_serialize_v1; + ifcToAddon->kodi_addon_game_deserialize_v1 = kodi_addon_game_deserialize_v1; + ifcToAddon->kodi_addon_game_cheat_reset_v1 = kodi_addon_game_cheat_reset_v1; + ifcToAddon->kodi_addon_game_get_memory_v1 = kodi_addon_game_get_memory_v1; + ifcToAddon->kodi_addon_game_set_cheat_v1 = kodi_addon_game_set_cheat_v1; + ifcToAddon->kodi_addon_game_rc_generate_hash_from_file_v1 = + kodi_addon_game_rc_generate_hash_from_file_v1; + ifcToAddon->kodi_addon_game_rc_get_game_id_url_v1 = kodi_addon_game_rc_get_game_id_url_v1; + ifcToAddon->kodi_addon_game_rc_get_patch_file_url_v1 = kodi_addon_game_rc_get_patch_file_url_v1; + ifcToAddon->kodi_addon_game_rc_post_rich_presence_url_v1 = + kodi_addon_game_rc_post_rich_presence_url_v1; + ifcToAddon->kodi_addon_game_rc_enable_rich_presence_v1 = + kodi_addon_game_rc_enable_rich_presence_v1; + ifcToAddon->kodi_addon_game_rc_get_rich_presence_evaluation_v1 = + kodi_addon_game_rc_get_rich_presence_evaluation_v1; + ifcToAddon->kodi_addon_game_rc_reset_runtime_v1 = kodi_addon_game_rc_reset_runtime_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_game_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_game_h) + return false; + + switch (func) + { + /* NOTE: Ignored as direct api only is set! */ + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +KODI_ADDON_GAME_HDL CHdl_kodi_addoninstance_game_h::kodi_addon_game_create_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(kodi_hdl); + KODI_ADDON_GAME_HDL auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_game.v1.create) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.create(kodi_hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_game_h::kodi_addon_game_destroy_v1( + void* thisClassHdl, KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_game.v1.destroy) + { + union_data->types.kodi_addon_game.v1.destroy(union_data->hdl); + } +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_load_game_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl, const char* url) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.load_game) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.load_game(union_data->hdl, url); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_load_game_special_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + enum SPECIAL_GAME_TYPE type, + const char** urls, + size_t urlCount) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.load_game_special) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.load_game_special(union_data->hdl, type, + urls, urlCount); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_load_standalone_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.load_standalone) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.load_standalone(union_data->hdl); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_unload_game_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.unload_game) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.unload_game(union_data->hdl); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_get_game_timing_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + struct game_system_timing* timing_info) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.get_game_timing) + { + auto_gen_ret = + union_data->types.kodi_addon_game.v1.get_game_timing(union_data->hdl, timing_info); + } + return auto_gen_ret; +} + +enum GAME_REGION CHdl_kodi_addoninstance_game_h::kodi_addon_game_get_region_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_REGION_UNKNOWN; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_REGION auto_gen_ret = GAME_REGION_UNKNOWN; + if (union_data->types.kodi_addon_game.v1.get_region) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.get_region(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_requires_game_loop_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_game.v1.requires_game_loop) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.requires_game_loop(union_data->hdl); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_run_frame_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.run_frame) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.run_frame(union_data->hdl); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_reset_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.reset) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.reset(union_data->hdl); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_hw_context_reset_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.hw_context_reset) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.hw_context_reset(union_data->hdl); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_hw_context_destroy_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.hw_context_destroy) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.hw_context_destroy(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_has_feature_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + const char* controller_id, + const char* feature_name) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_game.v1.has_feature) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.has_feature(union_data->hdl, controller_id, + feature_name); + } + return auto_gen_ret; +} + +struct game_input_topology* CHdl_kodi_addoninstance_game_h::kodi_addon_game_get_topology_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + struct game_input_topology* auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_game.v1.get_topology) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.get_topology(union_data->hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_game_h::kodi_addon_game_free_topology_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + struct game_input_topology* topology) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_game.v1.free_topology) + { + union_data->types.kodi_addon_game.v1.free_topology(union_data->hdl, topology); + } +} + +void CHdl_kodi_addoninstance_game_h::kodi_addon_game_set_controller_layouts_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + const struct game_controller_layout* controllers, + size_t controller_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_game.v1.set_controller_layouts) + { + union_data->types.kodi_addon_game.v1.set_controller_layouts(union_data->hdl, controllers, + controller_count); + } +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_enable_keyboard_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + bool enable, + const char* controller_id) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_game.v1.enable_keyboard) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.enable_keyboard(union_data->hdl, enable, + controller_id); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_enable_mouse_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + bool enable, + const char* controller_id) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_game.v1.enable_mouse) + { + auto_gen_ret = + union_data->types.kodi_addon_game.v1.enable_mouse(union_data->hdl, enable, controller_id); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_connect_controller_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + bool connect, + const char* port_address, + const char* controller_id) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_game.v1.connect_controller) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.connect_controller( + union_data->hdl, connect, port_address, controller_id); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_game_h::kodi_addon_game_input_event_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + const struct game_input_event* event) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_game.v1.input_event) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.input_event(union_data->hdl, event); + } + return auto_gen_ret; +} + +size_t CHdl_kodi_addoninstance_game_h::kodi_addon_game_serialize_size_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + size_t auto_gen_ret = 0; + if (union_data->types.kodi_addon_game.v1.serialize_size) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.serialize_size(union_data->hdl); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_serialize_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + uint8_t* data, + size_t size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.serialize) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.serialize(union_data->hdl, data, size); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_deserialize_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + const uint8_t* data, + size_t size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.deserialize) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.deserialize(union_data->hdl, data, size); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_cheat_reset_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.cheat_reset) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.cheat_reset(union_data->hdl); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_get_memory_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + enum GAME_MEMORY type, + uint8_t** data, + size_t* size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.get_memory) + { + auto_gen_ret = + union_data->types.kodi_addon_game.v1.get_memory(union_data->hdl, type, data, size); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_set_cheat_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + unsigned int index, + bool enabled, + const char* code) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.set_cheat) + { + auto_gen_ret = + union_data->types.kodi_addon_game.v1.set_cheat(union_data->hdl, index, enabled, code); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_generate_hash_from_file_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + char** hash, + unsigned int console_id, + const char* file_path) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.rc_generate_hash_from_file) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.rc_generate_hash_from_file( + union_data->hdl, hash, console_id, file_path); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_get_game_id_url_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + char** url, + const char* hash) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.rc_get_game_id_url) + { + auto_gen_ret = + union_data->types.kodi_addon_game.v1.rc_get_game_id_url(union_data->hdl, url, hash); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_get_patch_file_url_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + char** url, + const char* username, + const char* token, + unsigned int game_id) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.rc_get_patch_file_url) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.rc_get_patch_file_url( + union_data->hdl, url, username, token, game_id); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_post_rich_presence_url_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + char** url, + char** post_data, + const char* username, + const char* token, + unsigned int game_id, + const char* rich_presence) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.rc_post_rich_presence_url) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.rc_post_rich_presence_url( + union_data->hdl, url, post_data, username, token, game_id, rich_presence); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_enable_rich_presence_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl, const char* script) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.rc_enable_rich_presence) + { + auto_gen_ret = + union_data->types.kodi_addon_game.v1.rc_enable_rich_presence(union_data->hdl, script); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_get_rich_presence_evaluation_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + char** evaluation, + unsigned int console_id) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.rc_get_rich_presence_evaluation) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.rc_get_rich_presence_evaluation( + union_data->hdl, evaluation, console_id); + } + return auto_gen_ret; +} + +enum GAME_ERROR CHdl_kodi_addoninstance_game_h::kodi_addon_game_rc_reset_runtime_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return GAME_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum GAME_ERROR auto_gen_ret = GAME_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_game.v1.rc_reset_runtime) + { + auto_gen_ret = union_data->types.kodi_addon_game.v1.rc_reset_runtime(union_data->hdl); + } + return auto_gen_ret; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_addon_game_close(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_game_close(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr) + return; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_game_h; + auto_gen_group.kodi_addon_game_close_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT KODI_GAME_STREAM_HANDLE kodi_addon_game_open_stream( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const struct game_stream_properties* properties) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GAME_STREAM_HANDLE kodi_addon_game_open_stream( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const struct game_stream_properties* properties) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || properties == nullptr) + return nullptr; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_game_h; + return auto_gen_group.kodi_addon_game_open_stream_v1(auto_gen_group.thisClassHdl, hdl, + properties); +} + +ATTR_DLL_EXPORT bool kodi_addon_game_get_stream_buffer(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + unsigned int width, + unsigned int height, + struct game_stream_buffer* buffer) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_game_get_stream_buffer(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_GAME_STREAM_HANDLE game_hdl, unsigned int width, unsigned int height, struct game_stream_buffer* buffer) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || game_hdl == nullptr || buffer == nullptr) + return false; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_game_h; + return auto_gen_group.kodi_addon_game_get_stream_buffer_v1(auto_gen_group.thisClassHdl, hdl, + game_hdl, width, height, buffer); +} + +ATTR_DLL_EXPORT void kodi_addon_game_add_stream_data(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + const struct game_stream_packet* packet) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_game_add_stream_data(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_GAME_STREAM_HANDLE game_hdl, const struct game_stream_packet* packet) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || game_hdl == nullptr || packet == nullptr) + return; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_game_h; + auto_gen_group.kodi_addon_game_add_stream_data_v1(auto_gen_group.thisClassHdl, hdl, game_hdl, + packet); +} + +ATTR_DLL_EXPORT void kodi_addon_game_release_stream_buffer(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl, + struct game_stream_buffer* buffer) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_game_release_stream_buffer(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_GAME_STREAM_HANDLE game_hdl, struct game_stream_buffer* buffer) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || game_hdl == nullptr || buffer == nullptr) + return; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_game_h; + auto_gen_group.kodi_addon_game_release_stream_buffer_v1(auto_gen_group.thisClassHdl, hdl, + game_hdl, buffer); +} + +ATTR_DLL_EXPORT void kodi_addon_game_close_stream(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_GAME_STREAM_HANDLE game_hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_game_close_stream(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_GAME_STREAM_HANDLE game_hdl) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || game_hdl == nullptr) + return; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_game_h; + auto_gen_group.kodi_addon_game_close_stream_v1(auto_gen_group.thisClassHdl, hdl, game_hdl); +} + +ATTR_DLL_EXPORT game_proc_address_t +kodi_addon_game_hw_get_proc_address(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* symbol) +{ + // Original API call: ATTR_DLL_EXPORT game_proc_address_t kodi_addon_game_hw_get_proc_address( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* symbol) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || symbol == nullptr) + return nullptr; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_game_h; + return auto_gen_group.kodi_addon_game_hw_get_proc_address_v1(auto_gen_group.thisClassHdl, hdl, + symbol); +} + +ATTR_DLL_EXPORT bool kodi_addon_game_input_event(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const struct game_input_event* event) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_game_input_event(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const struct game_input_event* event) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || event == nullptr) + return false; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_game_h; + return auto_gen_group.kodi_addon_game_input_event_v1(auto_gen_group.thisClassHdl, hdl, event); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/game.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/game.h new file mode 100644 index 0000000000000..0f63a43f15fec --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/game.h @@ -0,0 +1,216 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/game.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_game_h; +struct directFuncToKodi_addoninstance_game_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_game_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_game_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_game_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static KODI_ADDON_GAME_HDL kodi_addon_game_create_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); // Added with API 1 + + static void kodi_addon_game_destroy_v1(void* thisClassHdl, + KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_load_game_v1(void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + const char* url); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_load_game_special_v1(void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + enum SPECIAL_GAME_TYPE type, + const char** urls, + size_t urlCount); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_load_standalone_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_unload_game_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_get_game_timing_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + struct game_system_timing* timing_info); // Added with API 1 + + static enum GAME_REGION kodi_addon_game_get_region_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static bool kodi_addon_game_requires_game_loop_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_run_frame_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_reset_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_hw_context_reset_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_hw_context_destroy_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static bool kodi_addon_game_has_feature_v1(void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + const char* controller_id, + const char* feature_name); // Added with API 1 + + static struct game_input_topology* kodi_addon_game_get_topology_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static void kodi_addon_game_free_topology_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + struct game_input_topology* topology); // Added with API 1 + + static void kodi_addon_game_set_controller_layouts_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + const struct game_controller_layout* controllers, + size_t controller_count); // Added with API 1 + + static bool kodi_addon_game_enable_keyboard_v1(void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + bool enable, + const char* controller_id); // Added with API 1 + + static bool kodi_addon_game_enable_mouse_v1(void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + bool enable, + const char* controller_id); // Added with API 1 + + static bool kodi_addon_game_connect_controller_v1(void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + bool connect, + const char* port_address, + const char* controller_id); // Added with API 1 + + static bool kodi_addon_game_input_event_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + const struct game_input_event* event); // Added with API 1 + + static size_t kodi_addon_game_serialize_size_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_serialize_v1(void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + uint8_t* data, + size_t size); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_deserialize_v1(void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + const uint8_t* data, + size_t size); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_cheat_reset_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_get_memory_v1(void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + enum GAME_MEMORY type, + uint8_t** data, + size_t* size); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_set_cheat_v1(void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + unsigned int index, + bool enabled, + const char* code); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_rc_generate_hash_from_file_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + char** hash, + unsigned int console_id, + const char* file_path); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_rc_get_game_id_url_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + char** url, + const char* hash); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_rc_get_patch_file_url_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + char** url, + const char* username, + const char* token, + unsigned int game_id); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_rc_post_rich_presence_url_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + char** url, + char** post_data, + const char* username, + const char* token, + unsigned int game_id, + const char* rich_presence); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_rc_enable_rich_presence_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl, const char* script); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_rc_get_rich_presence_evaluation_v1( + void* thisClassHdl, + const KODI_ADDON_GAME_HDL hdl, + char** evaluation, + unsigned int console_id); // Added with API 1 + + static enum GAME_ERROR kodi_addon_game_rc_reset_runtime_v1( + void* thisClassHdl, const KODI_ADDON_GAME_HDL hdl); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/imagedecoder.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/imagedecoder.cpp new file mode 100644 index 0000000000000..c50c893dc2a01 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/imagedecoder.cpp @@ -0,0 +1,229 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "imagedecoder.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_imagedecoder_h::InitDirect( + directFuncToAddon_addoninstance_imagedecoder_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_imagedecoder_supports_file_v1 = kodi_addon_imagedecoder_supports_file_v1; + ifcToAddon->kodi_addon_imagedecoder_read_tag_v1 = kodi_addon_imagedecoder_read_tag_v1; + ifcToAddon->kodi_addon_imagedecoder_load_image_from_memory_v1 = + kodi_addon_imagedecoder_load_image_from_memory_v1; + ifcToAddon->kodi_addon_imagedecoder_decode_v1 = kodi_addon_imagedecoder_decode_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_imagedecoder_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_imagedecoder_h) + return false; + + switch (func) + { + case funcChild_kodi_addon_imagedecoder_supports_file_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_IMAGEDECODER_SUPPORTS_FILE_V1)(const KODI_ADDON_IMAGEDECODER_HDL hdl, const char* file); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_imagedecoder_supports_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_imagedecoder_supports_file_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_imagedecoder_supports_file_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& file = std::get<1>(t); + bool auto_gen_ret = + kodi_addon_imagedecoder_supports_file_v1(this, auto_gen_hdl, file.c_str()); + + msgpack::pack(out, msgChild_OUT_kodi_addon_imagedecoder_supports_file_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_imagedecoder_read_tag_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_IMAGEDECODER_READ_TAG_V1)(const KODI_ADDON_IMAGEDECODER_HDL hdl, const char* file, struct KODI_ADDON_IMAGEDECODER_INFO_TAG* info); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_imagedecoder_read_tag_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_imagedecoder_read_tag_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_imagedecoder_read_tag_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& file = std::get<1>(t); + struct KODI_ADDON_IMAGEDECODER_INFO_TAG info = {}; + bool auto_gen_ret = + kodi_addon_imagedecoder_read_tag_v1(this, auto_gen_hdl, file.c_str(), &info); + + msgpack::pack(out, msgChild_OUT_kodi_addon_imagedecoder_read_tag_v1(auto_gen_ret, &info)); + IFC_KODI_ADDON_IMAGEDECODER_INFO_TAG::CleanCStructure(&info); + return true; + } + case funcChild_kodi_addon_imagedecoder_load_image_from_memory_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_IMAGEDECODER_LOAD_IMAGE_FROM_MEMORY_V1)(const KODI_ADDON_IMAGEDECODER_HDL hdl, const char* mimetype, const uint8_t* buffer, size_t buf_size, unsigned int* width, unsigned int* height); + // Tuple in: typedef std::tuple, size_t, unsigned int, unsigned int> msgChild__IN_kodi_addon_imagedecoder_load_image_from_memory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_imagedecoder_load_image_from_memory_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_imagedecoder_load_image_from_memory_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& mimetype = std::get<1>(t); + const std::vector& buffer = std::get<2>(t); + size_t buf_size = std::get<3>(t); + unsigned int width = std::get<4>(t); + unsigned int height = std::get<5>(t); + bool auto_gen_ret = kodi_addon_imagedecoder_load_image_from_memory_v1( + this, auto_gen_hdl, mimetype.c_str(), buffer.data(), buf_size, &width, &height); + + msgpack::pack(out, msgChild_OUT_kodi_addon_imagedecoder_load_image_from_memory_v1( + auto_gen_ret, width, height)); + return true; + } + case funcChild_kodi_addon_imagedecoder_decode_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_IMAGEDECODER_DECODE_V1)(const KODI_ADDON_IMAGEDECODER_HDL hdl, uint8_t* pixels, size_t pixels_size, unsigned int width, unsigned int height, unsigned int pitch, enum ADDON_IMG_FMT format); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_imagedecoder_decode_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple> msgChild_OUT_kodi_addon_imagedecoder_decode_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_imagedecoder_decode_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + size_t pixels_size = std::get<1>(t); + unsigned int width = std::get<2>(t); + unsigned int height = std::get<3>(t); + unsigned int pitch = std::get<4>(t); + enum ADDON_IMG_FMT format = std::get<5>(t); + std::vector pixels(pixels_size); + bool auto_gen_ret = kodi_addon_imagedecoder_decode_v1( + this, auto_gen_hdl, pixels.data(), pixels_size, width, height, pitch, format); + + msgpack::pack(out, msgChild_OUT_kodi_addon_imagedecoder_decode_v1(auto_gen_ret, pixels)); + return true; + } + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +bool CHdl_kodi_addoninstance_imagedecoder_h::kodi_addon_imagedecoder_supports_file_v1( + void* thisClassHdl, const KODI_ADDON_IMAGEDECODER_HDL hdl, const char* file) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_imagedecoder.v1.supports_file) + { + auto_gen_ret = + union_data->types.kodi_addon_imagedecoder.v1.supports_file(union_data->hdl, file); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_imagedecoder_h::kodi_addon_imagedecoder_read_tag_v1( + void* thisClassHdl, + const KODI_ADDON_IMAGEDECODER_HDL hdl, + const char* file, + struct KODI_ADDON_IMAGEDECODER_INFO_TAG* info) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_imagedecoder.v1.read_tag) + { + auto_gen_ret = + union_data->types.kodi_addon_imagedecoder.v1.read_tag(union_data->hdl, file, info); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_imagedecoder_h::kodi_addon_imagedecoder_load_image_from_memory_v1( + void* thisClassHdl, + const KODI_ADDON_IMAGEDECODER_HDL hdl, + const char* mimetype, + const uint8_t* buffer, + size_t buf_size, + unsigned int* width, + unsigned int* height) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_imagedecoder.v1.load_image_from_memory) + { + auto_gen_ret = union_data->types.kodi_addon_imagedecoder.v1.load_image_from_memory( + union_data->hdl, mimetype, buffer, buf_size, width, height); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_imagedecoder_h::kodi_addon_imagedecoder_decode_v1( + void* thisClassHdl, + const KODI_ADDON_IMAGEDECODER_HDL hdl, + uint8_t* pixels, + size_t pixels_size, + unsigned int width, + unsigned int height, + unsigned int pitch, + enum ADDON_IMG_FMT format) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_imagedecoder.v1.decode) + { + auto_gen_ret = union_data->types.kodi_addon_imagedecoder.v1.decode( + union_data->hdl, pixels, pixels_size, width, height, pitch, format); + } + return auto_gen_ret; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/imagedecoder.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/imagedecoder.h new file mode 100644 index 0000000000000..f7fa8d99c044f --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/imagedecoder.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/imagedecoder.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_imagedecoder_h; +struct directFuncToKodi_addoninstance_imagedecoder_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_imagedecoder_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_imagedecoder_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_imagedecoder_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static bool kodi_addon_imagedecoder_supports_file_v1(void* thisClassHdl, + const KODI_ADDON_IMAGEDECODER_HDL hdl, + const char* file); // Added with API 1 + + static bool kodi_addon_imagedecoder_read_tag_v1( + void* thisClassHdl, + const KODI_ADDON_IMAGEDECODER_HDL hdl, + const char* file, + struct KODI_ADDON_IMAGEDECODER_INFO_TAG* info); // Added with API 1 + + static bool kodi_addon_imagedecoder_load_image_from_memory_v1( + void* thisClassHdl, + const KODI_ADDON_IMAGEDECODER_HDL hdl, + const char* mimetype, + const uint8_t* buffer, + size_t buf_size, + unsigned int* width, + unsigned int* height); // Added with API 1 + + static bool kodi_addon_imagedecoder_decode_v1(void* thisClassHdl, + const KODI_ADDON_IMAGEDECODER_HDL hdl, + uint8_t* pixels, + size_t pixels_size, + unsigned int width, + unsigned int height, + unsigned int pitch, + enum ADDON_IMG_FMT format); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/inputstream.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/inputstream.cpp new file mode 100644 index 0000000000000..04dcb699ab97d --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/inputstream.cpp @@ -0,0 +1,675 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "inputstream.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_inputstream_h::InitDirect( + directFuncToAddon_addoninstance_inputstream_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_inputstream_create_v1 = kodi_addon_inputstream_create_v1; + ifcToAddon->kodi_addon_inputstream_destroy_v1 = kodi_addon_inputstream_destroy_v1; + ifcToAddon->kodi_addon_inputstream_open_v1 = kodi_addon_inputstream_open_v1; + ifcToAddon->kodi_addon_inputstream_close_v1 = kodi_addon_inputstream_close_v1; + ifcToAddon->kodi_addon_inputstream_get_path_list_v1 = kodi_addon_inputstream_get_path_list_v1; + ifcToAddon->kodi_addon_inputstream_get_capabilities_v1 = + kodi_addon_inputstream_get_capabilities_v1; + ifcToAddon->kodi_addon_inputstream_get_stream_ids_v1 = kodi_addon_inputstream_get_stream_ids_v1; + ifcToAddon->kodi_addon_inputstream_get_stream_v1 = kodi_addon_inputstream_get_stream_v1; + ifcToAddon->kodi_addon_inputstream_enable_stream_v1 = kodi_addon_inputstream_enable_stream_v1; + ifcToAddon->kodi_addon_inputstream_open_stream_v1 = kodi_addon_inputstream_open_stream_v1; + ifcToAddon->kodi_addon_inputstream_demux_reset_v1 = kodi_addon_inputstream_demux_reset_v1; + ifcToAddon->kodi_addon_inputstream_demux_abort_v1 = kodi_addon_inputstream_demux_abort_v1; + ifcToAddon->kodi_addon_inputstream_demux_flush_v1 = kodi_addon_inputstream_demux_flush_v1; + ifcToAddon->kodi_addon_inputstream_demux_read_v1 = kodi_addon_inputstream_demux_read_v1; + ifcToAddon->kodi_addon_inputstream_demux_seek_time_v1 = kodi_addon_inputstream_demux_seek_time_v1; + ifcToAddon->kodi_addon_inputstream_demux_set_speed_v1 = kodi_addon_inputstream_demux_set_speed_v1; + ifcToAddon->kodi_addon_inputstream_set_video_resolution_v1 = + kodi_addon_inputstream_set_video_resolution_v1; + ifcToAddon->kodi_addon_inputstream_get_total_time_v1 = kodi_addon_inputstream_get_total_time_v1; + ifcToAddon->kodi_addon_inputstream_get_time_v1 = kodi_addon_inputstream_get_time_v1; + ifcToAddon->kodi_addon_inputstream_get_times_v1 = kodi_addon_inputstream_get_times_v1; + ifcToAddon->kodi_addon_inputstream_pos_time_v1 = kodi_addon_inputstream_pos_time_v1; + ifcToAddon->kodi_addon_inputstream_read_stream_v1 = kodi_addon_inputstream_read_stream_v1; + ifcToAddon->kodi_addon_inputstream_seek_stream_v1 = kodi_addon_inputstream_seek_stream_v1; + ifcToAddon->kodi_addon_inputstream_position_stream_v1 = kodi_addon_inputstream_position_stream_v1; + ifcToAddon->kodi_addon_inputstream_length_stream_v1 = kodi_addon_inputstream_length_stream_v1; + ifcToAddon->kodi_addon_inputstream_is_real_time_stream_v1 = + kodi_addon_inputstream_is_real_time_stream_v1; + ifcToAddon->kodi_addon_inputstream_get_chapter_v1 = kodi_addon_inputstream_get_chapter_v1; + ifcToAddon->kodi_addon_inputstream_get_chapter_count_v1 = + kodi_addon_inputstream_get_chapter_count_v1; + ifcToAddon->kodi_addon_inputstream_get_chapter_name_v1 = + kodi_addon_inputstream_get_chapter_name_v1; + ifcToAddon->kodi_addon_inputstream_get_chapter_pos_v1 = kodi_addon_inputstream_get_chapter_pos_v1; + ifcToAddon->kodi_addon_inputstream_seek_chapter_v1 = kodi_addon_inputstream_seek_chapter_v1; + ifcToAddon->kodi_addon_inputstream_block_size_stream_v1 = + kodi_addon_inputstream_block_size_stream_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_inputstream_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_inputstream_h) + return false; + + switch (func) + { + /* NOTE: Ignored as direct api only is set! */ + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +KODI_ADDON_INPUTSTREAM_HDL CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_create_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(kodi_hdl); + KODI_ADDON_INPUTSTREAM_HDL auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_inputstream.v1.create) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.create(kodi_hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_destroy_v1( + void* thisClassHdl, KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_inputstream.v1.destroy) + { + union_data->types.kodi_addon_inputstream.v1.destroy(union_data->hdl); + } +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_open_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_PROPERTY* props) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_inputstream.v1.open) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.open(union_data->hdl, props); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_close_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_inputstream.v1.close) + { + union_data->types.kodi_addon_inputstream.v1.close(union_data->hdl); + } +} + +const char* CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_path_list_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + const char* auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_inputstream.v1.get_path_list) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.get_path_list(union_data->hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_capabilities_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_CAPABILITIES* capabilities) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_inputstream.v1.get_capabilities) + { + union_data->types.kodi_addon_inputstream.v1.get_capabilities(union_data->hdl, capabilities); + } +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_stream_ids_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_IDS* ids) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_inputstream.v1.get_stream_ids) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.get_stream_ids(union_data->hdl, ids); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_stream_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int streamid, + struct INPUTSTREAM_INFO* info, + KODI_OWN_HDL* demuxStream, + PFN_CB_KODI_ADDON_INPUTSTREAM_TRANSFER_STREAM transfer_stream) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_inputstream.v1.get_stream) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.get_stream( + union_data->hdl, streamid, info, demuxStream, transfer_stream); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_enable_stream_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int streamid, + bool enable) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_inputstream.v1.enable_stream) + { + union_data->types.kodi_addon_inputstream.v1.enable_stream(union_data->hdl, streamid, enable); + } +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_open_stream_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl, int streamid) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_inputstream.v1.open_stream) + { + auto_gen_ret = + union_data->types.kodi_addon_inputstream.v1.open_stream(union_data->hdl, streamid); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_reset_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_inputstream.v1.demux_reset) + { + union_data->types.kodi_addon_inputstream.v1.demux_reset(union_data->hdl); + } +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_abort_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_inputstream.v1.demux_abort) + { + union_data->types.kodi_addon_inputstream.v1.demux_abort(union_data->hdl); + } +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_flush_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_inputstream.v1.demux_flush) + { + union_data->types.kodi_addon_inputstream.v1.demux_flush(union_data->hdl); + } +} + +struct DEMUX_PACKET* CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_read_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + struct DEMUX_PACKET* auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_inputstream.v1.demux_read) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.demux_read(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_seek_time_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + double time, + bool backwards, + double* startpts) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_inputstream.v1.demux_seek_time) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.demux_seek_time( + union_data->hdl, time, backwards, startpts); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_demux_set_speed_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl, int speed) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_inputstream.v1.demux_set_speed) + { + union_data->types.kodi_addon_inputstream.v1.demux_set_speed(union_data->hdl, speed); + } +} + +void CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_set_video_resolution_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int width, + int height) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_inputstream.v1.set_video_resolution) + { + union_data->types.kodi_addon_inputstream.v1.set_video_resolution(union_data->hdl, width, + height); + } +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_total_time_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_inputstream.v1.get_total_time) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.get_total_time(union_data->hdl); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_time_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_inputstream.v1.get_time) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.get_time(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_times_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_TIMES* times) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_inputstream.v1.get_times) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.get_times(union_data->hdl, times); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_pos_time_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl, int ms) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_inputstream.v1.pos_time) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.pos_time(union_data->hdl, ms); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_read_stream_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + uint8_t* buffer, + unsigned int bufferSize) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_inputstream.v1.read_stream) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.read_stream(union_data->hdl, buffer, + bufferSize); + } + return auto_gen_ret; +} + +int64_t CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_seek_stream_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int64_t position, + int whence) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int64_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_inputstream.v1.seek_stream) + { + auto_gen_ret = + union_data->types.kodi_addon_inputstream.v1.seek_stream(union_data->hdl, position, whence); + } + return auto_gen_ret; +} + +int64_t CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_position_stream_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int64_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_inputstream.v1.position_stream) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.position_stream(union_data->hdl); + } + return auto_gen_ret; +} + +int64_t CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_length_stream_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int64_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_inputstream.v1.length_stream) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.length_stream(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_is_real_time_stream_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_inputstream.v1.is_real_time_stream) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.is_real_time_stream(union_data->hdl); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_chapter_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_inputstream.v1.get_chapter) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.get_chapter(union_data->hdl); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_chapter_count_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_inputstream.v1.get_chapter_count) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.get_chapter_count(union_data->hdl); + } + return auto_gen_ret; +} + +const char* CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_chapter_name_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + const char* auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_inputstream.v1.get_chapter_name) + { + auto_gen_ret = + union_data->types.kodi_addon_inputstream.v1.get_chapter_name(union_data->hdl, ch); + } + return auto_gen_ret; +} + +int64_t CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_get_chapter_pos_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int64_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_inputstream.v1.get_chapter_pos) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.get_chapter_pos(union_data->hdl, ch); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_seek_chapter_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_inputstream.v1.seek_chapter) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.seek_chapter(union_data->hdl, ch); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_inputstream_h::kodi_addon_inputstream_block_size_stream_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_inputstream.v1.block_size_stream) + { + auto_gen_ret = union_data->types.kodi_addon_inputstream.v1.block_size_stream(union_data->hdl); + } + return auto_gen_ret; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT struct DEMUX_PACKET* kodi_addon_inputstream_allocate_demux_packet( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, int data_size) +{ + // Original API call: ATTR_DLL_EXPORT struct DEMUX_PACKET* kodi_addon_inputstream_allocate_demux_packet( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, int data_size) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr) + return nullptr; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_inputstream_h; + return auto_gen_group.kodi_addon_inputstream_allocate_demux_packet_v1(auto_gen_group.thisClassHdl, + hdl, data_size); +} + +ATTR_DLL_EXPORT struct DEMUX_PACKET* kodi_addon_inputstream_allocate_encrypted_demux_packet( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + unsigned int data_size, + unsigned int encrypted_subsample_count) +{ + // Original API call: ATTR_DLL_EXPORT struct DEMUX_PACKET* kodi_addon_inputstream_allocate_encrypted_demux_packet( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, unsigned int data_size, unsigned int encrypted_subsample_count) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr) + return nullptr; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_inputstream_h; + return auto_gen_group.kodi_addon_inputstream_allocate_encrypted_demux_packet_v1( + auto_gen_group.thisClassHdl, hdl, data_size, encrypted_subsample_count); +} + +ATTR_DLL_EXPORT void kodi_addon_inputstream_free_demux_packet(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct DEMUX_PACKET* packet) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_inputstream_free_demux_packet(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct DEMUX_PACKET* packet) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || packet == nullptr) + return; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_inputstream_h; + auto_gen_group.kodi_addon_inputstream_free_demux_packet_v1(auto_gen_group.thisClassHdl, hdl, + packet); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/inputstream.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/inputstream.h new file mode 100644 index 0000000000000..350947e0a054e --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/inputstream.h @@ -0,0 +1,186 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/inputstream.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_inputstream_h; +struct directFuncToKodi_addoninstance_inputstream_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_inputstream_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_inputstream_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_inputstream_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static KODI_ADDON_INPUTSTREAM_HDL kodi_addon_inputstream_create_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); // Added with API 1 + + static void kodi_addon_inputstream_destroy_v1(void* thisClassHdl, + KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static bool kodi_addon_inputstream_open_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_PROPERTY* props); // Added with API 1 + + static void kodi_addon_inputstream_close_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static const char* kodi_addon_inputstream_get_path_list_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static void kodi_addon_inputstream_get_capabilities_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_CAPABILITIES* capabilities); // Added with API 1 + + static bool kodi_addon_inputstream_get_stream_ids_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_IDS* ids); // Added with API 1 + + static bool kodi_addon_inputstream_get_stream_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int streamid, + struct INPUTSTREAM_INFO* info, + KODI_OWN_HDL* demuxStream, + PFN_CB_KODI_ADDON_INPUTSTREAM_TRANSFER_STREAM transfer_stream); // Added with API 1 + + static void kodi_addon_inputstream_enable_stream_v1(void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int streamid, + bool enable); // Added with API 1 + + static bool kodi_addon_inputstream_open_stream_v1(void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int streamid); // Added with API 1 + + static void kodi_addon_inputstream_demux_reset_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static void kodi_addon_inputstream_demux_abort_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static void kodi_addon_inputstream_demux_flush_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static struct DEMUX_PACKET* kodi_addon_inputstream_demux_read_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static bool kodi_addon_inputstream_demux_seek_time_v1(void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + double time, + bool backwards, + double* startpts); // Added with API 1 + + static void kodi_addon_inputstream_demux_set_speed_v1(void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int speed); // Added with API 1 + + static void kodi_addon_inputstream_set_video_resolution_v1(void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int width, + int height); // Added with API 1 + + static int kodi_addon_inputstream_get_total_time_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static int kodi_addon_inputstream_get_time_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static bool kodi_addon_inputstream_get_times_v1( + void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + struct INPUTSTREAM_TIMES* times); // Added with API 1 + + static bool kodi_addon_inputstream_pos_time_v1(void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int ms); // Added with API 1 + + static int kodi_addon_inputstream_read_stream_v1(void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + uint8_t* buffer, + unsigned int bufferSize); // Added with API 1 + + static int64_t kodi_addon_inputstream_seek_stream_v1(void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int64_t position, + int whence); // Added with API 1 + + static int64_t kodi_addon_inputstream_position_stream_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static int64_t kodi_addon_inputstream_length_stream_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static bool kodi_addon_inputstream_is_real_time_stream_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static int kodi_addon_inputstream_get_chapter_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static int kodi_addon_inputstream_get_chapter_count_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 + + static const char* kodi_addon_inputstream_get_chapter_name_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl, int ch); // Added with API 1 + + static int64_t kodi_addon_inputstream_get_chapter_pos_v1(void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int ch); // Added with API 1 + + static bool kodi_addon_inputstream_seek_chapter_v1(void* thisClassHdl, + const KODI_ADDON_INPUTSTREAM_HDL hdl, + int ch); // Added with API 1 + + static int kodi_addon_inputstream_block_size_stream_v1( + void* thisClassHdl, const KODI_ADDON_INPUTSTREAM_HDL hdl); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/peripheral.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/peripheral.cpp new file mode 100644 index 0000000000000..36676b909a94b --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/peripheral.cpp @@ -0,0 +1,506 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "peripheral.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_peripheral_h::InitDirect( + directFuncToAddon_addoninstance_peripheral_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_peripheral_create_v1 = kodi_addon_peripheral_create_v1; + ifcToAddon->kodi_addon_peripheral_destroy_v1 = kodi_addon_peripheral_destroy_v1; + ifcToAddon->kodi_addon_peripheral_get_capabilities_v1 = kodi_addon_peripheral_get_capabilities_v1; + ifcToAddon->kodi_addon_peripheral_perform_device_scan_v1 = + kodi_addon_peripheral_perform_device_scan_v1; + ifcToAddon->kodi_addon_peripheral_free_scan_results_v1 = + kodi_addon_peripheral_free_scan_results_v1; + ifcToAddon->kodi_addon_peripheral_get_events_v1 = kodi_addon_peripheral_get_events_v1; + ifcToAddon->kodi_addon_peripheral_free_events_v1 = kodi_addon_peripheral_free_events_v1; + ifcToAddon->kodi_addon_peripheral_send_event_v1 = kodi_addon_peripheral_send_event_v1; + ifcToAddon->kodi_addon_peripheral_get_joystick_info_v1 = + kodi_addon_peripheral_get_joystick_info_v1; + ifcToAddon->kodi_addon_peripheral_free_joystick_info_v1 = + kodi_addon_peripheral_free_joystick_info_v1; + ifcToAddon->kodi_addon_peripheral_get_features_v1 = kodi_addon_peripheral_get_features_v1; + ifcToAddon->kodi_addon_peripheral_free_features_v1 = kodi_addon_peripheral_free_features_v1; + ifcToAddon->kodi_addon_peripheral_map_features_v1 = kodi_addon_peripheral_map_features_v1; + ifcToAddon->kodi_addon_peripheral_get_ignored_primitives_v1 = + kodi_addon_peripheral_get_ignored_primitives_v1; + ifcToAddon->kodi_addon_peripheral_free_primitives_v1 = kodi_addon_peripheral_free_primitives_v1; + ifcToAddon->kodi_addon_peripheral_set_ignored_primitives_v1 = + kodi_addon_peripheral_set_ignored_primitives_v1; + ifcToAddon->kodi_addon_peripheral_save_button_map_v1 = kodi_addon_peripheral_save_button_map_v1; + ifcToAddon->kodi_addon_peripheral_revert_button_map_v1 = + kodi_addon_peripheral_revert_button_map_v1; + ifcToAddon->kodi_addon_peripheral_reset_button_map_v1 = kodi_addon_peripheral_reset_button_map_v1; + ifcToAddon->kodi_addon_peripheral_power_off_joystick_v1 = + kodi_addon_peripheral_power_off_joystick_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_peripheral_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_peripheral_h) + return false; + + switch (func) + { + /* NOTE: Ignored as direct api only is set! */ + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +KODI_ADDON_PERIPHERAL_HDL CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_create_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(kodi_hdl); + KODI_ADDON_PERIPHERAL_HDL auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_peripheral.v1.create) + { + auto_gen_ret = union_data->types.kodi_addon_peripheral.v1.create(kodi_hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_destroy_v1( + void* thisClassHdl, KODI_ADDON_PERIPHERAL_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.destroy) + { + union_data->types.kodi_addon_peripheral.v1.destroy(union_data->hdl); + } +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_get_capabilities_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_CAPABILITIES* capabilities) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.get_capabilities) + { + union_data->types.kodi_addon_peripheral.v1.get_capabilities(union_data->hdl, capabilities); + } +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h:: + kodi_addon_peripheral_perform_device_scan_v1(void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_INFO** scan_results, + size_t* peripheral_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PERIPHERAL_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PERIPHERAL_ERROR auto_gen_ret = PERIPHERAL_NO_ERROR; + if (union_data->types.kodi_addon_peripheral.v1.perform_device_scan) + { + auto_gen_ret = union_data->types.kodi_addon_peripheral.v1.perform_device_scan( + union_data->hdl, scan_results, peripheral_count); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_free_scan_results_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_INFO* scan_results, + size_t peripheral_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.free_scan_results) + { + union_data->types.kodi_addon_peripheral.v1.free_scan_results(union_data->hdl, scan_results, + peripheral_count); + } +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_get_events_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_EVENT** events, + size_t* event_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PERIPHERAL_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PERIPHERAL_ERROR auto_gen_ret = PERIPHERAL_NO_ERROR; + if (union_data->types.kodi_addon_peripheral.v1.get_events) + { + auto_gen_ret = + union_data->types.kodi_addon_peripheral.v1.get_events(union_data->hdl, events, event_count); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_free_events_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_EVENT* events, + size_t event_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.free_events) + { + union_data->types.kodi_addon_peripheral.v1.free_events(union_data->hdl, events, event_count); + } +} + +bool CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_send_event_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct PERIPHERAL_EVENT* event) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_peripheral.v1.send_event) + { + auto_gen_ret = union_data->types.kodi_addon_peripheral.v1.send_event(union_data->hdl, event); + } + return auto_gen_ret; +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h:: + kodi_addon_peripheral_get_joystick_info_v1(void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + unsigned int index, + struct JOYSTICK_INFO* info) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PERIPHERAL_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PERIPHERAL_ERROR auto_gen_ret = PERIPHERAL_NO_ERROR; + if (union_data->types.kodi_addon_peripheral.v1.get_joystick_info) + { + auto_gen_ret = + union_data->types.kodi_addon_peripheral.v1.get_joystick_info(union_data->hdl, index, info); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_free_joystick_info_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_INFO* info) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.free_joystick_info) + { + union_data->types.kodi_addon_peripheral.v1.free_joystick_info(union_data->hdl, info); + } +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_get_features_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id, + struct JOYSTICK_FEATURE** features, + size_t* feature_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PERIPHERAL_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PERIPHERAL_ERROR auto_gen_ret = PERIPHERAL_NO_ERROR; + if (union_data->types.kodi_addon_peripheral.v1.get_features) + { + auto_gen_ret = union_data->types.kodi_addon_peripheral.v1.get_features( + union_data->hdl, joystick, controller_id, features, feature_count); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_free_features_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_FEATURE* features, + size_t feature_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.free_features) + { + union_data->types.kodi_addon_peripheral.v1.free_features(union_data->hdl, features, + feature_count); + } +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_map_features_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id, + const struct JOYSTICK_FEATURE* features, + size_t feature_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PERIPHERAL_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PERIPHERAL_ERROR auto_gen_ret = PERIPHERAL_NO_ERROR; + if (union_data->types.kodi_addon_peripheral.v1.map_features) + { + auto_gen_ret = union_data->types.kodi_addon_peripheral.v1.map_features( + union_data->hdl, joystick, controller_id, features, feature_count); + } + return auto_gen_ret; +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h:: + kodi_addon_peripheral_get_ignored_primitives_v1(void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + struct JOYSTICK_DRIVER_PRIMITIVE** primitives, + size_t* primitive_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PERIPHERAL_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PERIPHERAL_ERROR auto_gen_ret = PERIPHERAL_NO_ERROR; + if (union_data->types.kodi_addon_peripheral.v1.get_ignored_primitives) + { + auto_gen_ret = union_data->types.kodi_addon_peripheral.v1.get_ignored_primitives( + union_data->hdl, joystick, primitives, primitive_count); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_free_primitives_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.free_primitives) + { + union_data->types.kodi_addon_peripheral.v1.free_primitives(union_data->hdl, primitives, + primitive_count); + } +} + +enum PERIPHERAL_ERROR CHdl_kodi_addoninstance_peripheral_h:: + kodi_addon_peripheral_set_ignored_primitives_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const struct JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PERIPHERAL_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PERIPHERAL_ERROR auto_gen_ret = PERIPHERAL_NO_ERROR; + if (union_data->types.kodi_addon_peripheral.v1.set_ignored_primitives) + { + auto_gen_ret = union_data->types.kodi_addon_peripheral.v1.set_ignored_primitives( + union_data->hdl, joystick, primitives, primitive_count); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_save_button_map_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.save_button_map) + { + union_data->types.kodi_addon_peripheral.v1.save_button_map(union_data->hdl, joystick); + } +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_revert_button_map_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.revert_button_map) + { + union_data->types.kodi_addon_peripheral.v1.revert_button_map(union_data->hdl, joystick); + } +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_reset_button_map_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.reset_button_map) + { + union_data->types.kodi_addon_peripheral.v1.reset_button_map(union_data->hdl, joystick, + controller_id); + } +} + +void CHdl_kodi_addoninstance_peripheral_h::kodi_addon_peripheral_power_off_joystick_v1( + void* thisClassHdl, KODI_ADDON_PERIPHERAL_HDL hdl, unsigned int index) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_peripheral.v1.power_off_joystick) + { + union_data->types.kodi_addon_peripheral.v1.power_off_joystick(union_data->hdl, index); + } +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_addon_peripheral_trigger_scan(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_peripheral_trigger_scan(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr) + return; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_peripheral_h; + auto_gen_group.kodi_addon_peripheral_trigger_scan_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_addon_peripheral_refresh_button_maps(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* device_name, + const char* controller_id) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_peripheral_refresh_button_maps( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* device_name, const char* controller_id) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || device_name == nullptr || controller_id == nullptr) + return; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_peripheral_h; + auto_gen_group.kodi_addon_peripheral_refresh_button_maps_v1(auto_gen_group.thisClassHdl, hdl, + device_name, controller_id); +} + +ATTR_DLL_EXPORT unsigned int kodi_addon_peripheral_feature_count( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* controller_id, enum JOYSTICK_FEATURE_TYPE type) +{ + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_addon_peripheral_feature_count( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* controller_id, enum JOYSTICK_FEATURE_TYPE type) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || controller_id == nullptr) + return 0; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_peripheral_h; + return auto_gen_group.kodi_addon_peripheral_feature_count_v1(auto_gen_group.thisClassHdl, hdl, + controller_id, type); +} + +ATTR_DLL_EXPORT enum JOYSTICK_FEATURE_TYPE kodi_addon_peripheral_feature_type( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* controller_id, const char* feature_name) +{ + // Original API call: ATTR_DLL_EXPORT enum JOYSTICK_FEATURE_TYPE kodi_addon_peripheral_feature_type( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* controller_id, const char* feature_name) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || controller_id == nullptr || feature_name == nullptr) + return JOYSTICK_FEATURE_TYPE_UNKNOWN; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_peripheral_h; + return auto_gen_group.kodi_addon_peripheral_feature_type_v1(auto_gen_group.thisClassHdl, hdl, + controller_id, feature_name); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/peripheral.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/peripheral.h new file mode 100644 index 0000000000000..ac6f153787b08 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/peripheral.h @@ -0,0 +1,171 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/peripheral.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_peripheral_h; +struct directFuncToKodi_addoninstance_peripheral_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_peripheral_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_peripheral_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_peripheral_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static KODI_ADDON_PERIPHERAL_HDL kodi_addon_peripheral_create_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); // Added with API 1 + + static void kodi_addon_peripheral_destroy_v1(void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl); // Added with API 1 + + static void kodi_addon_peripheral_get_capabilities_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_CAPABILITIES* capabilities); // Added with API 1 + + static enum PERIPHERAL_ERROR kodi_addon_peripheral_perform_device_scan_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_INFO** scan_results, + size_t* peripheral_count); // Added with API 1 + + static void kodi_addon_peripheral_free_scan_results_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_INFO* scan_results, + size_t peripheral_count); // Added with API 1 + + static enum PERIPHERAL_ERROR kodi_addon_peripheral_get_events_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_EVENT** events, + size_t* event_count); // Added with API 1 + + static void kodi_addon_peripheral_free_events_v1(void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct PERIPHERAL_EVENT* events, + size_t event_count); // Added with API 1 + + static bool kodi_addon_peripheral_send_event_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct PERIPHERAL_EVENT* event); // Added with API 1 + + static enum PERIPHERAL_ERROR kodi_addon_peripheral_get_joystick_info_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + unsigned int index, + struct JOYSTICK_INFO* info); // Added with API 1 + + static void kodi_addon_peripheral_free_joystick_info_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_INFO* info); // Added with API 1 + + static enum PERIPHERAL_ERROR kodi_addon_peripheral_get_features_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id, + struct JOYSTICK_FEATURE** features, + size_t* feature_count); // Added with API 1 + + static void kodi_addon_peripheral_free_features_v1(void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_FEATURE* features, + size_t feature_count); // Added with API 1 + + static enum PERIPHERAL_ERROR kodi_addon_peripheral_map_features_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id, + const struct JOYSTICK_FEATURE* features, + size_t feature_count); // Added with API 1 + + static enum PERIPHERAL_ERROR kodi_addon_peripheral_get_ignored_primitives_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + struct JOYSTICK_DRIVER_PRIMITIVE** primitives, + size_t* primitive_count); // Added with API 1 + + static void kodi_addon_peripheral_free_primitives_v1(void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + struct JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count); // Added with API 1 + + static enum PERIPHERAL_ERROR kodi_addon_peripheral_set_ignored_primitives_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const struct JOYSTICK_DRIVER_PRIMITIVE* primitives, + size_t primitive_count); // Added with API 1 + + static void kodi_addon_peripheral_save_button_map_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick); // Added with API 1 + + static void kodi_addon_peripheral_revert_button_map_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick); // Added with API 1 + + static void kodi_addon_peripheral_reset_button_map_v1( + void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + const struct JOYSTICK_INFO* joystick, + const char* controller_id); // Added with API 1 + + static void kodi_addon_peripheral_power_off_joystick_v1(void* thisClassHdl, + KODI_ADDON_PERIPHERAL_HDL hdl, + unsigned int index); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/pvr.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/pvr.cpp new file mode 100644 index 0000000000000..72e95902ac8f5 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/pvr.cpp @@ -0,0 +1,2659 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "pvr.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_pvr_h::InitDirect(directFuncToAddon_addoninstance_pvr_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_pvr_get_capabilities_v1 = kodi_addon_pvr_get_capabilities_v1; + ifcToAddon->kodi_addon_pvr_get_backend_name_v1 = kodi_addon_pvr_get_backend_name_v1; + ifcToAddon->kodi_addon_pvr_get_backend_version_v1 = kodi_addon_pvr_get_backend_version_v1; + ifcToAddon->kodi_addon_pvr_get_backend_hostname_v1 = kodi_addon_pvr_get_backend_hostname_v1; + ifcToAddon->kodi_addon_pvr_get_connection_string_v1 = kodi_addon_pvr_get_connection_string_v1; + ifcToAddon->kodi_addon_pvr_get_drive_space_v1 = kodi_addon_pvr_get_drive_space_v1; + ifcToAddon->kodi_addon_pvr_call_settings_menu_hook_v1 = kodi_addon_pvr_call_settings_menu_hook_v1; + ifcToAddon->kodi_addon_pvr_get_channels_amount_v1 = kodi_addon_pvr_get_channels_amount_v1; + ifcToAddon->kodi_addon_pvr_get_channels_v1 = kodi_addon_pvr_get_channels_v1; + ifcToAddon->kodi_addon_pvr_get_channel_stream_properties_v1 = + kodi_addon_pvr_get_channel_stream_properties_v1; + ifcToAddon->kodi_addon_pvr_get_signal_status_v1 = kodi_addon_pvr_get_signal_status_v1; + ifcToAddon->kodi_addon_pvr_get_descramble_info_v1 = kodi_addon_pvr_get_descramble_info_v1; + ifcToAddon->kodi_addon_pvr_get_providers_amount_v1 = kodi_addon_pvr_get_providers_amount_v1; + ifcToAddon->kodi_addon_pvr_get_providers_v1 = kodi_addon_pvr_get_providers_v1; + ifcToAddon->kodi_addon_pvr_get_channel_groups_amount_v1 = + kodi_addon_pvr_get_channel_groups_amount_v1; + ifcToAddon->kodi_addon_pvr_get_channel_groups_v1 = kodi_addon_pvr_get_channel_groups_v1; + ifcToAddon->kodi_addon_pvr_get_channel_group_members_v1 = + kodi_addon_pvr_get_channel_group_members_v1; + ifcToAddon->kodi_addon_pvr_delete_channel_v1 = kodi_addon_pvr_delete_channel_v1; + ifcToAddon->kodi_addon_pvr_rename_channel_v1 = kodi_addon_pvr_rename_channel_v1; + ifcToAddon->kodi_addon_pvr_open_dialog_channel_settings_v1 = + kodi_addon_pvr_open_dialog_channel_settings_v1; + ifcToAddon->kodi_addon_pvr_open_dialog_channel_add_v1 = kodi_addon_pvr_open_dialog_channel_add_v1; + ifcToAddon->kodi_addon_pvr_open_dialog_channel_scan_v1 = + kodi_addon_pvr_open_dialog_channel_scan_v1; + ifcToAddon->kodi_addon_pvr_call_channel_menu_hook_v1 = kodi_addon_pvr_call_channel_menu_hook_v1; + ifcToAddon->kodi_addon_pvr_get_epg_for_channel_v1 = kodi_addon_pvr_get_epg_for_channel_v1; + ifcToAddon->kodi_addon_pvr_is_epg_tag_recordable_v1 = kodi_addon_pvr_is_epg_tag_recordable_v1; + ifcToAddon->kodi_addon_pvr_is_epg_tag_playable_v1 = kodi_addon_pvr_is_epg_tag_playable_v1; + ifcToAddon->kodi_addon_pvr_get_epg_tag_edl_v1 = kodi_addon_pvr_get_epg_tag_edl_v1; + ifcToAddon->kodi_addon_pvr_get_epg_tag_stream_properties_v1 = + kodi_addon_pvr_get_epg_tag_stream_properties_v1; + ifcToAddon->kodi_addon_pvr_set_epg_max_past_days_v1 = kodi_addon_pvr_set_epg_max_past_days_v1; + ifcToAddon->kodi_addon_pvr_set_epg_max_future_days_v1 = kodi_addon_pvr_set_epg_max_future_days_v1; + ifcToAddon->kodi_addon_pvr_call_epg_menu_hook_v1 = kodi_addon_pvr_call_epg_menu_hook_v1; + ifcToAddon->kodi_addon_pvr_get_recordings_amount_v1 = kodi_addon_pvr_get_recordings_amount_v1; + ifcToAddon->kodi_addon_pvr_get_recordings_v1 = kodi_addon_pvr_get_recordings_v1; + ifcToAddon->kodi_addon_pvr_delete_recording_v1 = kodi_addon_pvr_delete_recording_v1; + ifcToAddon->kodi_addon_pvr_undelete_recording_v1 = kodi_addon_pvr_undelete_recording_v1; + ifcToAddon->kodi_addon_pvr_delete_all_recordings_from_trash_v1 = + kodi_addon_pvr_delete_all_recordings_from_trash_v1; + ifcToAddon->kodi_addon_pvr_rename_recording_v1 = kodi_addon_pvr_rename_recording_v1; + ifcToAddon->kodi_addon_pvr_set_recording_lifetime_v1 = kodi_addon_pvr_set_recording_lifetime_v1; + ifcToAddon->kodi_addon_pvr_set_recording_play_count_v1 = + kodi_addon_pvr_set_recording_play_count_v1; + ifcToAddon->kodi_addon_pvr_set_recording_last_played_position_v1 = + kodi_addon_pvr_set_recording_last_played_position_v1; + ifcToAddon->kodi_addon_pvr_get_recording_last_played_position_v1 = + kodi_addon_pvr_get_recording_last_played_position_v1; + ifcToAddon->kodi_addon_pvr_get_recording_edl_v1 = kodi_addon_pvr_get_recording_edl_v1; + ifcToAddon->kodi_addon_pvr_get_recording_size_v1 = kodi_addon_pvr_get_recording_size_v1; + ifcToAddon->kodi_addon_pvr_get_recording_stream_properties_v1 = + kodi_addon_pvr_get_recording_stream_properties_v1; + ifcToAddon->kodi_addon_pvr_call_recording_menu_hook_v1 = + kodi_addon_pvr_call_recording_menu_hook_v1; + ifcToAddon->kodi_addon_pvr_get_timer_types_v1 = kodi_addon_pvr_get_timer_types_v1; + ifcToAddon->kodi_addon_pvr_get_timers_amount_v1 = kodi_addon_pvr_get_timers_amount_v1; + ifcToAddon->kodi_addon_pvr_get_timers_v1 = kodi_addon_pvr_get_timers_v1; + ifcToAddon->kodi_addon_pvr_add_timer_v1 = kodi_addon_pvr_add_timer_v1; + ifcToAddon->kodi_addon_pvr_delete_timer_v1 = kodi_addon_pvr_delete_timer_v1; + ifcToAddon->kodi_addon_pvr_update_timer_v1 = kodi_addon_pvr_update_timer_v1; + ifcToAddon->kodi_addon_pvr_call_timer_menu_hook_v1 = kodi_addon_pvr_call_timer_menu_hook_v1; + ifcToAddon->kodi_addon_pvr_on_system_sleep_v1 = kodi_addon_pvr_on_system_sleep_v1; + ifcToAddon->kodi_addon_pvr_on_system_wake_v1 = kodi_addon_pvr_on_system_wake_v1; + ifcToAddon->kodi_addon_pvr_on_power_saving_activated_v1 = + kodi_addon_pvr_on_power_saving_activated_v1; + ifcToAddon->kodi_addon_pvr_on_power_saving_deactivated_v1 = + kodi_addon_pvr_on_power_saving_deactivated_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_pvr_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_pvr_h) + return false; + + switch (func) + { + case funcChild_kodi_addon_pvr_get_capabilities_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CAPABILITIES_V1)(KODI_ADDON_PVR_HDL hdl, struct PVR_ADDON_CAPABILITIES* capabilities); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_capabilities_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_capabilities_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_capabilities_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + struct PVR_ADDON_CAPABILITIES capabilities = {}; + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_capabilities_v1(this, auto_gen_hdl, &capabilities); + + msgpack::pack(out, + msgChild_OUT_kodi_addon_pvr_get_capabilities_v1(auto_gen_ret, &capabilities)); + return true; + } + case funcChild_kodi_addon_pvr_get_backend_name_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_BACKEND_NAME_V1)(KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_backend_name_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_backend_name_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_backend_name_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + std::string str; + size_t mem_size = std::get<1>(t); + str.reserve(mem_size); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_backend_name_v1(this, auto_gen_hdl, &str[0], mem_size); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_backend_name_v1(auto_gen_ret, str)); + return true; + } + case funcChild_kodi_addon_pvr_get_backend_version_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_BACKEND_VERSION_V1)(KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_backend_version_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_backend_version_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_backend_version_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + std::string str; + size_t mem_size = std::get<1>(t); + str.reserve(mem_size); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_backend_version_v1(this, auto_gen_hdl, &str[0], mem_size); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_backend_version_v1(auto_gen_ret, str)); + return true; + } + case funcChild_kodi_addon_pvr_get_backend_hostname_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_BACKEND_HOSTNAME_V1)(KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_backend_hostname_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_backend_hostname_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_backend_hostname_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + std::string str; + size_t mem_size = std::get<1>(t); + str.reserve(mem_size); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_backend_hostname_v1(this, auto_gen_hdl, &str[0], mem_size); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_backend_hostname_v1(auto_gen_ret, str)); + return true; + } + case funcChild_kodi_addon_pvr_get_connection_string_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CONNECTION_STRING_V1)(KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_connection_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_connection_string_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_connection_string_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + std::string str; + size_t mem_size = std::get<1>(t); + str.reserve(mem_size); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_connection_string_v1(this, auto_gen_hdl, &str[0], mem_size); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_connection_string_v1(auto_gen_ret, str)); + return true; + } + case funcChild_kodi_addon_pvr_get_drive_space_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_DRIVE_SPACE_V1)(KODI_ADDON_PVR_HDL hdl, uint64_t* total, uint64_t* used); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_drive_space_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_drive_space_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_drive_space_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + uint64_t total = std::get<1>(t); + uint64_t used = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_drive_space_v1(this, auto_gen_hdl, &total, &used); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_drive_space_v1(auto_gen_ret, total, used)); + return true; + } + case funcChild_kodi_addon_pvr_call_settings_menu_hook_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_SETTINGS_MENU_HOOK_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_call_settings_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_call_settings_menu_hook_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_call_settings_menu_hook_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_MENUHOOK menuhook; + std::get<1>(t).SetCStructure(&menuhook); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_call_settings_menu_hook_v1(this, auto_gen_hdl, &menuhook); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_call_settings_menu_hook_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_get_channels_amount_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNELS_AMOUNT_V1)(KODI_ADDON_PVR_HDL hdl, int* amount); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channels_amount_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channels_amount_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_channels_amount_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + int amount = std::get<1>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_channels_amount_v1(this, auto_gen_hdl, &amount); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_channels_amount_v1(auto_gen_ret, amount)); + return true; + } + case funcChild_kodi_addon_pvr_get_channels_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNELS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool radio); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channels_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channels_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_channels_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + bool radio = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_channels_v1(this, auto_gen_hdl, handle, radio); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_channels_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_get_channel_stream_properties_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_STREAM_PROPERTIES_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel, struct PVR_NAMED_VALUE* properties, size_t* properties_count); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channel_stream_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channel_stream_properties_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_channel_stream_properties_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_CHANNEL channel; + std::get<1>(t).SetCStructure(&channel); + struct PVR_NAMED_VALUE properties = {}; + size_t properties_count = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_get_channel_stream_properties_v1( + this, auto_gen_hdl, &channel, &properties, &properties_count); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_channel_stream_properties_v1( + auto_gen_ret, &properties, properties_count)); + return true; + } + case funcChild_kodi_addon_pvr_get_signal_status_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_SIGNAL_STATUS_V1)(KODI_ADDON_PVR_HDL hdl, int channel_uid, struct PVR_SIGNAL_STATUS* signal_status); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_signal_status_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_signal_status_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_signal_status_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + int channel_uid = std::get<1>(t); + struct PVR_SIGNAL_STATUS signal_status = {}; + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_signal_status_v1(this, auto_gen_hdl, channel_uid, &signal_status); + + msgpack::pack(out, + msgChild_OUT_kodi_addon_pvr_get_signal_status_v1(auto_gen_ret, &signal_status)); + return true; + } + case funcChild_kodi_addon_pvr_get_descramble_info_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_DESCRAMBLE_INFO_V1)(KODI_ADDON_PVR_HDL hdl, int channel_uid, struct PVR_DESCRAMBLE_INFO* descramble_info); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_descramble_info_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_descramble_info_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_descramble_info_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + int channel_uid = std::get<1>(t); + struct PVR_DESCRAMBLE_INFO descramble_info = {}; + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_descramble_info_v1(this, auto_gen_hdl, channel_uid, &descramble_info); + + msgpack::pack( + out, msgChild_OUT_kodi_addon_pvr_get_descramble_info_v1(auto_gen_ret, &descramble_info)); + return true; + } + case funcChild_kodi_addon_pvr_get_providers_amount_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_PROVIDERS_AMOUNT_V1)(KODI_ADDON_PVR_HDL hdl, int* amount); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_providers_amount_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_providers_amount_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_providers_amount_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + int amount = std::get<1>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_providers_amount_v1(this, auto_gen_hdl, &amount); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_providers_amount_v1(auto_gen_ret, amount)); + return true; + } + case funcChild_kodi_addon_pvr_get_providers_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_PROVIDERS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_providers_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_providers_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_providers_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_get_providers_v1(this, auto_gen_hdl, handle); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_providers_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_get_channel_groups_amount_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUPS_AMOUNT_V1)(KODI_ADDON_PVR_HDL hdl, int* amount); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channel_groups_amount_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channel_groups_amount_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_channel_groups_amount_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + int amount = std::get<1>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_channel_groups_amount_v1(this, auto_gen_hdl, &amount); + + msgpack::pack(out, + msgChild_OUT_kodi_addon_pvr_get_channel_groups_amount_v1(auto_gen_ret, amount)); + return true; + } + case funcChild_kodi_addon_pvr_get_channel_groups_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUPS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool radio); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channel_groups_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channel_groups_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_channel_groups_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + bool radio = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_channel_groups_v1(this, auto_gen_hdl, handle, radio); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_channel_groups_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_get_channel_group_members_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_CHANNEL_GROUP_MEMBERS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_CHANNEL_GROUP* group); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_channel_group_members_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_channel_group_members_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_channel_group_members_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_CHANNEL_GROUP group; + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + std::get<2>(t).SetCStructure(&group); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_channel_group_members_v1(this, auto_gen_hdl, handle, &group); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_channel_group_members_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_delete_channel_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_CHANNEL_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_delete_channel_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_delete_channel_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_delete_channel_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_CHANNEL channel; + std::get<1>(t).SetCStructure(&channel); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_delete_channel_v1(this, auto_gen_hdl, &channel); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_delete_channel_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_rename_channel_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_RENAME_CHANNEL_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_rename_channel_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_rename_channel_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_rename_channel_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_CHANNEL channel; + std::get<1>(t).SetCStructure(&channel); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_rename_channel_v1(this, auto_gen_hdl, &channel); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_rename_channel_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_open_dialog_channel_settings_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_SETTINGS_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_open_dialog_channel_settings_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_open_dialog_channel_settings_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_open_dialog_channel_settings_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_CHANNEL channel; + std::get<1>(t).SetCStructure(&channel); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_open_dialog_channel_settings_v1(this, auto_gen_hdl, &channel); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_open_dialog_channel_settings_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_open_dialog_channel_add_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_ADD_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_CHANNEL* channel); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_open_dialog_channel_add_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_open_dialog_channel_add_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_open_dialog_channel_add_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_CHANNEL channel; + std::get<1>(t).SetCStructure(&channel); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_open_dialog_channel_add_v1(this, auto_gen_hdl, &channel); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_open_dialog_channel_add_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_open_dialog_channel_scan_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_OPEN_DIALOG_CHANNEL_SCAN_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_open_dialog_channel_scan_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_open_dialog_channel_scan_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_open_dialog_channel_scan_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_open_dialog_channel_scan_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_open_dialog_channel_scan_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_call_channel_menu_hook_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_CHANNEL_MENU_HOOK_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct PVR_CHANNEL* channel); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_call_channel_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_call_channel_menu_hook_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_call_channel_menu_hook_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_MENUHOOK menuhook; + PVR_CHANNEL channel; + std::get<1>(t).SetCStructure(&menuhook); + std::get<2>(t).SetCStructure(&channel); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_call_channel_menu_hook_v1(this, auto_gen_hdl, &menuhook, &channel); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_call_channel_menu_hook_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_get_epg_for_channel_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_FOR_CHANNEL_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, int channel_uid, time_t start, time_t end); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_epg_for_channel_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_epg_for_channel_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_epg_for_channel_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + int channel_uid = std::get<2>(t); + time_t start = std::get<3>(t); + time_t end = std::get<4>(t); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_get_epg_for_channel_v1( + this, auto_gen_hdl, handle, channel_uid, start, end); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_epg_for_channel_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_is_epg_tag_recordable_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_IS_EPG_TAG_RECORDABLE_V1)(KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, bool* is_recordable); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_is_epg_tag_recordable_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_is_epg_tag_recordable_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_is_epg_tag_recordable_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + EPG_TAG tag; + std::get<1>(t).SetCStructure(&tag); + bool is_recordable = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_is_epg_tag_recordable_v1(this, auto_gen_hdl, &tag, &is_recordable); + + msgpack::pack( + out, msgChild_OUT_kodi_addon_pvr_is_epg_tag_recordable_v1(auto_gen_ret, is_recordable)); + return true; + } + case funcChild_kodi_addon_pvr_is_epg_tag_playable_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_IS_EPG_TAG_PLAYABLE_V1)(KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, bool* is_playable); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_is_epg_tag_playable_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_is_epg_tag_playable_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_is_epg_tag_playable_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + EPG_TAG tag; + std::get<1>(t).SetCStructure(&tag); + bool is_playable = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_is_epg_tag_playable_v1(this, auto_gen_hdl, &tag, &is_playable); + + msgpack::pack(out, + msgChild_OUT_kodi_addon_pvr_is_epg_tag_playable_v1(auto_gen_ret, is_playable)); + return true; + } + case funcChild_kodi_addon_pvr_get_epg_tag_edl_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_TAG_EDL_V1)(KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, struct PVR_EDL_ENTRY edl[], size_t* size); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_pvr_get_epg_tag_edl_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_pvr_get_epg_tag_edl_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_epg_tag_edl_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + EPG_TAG tag; + std::get<1>(t).SetCStructure(&tag); + std::vector& ifc_edl = std::get<2>(t); + size_t size = std::get<3>(t); + std::vector edl(size); + for (size_t i = 0; i < size; ++i) + { + ifc_edl[i].SetCStructure(&edl[i]); + } + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_epg_tag_edl_v1(this, auto_gen_hdl, &tag, edl.data(), &size); + + for (size_t i = 0; i < size; ++i) + { + ifc_edl[i] = IFC_PVR_EDL_ENTRY(&edl[i]); + } + msgpack::pack(out, + msgChild_OUT_kodi_addon_pvr_get_epg_tag_edl_v1(auto_gen_ret, ifc_edl, size)); + return true; + } + case funcChild_kodi_addon_pvr_get_epg_tag_stream_properties_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_EPG_TAG_STREAM_PROPERTIES_V1)(KODI_ADDON_PVR_HDL hdl, const struct EPG_TAG* tag, struct PVR_NAMED_VALUE* properties, size_t* properties_count); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_epg_tag_stream_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_epg_tag_stream_properties_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_epg_tag_stream_properties_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + EPG_TAG tag; + std::get<1>(t).SetCStructure(&tag); + struct PVR_NAMED_VALUE properties = {}; + size_t properties_count = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_get_epg_tag_stream_properties_v1( + this, auto_gen_hdl, &tag, &properties, &properties_count); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_epg_tag_stream_properties_v1( + auto_gen_ret, &properties, properties_count)); + return true; + } + case funcChild_kodi_addon_pvr_set_epg_max_past_days_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_EPG_MAX_PAST_DAYS_V1)(KODI_ADDON_PVR_HDL hdl, int past_days); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_set_epg_max_past_days_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_set_epg_max_past_days_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_set_epg_max_past_days_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + int past_days = std::get<1>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_set_epg_max_past_days_v1(this, auto_gen_hdl, past_days); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_set_epg_max_past_days_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_set_epg_max_future_days_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_EPG_MAX_FUTURE_DAYS_V1)(KODI_ADDON_PVR_HDL hdl, int future_days); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_set_epg_max_future_days_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_set_epg_max_future_days_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_set_epg_max_future_days_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + int future_days = std::get<1>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_set_epg_max_future_days_v1(this, auto_gen_hdl, future_days); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_set_epg_max_future_days_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_call_epg_menu_hook_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_EPG_MENU_HOOK_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct EPG_TAG* tag); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_call_epg_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_call_epg_menu_hook_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_call_epg_menu_hook_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_MENUHOOK menuhook; + EPG_TAG tag; + std::get<1>(t).SetCStructure(&menuhook); + std::get<2>(t).SetCStructure(&tag); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_call_epg_menu_hook_v1(this, auto_gen_hdl, &menuhook, &tag); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_call_epg_menu_hook_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_get_recordings_amount_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDINGS_AMOUNT_V1)(KODI_ADDON_PVR_HDL hdl, bool deleted, int* amount); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_recordings_amount_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_recordings_amount_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_recordings_amount_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + bool deleted = std::get<1>(t); + int amount = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_recordings_amount_v1(this, auto_gen_hdl, deleted, &amount); + + msgpack::pack(out, + msgChild_OUT_kodi_addon_pvr_get_recordings_amount_v1(auto_gen_ret, amount)); + return true; + } + case funcChild_kodi_addon_pvr_get_recordings_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDINGS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle, bool deleted); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_recordings_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_recordings_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_recordings_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + bool deleted = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_recordings_v1(this, auto_gen_hdl, handle, deleted); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_recordings_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_delete_recording_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_RECORDING_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_delete_recording_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_delete_recording_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_delete_recording_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&recording); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_delete_recording_v1(this, auto_gen_hdl, &recording); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_delete_recording_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_undelete_recording_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_UNDELETE_RECORDING_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_undelete_recording_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_undelete_recording_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_undelete_recording_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&recording); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_undelete_recording_v1(this, auto_gen_hdl, &recording); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_undelete_recording_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_delete_all_recordings_from_trash_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_ALL_RECORDINGS_FROM_TRASH_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_delete_all_recordings_from_trash_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_delete_all_recordings_from_trash_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_delete_all_recordings_from_trash_v1 t = + in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_delete_all_recordings_from_trash_v1(this, auto_gen_hdl); + + msgpack::pack(out, + msgChild_OUT_kodi_addon_pvr_delete_all_recordings_from_trash_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_rename_recording_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_RENAME_RECORDING_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_rename_recording_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_rename_recording_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_rename_recording_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&recording); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_rename_recording_v1(this, auto_gen_hdl, &recording); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_rename_recording_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_set_recording_lifetime_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_RECORDING_LIFETIME_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_set_recording_lifetime_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_set_recording_lifetime_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_set_recording_lifetime_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&recording); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_set_recording_lifetime_v1(this, auto_gen_hdl, &recording); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_set_recording_lifetime_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_set_recording_play_count_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_RECORDING_PLAY_COUNT_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int count); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_set_recording_play_count_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_set_recording_play_count_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_set_recording_play_count_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&recording); + int count = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_set_recording_play_count_v1(this, auto_gen_hdl, &recording, count); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_set_recording_play_count_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_set_recording_last_played_position_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_SET_RECORDING_LAST_PLAYED_POSITION_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int last_played_position); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_set_recording_last_played_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_set_recording_last_played_position_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_set_recording_last_played_position_v1 t = + in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&recording); + int last_played_position = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_set_recording_last_played_position_v1( + this, auto_gen_hdl, &recording, last_played_position); + + msgpack::pack( + out, msgChild_OUT_kodi_addon_pvr_set_recording_last_played_position_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_get_recording_last_played_position_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_LAST_PLAYED_POSITION_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int* last_played_position); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_recording_last_played_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_recording_last_played_position_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_recording_last_played_position_v1 t = + in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&recording); + int last_played_position = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_get_recording_last_played_position_v1( + this, auto_gen_hdl, &recording, &last_played_position); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_recording_last_played_position_v1( + auto_gen_ret, last_played_position)); + return true; + } + case funcChild_kodi_addon_pvr_get_recording_edl_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_EDL_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, struct PVR_EDL_ENTRY edl[], size_t* size); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_pvr_get_recording_edl_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_pvr_get_recording_edl_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_recording_edl_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&recording); + std::vector& ifc_edl = std::get<2>(t); + size_t size = std::get<3>(t); + std::vector edl(size); + for (size_t i = 0; i < size; ++i) + { + ifc_edl[i].SetCStructure(&edl[i]); + } + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_recording_edl_v1(this, auto_gen_hdl, &recording, edl.data(), &size); + + for (size_t i = 0; i < size; ++i) + { + ifc_edl[i] = IFC_PVR_EDL_ENTRY(&edl[i]); + } + msgpack::pack(out, + msgChild_OUT_kodi_addon_pvr_get_recording_edl_v1(auto_gen_ret, ifc_edl, size)); + return true; + } + case funcChild_kodi_addon_pvr_get_recording_size_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_SIZE_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, int64_t* size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_recording_size_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_recording_size_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_recording_size_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&recording); + int64_t size = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_recording_size_v1(this, auto_gen_hdl, &recording, &size); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_recording_size_v1(auto_gen_ret, size)); + return true; + } + case funcChild_kodi_addon_pvr_get_recording_stream_properties_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_RECORDING_STREAM_PROPERTIES_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_RECORDING* recording, struct PVR_NAMED_VALUE* properties, size_t* properties_count); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_recording_stream_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_recording_stream_properties_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_recording_stream_properties_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&recording); + struct PVR_NAMED_VALUE properties = {}; + size_t properties_count = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_get_recording_stream_properties_v1( + this, auto_gen_hdl, &recording, &properties, &properties_count); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_recording_stream_properties_v1( + auto_gen_ret, &properties, properties_count)); + return true; + } + case funcChild_kodi_addon_pvr_call_recording_menu_hook_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_RECORDING_MENU_HOOK_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct PVR_RECORDING* recording); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_call_recording_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_call_recording_menu_hook_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_call_recording_menu_hook_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_MENUHOOK menuhook; + PVR_RECORDING recording; + std::get<1>(t).SetCStructure(&menuhook); + std::get<2>(t).SetCStructure(&recording); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_call_recording_menu_hook_v1(this, auto_gen_hdl, &menuhook, &recording); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_call_recording_menu_hook_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_get_timer_types_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_TIMER_TYPES_V1)(KODI_ADDON_PVR_HDL hdl, struct PVR_TIMER_TYPE types[], size_t* types_count); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_pvr_get_timer_types_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_pvr_get_timer_types_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_timer_types_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + std::vector& ifc_types = std::get<1>(t); + size_t types_count = std::get<2>(t); + std::vector types(types_count); + for (size_t i = 0; i < types_count; ++i) + { + ifc_types[i].SetCStructure(&types[i]); + } + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_timer_types_v1(this, auto_gen_hdl, types.data(), &types_count); + + for (size_t i = 0; i < types_count; ++i) + { + ifc_types[i] = IFC_PVR_TIMER_TYPE(&types[i]); + } + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_timer_types_v1(auto_gen_ret, ifc_types, + types_count)); + return true; + } + case funcChild_kodi_addon_pvr_get_timers_amount_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_TIMERS_AMOUNT_V1)(KODI_ADDON_PVR_HDL hdl, int* amount); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_timers_amount_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_timers_amount_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_timers_amount_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + int amount = std::get<1>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_get_timers_amount_v1(this, auto_gen_hdl, &amount); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_timers_amount_v1(auto_gen_ret, amount)); + return true; + } + case funcChild_kodi_addon_pvr_get_timers_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_GET_TIMERS_V1)(KODI_ADDON_PVR_HDL hdl, KODI_ADDON_PVR_TRANSFER_HDL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_get_timers_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_get_timers_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_get_timers_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_PVR_TRANSFER_HDL handle = + reinterpret_cast(std::get<1>(t)); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_get_timers_v1(this, auto_gen_hdl, handle); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_get_timers_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_add_timer_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ADD_TIMER_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_add_timer_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_add_timer_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_add_timer_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_TIMER timer; + std::get<1>(t).SetCStructure(&timer); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_add_timer_v1(this, auto_gen_hdl, &timer); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_add_timer_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_delete_timer_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_DELETE_TIMER_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer, bool force_delete); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_delete_timer_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_delete_timer_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_delete_timer_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_TIMER timer; + std::get<1>(t).SetCStructure(&timer); + bool force_delete = std::get<2>(t); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_delete_timer_v1(this, auto_gen_hdl, &timer, force_delete); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_delete_timer_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_update_timer_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_UPDATE_TIMER_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_update_timer_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_update_timer_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_update_timer_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_TIMER timer; + std::get<1>(t).SetCStructure(&timer); + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_update_timer_v1(this, auto_gen_hdl, &timer); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_update_timer_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_call_timer_menu_hook_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_CALL_TIMER_MENU_HOOK_V1)(KODI_ADDON_PVR_HDL hdl, const struct PVR_MENUHOOK* menuhook, const struct PVR_TIMER* timer); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_call_timer_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_call_timer_menu_hook_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_call_timer_menu_hook_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + PVR_MENUHOOK menuhook; + PVR_TIMER timer; + std::get<1>(t).SetCStructure(&menuhook); + std::get<2>(t).SetCStructure(&timer); + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_call_timer_menu_hook_v1(this, auto_gen_hdl, &menuhook, &timer); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_call_timer_menu_hook_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_on_system_sleep_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_SYSTEM_SLEEP_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_on_system_sleep_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_on_system_sleep_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_on_system_sleep_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_on_system_sleep_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_on_system_sleep_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_on_system_wake_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_SYSTEM_WAKE_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_on_system_wake_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_on_system_wake_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_on_system_wake_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_on_system_wake_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_on_system_wake_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_on_power_saving_activated_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_POWER_SAVING_ACTIVATED_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_on_power_saving_activated_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_on_power_saving_activated_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_on_power_saving_activated_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + enum PVR_ERROR auto_gen_ret = kodi_addon_pvr_on_power_saving_activated_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_on_power_saving_activated_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_pvr_on_power_saving_deactivated_v1: + { + // Original API call: typedef enum PVR_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_PVR_ON_POWER_SAVING_DEACTIVATED_V1)(KODI_ADDON_PVR_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_pvr_on_power_saving_deactivated_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_pvr_on_power_saving_deactivated_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_pvr_on_power_saving_deactivated_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + enum PVR_ERROR auto_gen_ret = + kodi_addon_pvr_on_power_saving_deactivated_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_pvr_on_power_saving_deactivated_v1(auto_gen_ret)); + return true; + } + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_capabilities_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + struct PVR_ADDON_CAPABILITIES* capabilities) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_capabilities) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_capabilities(union_data->hdl, capabilities); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_backend_name_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_backend_name) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_backend_name(union_data->hdl, str, mem_size); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_backend_version_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_backend_version) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_backend_version(union_data->hdl, str, mem_size); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_backend_hostname_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_backend_hostname) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_backend_hostname(union_data->hdl, str, mem_size); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_connection_string_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_connection_string) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_connection_string(union_data->hdl, str, mem_size); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_drive_space_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, uint64_t* total, uint64_t* used) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_drive_space) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_drive_space(union_data->hdl, total, used); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_call_settings_menu_hook_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.call_settings_menu_hook) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.call_settings_menu_hook(union_data->hdl, menuhook); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channels_amount_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, int* amount) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_channels_amount) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_channels_amount(union_data->hdl, amount); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channels_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + bool radio) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_channels) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_channels(union_data->hdl, handle, radio); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channel_stream_properties_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_channel_stream_properties) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_channel_stream_properties( + union_data->hdl, channel, properties, properties_count); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_signal_status_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + int channel_uid, + struct PVR_SIGNAL_STATUS* signal_status) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_signal_status) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_signal_status( + union_data->hdl, channel_uid, signal_status); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_descramble_info_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + int channel_uid, + struct PVR_DESCRAMBLE_INFO* descramble_info) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_descramble_info) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_descramble_info( + union_data->hdl, channel_uid, descramble_info); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_providers_amount_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, int* amount) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_providers_amount) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_providers_amount(union_data->hdl, amount); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_providers_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_providers) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_providers(union_data->hdl, handle); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channel_groups_amount_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, int* amount) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_channel_groups_amount) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_channel_groups_amount(union_data->hdl, amount); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channel_groups_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + bool radio) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_channel_groups) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_channel_groups(union_data->hdl, handle, radio); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_channel_group_members_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP* group) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_channel_group_members) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_channel_group_members(union_data->hdl, + handle, group); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_delete_channel_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.delete_channel) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.delete_channel(union_data->hdl, channel); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_rename_channel_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.rename_channel) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.rename_channel(union_data->hdl, channel); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_open_dialog_channel_settings_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.open_dialog_channel_settings) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.open_dialog_channel_settings(union_data->hdl, channel); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_open_dialog_channel_add_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.open_dialog_channel_add) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.open_dialog_channel_add(union_data->hdl, channel); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_open_dialog_channel_scan_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.open_dialog_channel_scan) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.open_dialog_channel_scan(union_data->hdl); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_call_channel_menu_hook_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_CHANNEL* channel) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.call_channel_menu_hook) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.call_channel_menu_hook(union_data->hdl, + menuhook, channel); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_epg_for_channel_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + int channel_uid, + time_t start, + time_t end) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_epg_for_channel) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_epg_for_channel(union_data->hdl, handle, + channel_uid, start, end); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_is_epg_tag_recordable_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + bool* is_recordable) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.is_epg_tag_recordable) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.is_epg_tag_recordable(union_data->hdl, tag, + is_recordable); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_is_epg_tag_playable_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + bool* is_playable) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.is_epg_tag_playable) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.is_epg_tag_playable(union_data->hdl, tag, is_playable); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_epg_tag_edl_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + struct PVR_EDL_ENTRY edl[], + size_t* size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_epg_tag_edl) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_epg_tag_edl(union_data->hdl, tag, edl, size); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_epg_tag_stream_properties_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_epg_tag_stream_properties) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_epg_tag_stream_properties( + union_data->hdl, tag, properties, properties_count); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_set_epg_max_past_days_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, int past_days) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.set_epg_max_past_days) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.set_epg_max_past_days(union_data->hdl, past_days); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_set_epg_max_future_days_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, int future_days) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.set_epg_max_future_days) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.set_epg_max_future_days(union_data->hdl, future_days); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_call_epg_menu_hook_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct EPG_TAG* tag) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.call_epg_menu_hook) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.call_epg_menu_hook(union_data->hdl, menuhook, tag); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recordings_amount_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, bool deleted, int* amount) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_recordings_amount) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_recordings_amount(union_data->hdl, deleted, amount); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recordings_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + bool deleted) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_recordings) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_recordings(union_data->hdl, handle, deleted); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_delete_recording_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.delete_recording) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.delete_recording(union_data->hdl, recording); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_undelete_recording_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.undelete_recording) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.undelete_recording(union_data->hdl, recording); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_delete_all_recordings_from_trash_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.delete_all_recordings_from_trash) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.delete_all_recordings_from_trash(union_data->hdl); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_rename_recording_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.rename_recording) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.rename_recording(union_data->hdl, recording); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_set_recording_lifetime_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.set_recording_lifetime) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.set_recording_lifetime(union_data->hdl, recording); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_set_recording_play_count_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.set_recording_play_count) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.set_recording_play_count(union_data->hdl, + recording, count); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_set_recording_last_played_position_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int last_played_position) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.set_recording_last_played_position) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.set_recording_last_played_position( + union_data->hdl, recording, last_played_position); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recording_last_played_position_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int* last_played_position) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_recording_last_played_position) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_recording_last_played_position( + union_data->hdl, recording, last_played_position); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recording_edl_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + struct PVR_EDL_ENTRY edl[], + size_t* size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_recording_edl) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_recording_edl(union_data->hdl, recording, + edl, size); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recording_size_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int64_t* size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_recording_size) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_recording_size(union_data->hdl, recording, size); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_recording_stream_properties_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_recording_stream_properties) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_recording_stream_properties( + union_data->hdl, recording, properties, properties_count); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_call_recording_menu_hook_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_RECORDING* recording) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.call_recording_menu_hook) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.call_recording_menu_hook( + union_data->hdl, menuhook, recording); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_timer_types_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + struct PVR_TIMER_TYPE types[], + size_t* types_count) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_timer_types) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.get_timer_types(union_data->hdl, types, types_count); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_timers_amount_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, int* amount) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_timers_amount) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_timers_amount(union_data->hdl, amount); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_get_timers_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.get_timers) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.get_timers(union_data->hdl, handle); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_add_timer_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.add_timer) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.add_timer(union_data->hdl, timer); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_delete_timer_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_TIMER* timer, + bool force_delete) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.delete_timer) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.delete_timer(union_data->hdl, timer, force_delete); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_update_timer_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, const struct PVR_TIMER* timer) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.update_timer) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.update_timer(union_data->hdl, timer); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_call_timer_menu_hook_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_TIMER* timer) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.call_timer_menu_hook) + { + auto_gen_ret = + union_data->types.kodi_addon_pvr.v1.call_timer_menu_hook(union_data->hdl, menuhook, timer); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_on_system_sleep_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.on_system_sleep) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.on_system_sleep(union_data->hdl); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_on_system_wake_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.on_system_wake) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.on_system_wake(union_data->hdl); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_on_power_saving_activated_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.on_power_saving_activated) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.on_power_saving_activated(union_data->hdl); + } + return auto_gen_ret; +} + +enum PVR_ERROR CHdl_kodi_addoninstance_pvr_h::kodi_addon_pvr_on_power_saving_deactivated_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return PVR_ERROR_NO_ERROR; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum PVR_ERROR auto_gen_ret = PVR_ERROR_NO_ERROR; + if (union_data->types.kodi_addon_pvr.v1.on_power_saving_deactivated) + { + auto_gen_ret = union_data->types.kodi_addon_pvr.v1.on_power_saving_deactivated(union_data->hdl); + } + return auto_gen_ret; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT int kodi_addon_pvr_get_epg_max_future_days(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_addon_pvr_get_epg_max_future_days(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_get_epg_max_future_days_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_get_epg_max_future_days_v1; /* Autogenerated */ + + if (hdl == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_get_epg_max_future_days_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_get_epg_max_future_days_v1, in, + out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_pvr_get_epg_max_future_days_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + return auto_gen_group.kodi_addon_pvr_get_epg_max_future_days_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT int kodi_addon_pvr_get_epg_max_past_days(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_addon_pvr_get_epg_max_past_days(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_get_epg_max_past_days_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_get_epg_max_past_days_v1; /* Autogenerated */ + + if (hdl == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_get_epg_max_past_days_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_get_epg_max_past_days_v1, in, + out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_pvr_get_epg_max_past_days_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + return auto_gen_group.kodi_addon_pvr_get_epg_max_past_days_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_add_menu_hook(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const struct PVR_MENUHOOK* hook) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_add_menu_hook(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const struct PVR_MENUHOOK* hook) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_add_menu_hook_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_add_menu_hook_v1; /* Autogenerated */ + + if (hdl == nullptr || hook == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_add_menu_hook_v1(PtrValue(hdl), hook)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_add_menu_hook_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_add_menu_hook_v1(auto_gen_group.thisClassHdl, hdl, hook); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_recording_notification(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* name, + const char* fileName, + bool on) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_recording_notification(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* name, const char* fileName, bool on) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_recording_notification_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_recording_notification_v1; /* Autogenerated */ + + if (hdl == nullptr || name == nullptr || fileName == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_recording_notification_v1(PtrValue(hdl), name, + fileName, on)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_recording_notification_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_recording_notification_v1(auto_gen_group.thisClassHdl, hdl, name, + fileName, on); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_connection_state_change(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* strConnectionString, + enum PVR_CONNECTION_STATE newState, + const char* strMessage) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_connection_state_change(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* strConnectionString, enum PVR_CONNECTION_STATE newState, const char* strMessage) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_connection_state_change_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_connection_state_change_v1; /* Autogenerated */ + + if (hdl == nullptr || strConnectionString == nullptr || strMessage == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_connection_state_change_v1( + PtrValue(hdl), strConnectionString, newState, strMessage)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_connection_state_change_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_connection_state_change_v1( + auto_gen_group.thisClassHdl, hdl, strConnectionString, newState, strMessage); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_epg_event_state_change(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct EPG_TAG* tag, + enum EPG_EVENT_STATE newState) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_epg_event_state_change(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct EPG_TAG* tag, enum EPG_EVENT_STATE newState) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_epg_event_state_change_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_epg_event_state_change_v1; /* Autogenerated */ + + if (hdl == nullptr || tag == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_addon_pvr_epg_event_state_change_v1(PtrValue(hdl), newState)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_epg_event_state_change_v1, in, + out)) + return; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_pvr_epg_event_state_change_v1 t = ident.get().as(); + + std::get<0>(t).SetCStructure(tag); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_epg_event_state_change_v1(auto_gen_group.thisClassHdl, hdl, tag, + newState); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_entry(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL* chan) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_entry( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_CHANNEL* chan) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_channel_entry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_channel_entry_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || chan == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_transfer_channel_entry_v1( + PtrValue(hdl), PtrValue(handle), chan)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_transfer_channel_entry_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_transfer_channel_entry_v1(auto_gen_group.thisClassHdl, hdl, handle, + chan); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_provider_entry( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_PROVIDER* chanProvider) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_provider_entry( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_PROVIDER* chanProvider) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_provider_entry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_provider_entry_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || chanProvider == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_transfer_provider_entry_v1( + PtrValue(hdl), PtrValue(handle), chanProvider)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_transfer_provider_entry_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_transfer_provider_entry_v1(auto_gen_group.thisClassHdl, hdl, handle, + chanProvider); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_group(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP* group) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_group( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_CHANNEL_GROUP* group) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_channel_group_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_channel_group_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || group == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_transfer_channel_group_v1( + PtrValue(hdl), PtrValue(handle), group)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_transfer_channel_group_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_transfer_channel_group_v1(auto_gen_group.thisClassHdl, hdl, handle, + group); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_group_member( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP_MEMBER* member) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_channel_group_member( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_CHANNEL_GROUP_MEMBER* member) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_channel_group_member_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_channel_group_member_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || member == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_transfer_channel_group_member_v1( + PtrValue(hdl), PtrValue(handle), member)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_transfer_channel_group_member_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_transfer_channel_group_member_v1(auto_gen_group.thisClassHdl, hdl, + handle, member); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_epg_entry(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct EPG_TAG* epgentry) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_epg_entry(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct EPG_TAG* epgentry) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_epg_entry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_epg_entry_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || epgentry == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_transfer_epg_entry_v1( + PtrValue(hdl), PtrValue(handle), epgentry)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_transfer_epg_entry_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_transfer_epg_entry_v1(auto_gen_group.thisClassHdl, hdl, handle, + epgentry); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_recording_entry( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_RECORDING* recording) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_recording_entry( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_RECORDING* recording) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_recording_entry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_recording_entry_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || recording == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_transfer_recording_entry_v1( + PtrValue(hdl), PtrValue(handle), recording)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_transfer_recording_entry_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_transfer_recording_entry_v1(auto_gen_group.thisClassHdl, hdl, + handle, recording); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_timer_entry(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_TIMER* timer) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_transfer_timer_entry(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const KODI_ADDON_PVR_TRANSFER_HDL handle, const struct PVR_TIMER* timer) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_transfer_timer_entry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_transfer_timer_entry_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || timer == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_transfer_timer_entry_v1( + PtrValue(hdl), PtrValue(handle), timer)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_transfer_timer_entry_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_transfer_timer_entry_v1(auto_gen_group.thisClassHdl, hdl, handle, + timer); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_channel_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_channel_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_channel_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_channel_update_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_trigger_channel_update_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_trigger_channel_update_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_trigger_channel_update_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_providers_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_providers_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_providers_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_providers_update_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_trigger_providers_update_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_trigger_providers_update_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_trigger_providers_update_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_channel_groups_update( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_channel_groups_update( KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_channel_groups_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_channel_groups_update_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_trigger_channel_groups_update_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_trigger_channel_groups_update_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_trigger_channel_groups_update_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_epg_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + unsigned int iChannelUid) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_epg_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, unsigned int iChannelUid) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_epg_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_epg_update_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_addon_pvr_trigger_epg_update_v1(PtrValue(hdl), iChannelUid)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_trigger_epg_update_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_trigger_epg_update_v1(auto_gen_group.thisClassHdl, hdl, + iChannelUid); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_recording_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_recording_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_recording_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_recording_update_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_trigger_recording_update_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_trigger_recording_update_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_trigger_recording_update_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_timer_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_pvr_trigger_timer_update(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_pvr_trigger_timer_update_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_pvr_trigger_timer_update_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_pvr_trigger_timer_update_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_pvr_h, funcParent_kodi_addon_pvr_trigger_timer_update_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_pvr_h; + auto_gen_group.kodi_addon_pvr_trigger_timer_update_v1(auto_gen_group.thisClassHdl, hdl); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/pvr.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/pvr.h new file mode 100644 index 0000000000000..b3f7ede654267 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/pvr.h @@ -0,0 +1,340 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/pvr.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_pvr_h; +struct directFuncToKodi_addoninstance_pvr_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_pvr_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_pvr_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_pvr_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static enum PVR_ERROR kodi_addon_pvr_get_capabilities_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + struct PVR_ADDON_CAPABILITIES* capabilities); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_backend_name_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + char* str, + size_t mem_size); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_backend_version_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + char* str, + size_t mem_size); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_backend_hostname_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + char* str, + size_t mem_size); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_connection_string_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, char* str, size_t mem_size); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_drive_space_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + uint64_t* total, + uint64_t* used); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_call_settings_menu_hook_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_channels_amount_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + int* amount); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_channels_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + bool radio); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_channel_stream_properties_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_signal_status_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + int channel_uid, + struct PVR_SIGNAL_STATUS* signal_status); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_descramble_info_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + int channel_uid, + struct PVR_DESCRAMBLE_INFO* descramble_info); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_providers_amount_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + int* amount); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_providers_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_channel_groups_amount_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, int* amount); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_channel_groups_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + bool radio); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_channel_group_members_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + const struct PVR_CHANNEL_GROUP* group); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_delete_channel_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_rename_channel_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_open_dialog_channel_settings_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_open_dialog_channel_add_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_CHANNEL* channel); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_open_dialog_channel_scan_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_call_channel_menu_hook_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_CHANNEL* channel); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_epg_for_channel_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + int channel_uid, + time_t start, + time_t end); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_is_epg_tag_recordable_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + bool* is_recordable); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_is_epg_tag_playable_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + bool* is_playable); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_epg_tag_edl_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + struct PVR_EDL_ENTRY edl[], + size_t* size); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_epg_tag_stream_properties_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct EPG_TAG* tag, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_set_epg_max_past_days_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + int past_days); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_set_epg_max_future_days_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl, int future_days); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_call_epg_menu_hook_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct EPG_TAG* tag); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_recordings_amount_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + bool deleted, + int* amount); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_recordings_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle, + bool deleted); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_delete_recording_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_undelete_recording_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_delete_all_recordings_from_trash_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_rename_recording_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_set_recording_lifetime_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_set_recording_play_count_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int count); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_set_recording_last_played_position_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int last_played_position); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_recording_last_played_position_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int* last_played_position); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_recording_edl_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + struct PVR_EDL_ENTRY edl[], + size_t* size); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_recording_size_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + int64_t* size); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_recording_stream_properties_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_RECORDING* recording, + struct PVR_NAMED_VALUE* properties, + size_t* properties_count); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_call_recording_menu_hook_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_RECORDING* recording); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_timer_types_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + struct PVR_TIMER_TYPE types[], + size_t* types_count); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_timers_amount_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + int* amount); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_get_timers_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + KODI_ADDON_PVR_TRANSFER_HDL handle); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_add_timer_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_TIMER* timer); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_delete_timer_v1(void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_TIMER* timer, + bool force_delete); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_update_timer_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_TIMER* timer); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_call_timer_menu_hook_v1( + void* thisClassHdl, + KODI_ADDON_PVR_HDL hdl, + const struct PVR_MENUHOOK* menuhook, + const struct PVR_TIMER* timer); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_on_system_sleep_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_on_system_wake_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_on_power_saving_activated_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl); // Added with API 1 + + static enum PVR_ERROR kodi_addon_pvr_on_power_saving_deactivated_v1( + void* thisClassHdl, KODI_ADDON_PVR_HDL hdl); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/screensaver.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/screensaver.cpp new file mode 100644 index 0000000000000..aa6b66661ad0f --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/screensaver.cpp @@ -0,0 +1,218 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "screensaver.h" + +#include "src/addon/core/addon_offscreen_render_control.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_screensaver_h::InitDirect( + directFuncToAddon_addoninstance_screensaver_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_screensaver_start_v1 = kodi_addon_screensaver_start_v1; + ifcToAddon->kodi_addon_screensaver_stop_v1 = kodi_addon_screensaver_stop_v1; + ifcToAddon->kodi_addon_screensaver_render_v1 = kodi_addon_screensaver_render_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_screensaver_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_screensaver_h) + return false; + + switch (func) + { + case funcChild_kodi_addon_screensaver_start_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_START_V1)(const KODI_ADDON_SCREENSAVER_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_screensaver_start_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_screensaver_start_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_screensaver_start_v1 t = in.get().as(); + PtrKodiOffscreen kodiOffsetHdl = std::get<0>(t); + uint64_t renderId = std::get<1>(t); + int x = std::get<2>(t); + int y = std::get<3>(t); + int width = std::get<4>(t); + int height = std::get<5>(t); + ADDON_HARDWARE_CONTEXT context = reinterpret_cast(std::get<6>(t)); + IAddonOffscreenRenderControl* auto_gen_render_control = + GenerateOffscreenControl(kodiOffsetHdl, renderId, x, y, width, height, context); + bool auto_gen_render_ret = auto_gen_render_control && auto_gen_render_control->Start(); + + const KODI_ADDON_SCREENSAVER_HDL hdl = + reinterpret_cast(std::get<7>(t)); + bool auto_gen_ret = kodi_addon_screensaver_start_v1(this, hdl); + + msgpack::pack( + out, msgChild_OUT_kodi_addon_screensaver_start_v1( + auto_gen_ret, PtrAddonOffscreen(auto_gen_render_control), auto_gen_render_ret)); + return true; + } + case funcChild_kodi_addon_screensaver_stop_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_STOP_V1)(const KODI_ADDON_SCREENSAVER_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_screensaver_stop_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_screensaver_stop_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_screensaver_stop_v1 t = in.get().as(); + IAddonOffscreenRenderControl* auto_gen_render_control = + reinterpret_cast(std::get<0>(t)); + const KODI_ADDON_SCREENSAVER_HDL hdl = + reinterpret_cast(std::get<1>(t)); + kodi_addon_screensaver_stop_v1(this, hdl); + + if (auto_gen_render_control) + { + { + auto_gen_render_control->Stop(); + delete auto_gen_render_control; + } + } + return true; + } + case funcChild_kodi_addon_screensaver_render_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_SCREENSAVER_RENDER_V1)(const KODI_ADDON_SCREENSAVER_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_screensaver_render_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_screensaver_render_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_screensaver_render_v1 t = in.get().as(); + IAddonOffscreenRenderControl* auto_gen_render_control = + reinterpret_cast(std::get<0>(t)); + if (auto_gen_render_control) + auto_gen_render_control->RenderBegin(); + + const KODI_ADDON_SCREENSAVER_HDL hdl = + reinterpret_cast(std::get<1>(t)); + kodi_addon_screensaver_render_v1(this, hdl); + + if (auto_gen_render_control) + auto_gen_render_control->RenderEnd(); + return true; + } + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +bool CHdl_kodi_addoninstance_screensaver_h::kodi_addon_screensaver_start_v1( + void* thisClassHdl, const KODI_ADDON_SCREENSAVER_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_screensaver.v1.start) + { + auto_gen_ret = union_data->types.kodi_addon_screensaver.v1.start(union_data->hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_screensaver_h::kodi_addon_screensaver_stop_v1( + void* thisClassHdl, const KODI_ADDON_SCREENSAVER_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_screensaver.v1.stop) + { + union_data->types.kodi_addon_screensaver.v1.stop(union_data->hdl); + } +} + +void CHdl_kodi_addoninstance_screensaver_h::kodi_addon_screensaver_render_v1( + void* thisClassHdl, const KODI_ADDON_SCREENSAVER_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_screensaver.v1.render) + { + union_data->types.kodi_addon_screensaver.v1.render(union_data->hdl); + } +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_addon_screensaver_get_properties( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct KODI_ADDON_SCREENSAVER_PROPS* props) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_screensaver_get_properties( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct KODI_ADDON_SCREENSAVER_PROPS* props) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_screensaver_get_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_screensaver_get_properties_v1; /* Autogenerated */ + + if (hdl == nullptr || props == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_screensaver_get_properties_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_screensaver_h, + funcParent_kodi_addon_screensaver_get_properties_v1, in, out)) + return; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_screensaver_get_properties_v1 t = ident.get().as(); + + std::get<0>(t).SetCStructure(props); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_screensaver_h; + auto_gen_group.kodi_addon_screensaver_get_properties_v1(auto_gen_group.thisClassHdl, hdl, props); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/screensaver.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/screensaver.h new file mode 100644 index 0000000000000..780a376c13aa4 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/screensaver.h @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/screensaver.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_screensaver_h; +struct directFuncToKodi_addoninstance_screensaver_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_screensaver_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_screensaver_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_screensaver_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static bool kodi_addon_screensaver_start_v1( + void* thisClassHdl, const KODI_ADDON_SCREENSAVER_HDL hdl); // Added with API 1 + + static void kodi_addon_screensaver_stop_v1( + void* thisClassHdl, const KODI_ADDON_SCREENSAVER_HDL hdl); // Added with API 1 + + static void kodi_addon_screensaver_render_v1( + void* thisClassHdl, const KODI_ADDON_SCREENSAVER_HDL hdl); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/vfs.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/vfs.cpp new file mode 100644 index 0000000000000..19855b1ccc628 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/vfs.cpp @@ -0,0 +1,1080 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "vfs.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_vfs_h::InitDirect(directFuncToAddon_addoninstance_vfs_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_vfs_file_open_v1 = kodi_addon_vfs_file_open_v1; + ifcToAddon->kodi_addon_vfs_file_open_for_write_v1 = kodi_addon_vfs_file_open_for_write_v1; + ifcToAddon->kodi_addon_vfs_file_close_v1 = kodi_addon_vfs_file_close_v1; + ifcToAddon->kodi_addon_vfs_file_read_v1 = kodi_addon_vfs_file_read_v1; + ifcToAddon->kodi_addon_vfs_file_write_v1 = kodi_addon_vfs_file_write_v1; + ifcToAddon->kodi_addon_vfs_file_seek_v1 = kodi_addon_vfs_file_seek_v1; + ifcToAddon->kodi_addon_vfs_file_truncate_v1 = kodi_addon_vfs_file_truncate_v1; + ifcToAddon->kodi_addon_vfs_file_get_length_v1 = kodi_addon_vfs_file_get_length_v1; + ifcToAddon->kodi_addon_vfs_file_get_position_v1 = kodi_addon_vfs_file_get_position_v1; + ifcToAddon->kodi_addon_vfs_file_get_chunk_size_v1 = kodi_addon_vfs_file_get_chunk_size_v1; + ifcToAddon->kodi_addon_vfs_file_io_control_get_seek_possible_v1 = + kodi_addon_vfs_file_io_control_get_seek_possible_v1; + ifcToAddon->kodi_addon_vfs_file_io_control_get_cache_status_v1 = + kodi_addon_vfs_file_io_control_get_cache_status_v1; + ifcToAddon->kodi_addon_vfs_file_io_control_set_cache_rate_v1 = + kodi_addon_vfs_file_io_control_set_cache_rate_v1; + ifcToAddon->kodi_addon_vfs_file_io_control_set_retry_v1 = + kodi_addon_vfs_file_io_control_set_retry_v1; + ifcToAddon->kodi_addon_vfs_stat_v1 = kodi_addon_vfs_stat_v1; + ifcToAddon->kodi_addon_vfs_exists_v1 = kodi_addon_vfs_exists_v1; + ifcToAddon->kodi_addon_vfs_clear_out_idle_v1 = kodi_addon_vfs_clear_out_idle_v1; + ifcToAddon->kodi_addon_vfs_disconnect_all_v1 = kodi_addon_vfs_disconnect_all_v1; + ifcToAddon->kodi_addon_vfs_delete_it_v1 = kodi_addon_vfs_delete_it_v1; + ifcToAddon->kodi_addon_vfs_rename_v1 = kodi_addon_vfs_rename_v1; + ifcToAddon->kodi_addon_vfs_directory_exists_v1 = kodi_addon_vfs_directory_exists_v1; + ifcToAddon->kodi_addon_vfs_directory_remove_v1 = kodi_addon_vfs_directory_remove_v1; + ifcToAddon->kodi_addon_vfs_directory_create_v1 = kodi_addon_vfs_directory_create_v1; + ifcToAddon->kodi_addon_vfs_directory_get_v1 = kodi_addon_vfs_directory_get_v1; + ifcToAddon->kodi_addon_vfs_directory_contains_files_v1 = + kodi_addon_vfs_directory_contains_files_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_vfs_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_vfs_h) + return false; + + switch (func) + { + case funcChild_kodi_addon_vfs_file_open_v1: + { + // Original API call: typedef KODI_VFS_FILE_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_OPEN_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_open_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_open_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + std::get<1>(t).SetCStructure(&url); + KODI_VFS_FILE_HDL auto_gen_ret = kodi_addon_vfs_file_open_v1(this, auto_gen_hdl, &url); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_open_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcChild_kodi_addon_vfs_file_open_for_write_v1: + { + // Original API call: typedef KODI_VFS_FILE_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_OPEN_FOR_WRITE_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, bool overwrite); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_open_for_write_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_open_for_write_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_open_for_write_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + std::get<1>(t).SetCStructure(&url); + bool overwrite = std::get<2>(t); + KODI_VFS_FILE_HDL auto_gen_ret = + kodi_addon_vfs_file_open_for_write_v1(this, auto_gen_hdl, &url, overwrite); + + msgpack::pack(out, + msgChild_OUT_kodi_addon_vfs_file_open_for_write_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcChild_kodi_addon_vfs_file_close_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_CLOSE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_close_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_close_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_close_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + bool auto_gen_ret = kodi_addon_vfs_file_close_v1(this, auto_gen_hdl, context); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_close_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_file_read_v1: + { + // Original API call: typedef ssize_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_READ_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, uint8_t* buffer, size_t buf_size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_read_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple> msgChild_OUT_kodi_addon_vfs_file_read_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_read_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + size_t buf_size = std::get<2>(t); + std::vector buffer(buf_size); + ssize_t auto_gen_ret = + kodi_addon_vfs_file_read_v1(this, auto_gen_hdl, context, buffer.data(), buf_size); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_read_v1(auto_gen_ret, buffer)); + return true; + } + case funcChild_kodi_addon_vfs_file_write_v1: + { + // Original API call: typedef ssize_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_WRITE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, const uint8_t* buffer, size_t buf_size); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_vfs_file_write_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_write_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_write_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + const std::vector& buffer = std::get<2>(t); + size_t buf_size = std::get<3>(t); + ssize_t auto_gen_ret = + kodi_addon_vfs_file_write_v1(this, auto_gen_hdl, context, buffer.data(), buf_size); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_write_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_file_seek_v1: + { + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_SEEK_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, int64_t position, int whence); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_seek_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_seek_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_seek_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + int64_t position = std::get<2>(t); + int whence = std::get<3>(t); + int64_t auto_gen_ret = + kodi_addon_vfs_file_seek_v1(this, auto_gen_hdl, context, position, whence); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_seek_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_file_truncate_v1: + { + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_TRUNCATE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, int64_t size); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_truncate_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_truncate_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_truncate_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + int64_t size = std::get<2>(t); + int auto_gen_ret = kodi_addon_vfs_file_truncate_v1(this, auto_gen_hdl, context, size); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_truncate_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_file_get_length_v1: + { + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_GET_LENGTH_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_get_length_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_get_length_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_get_length_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + int64_t auto_gen_ret = kodi_addon_vfs_file_get_length_v1(this, auto_gen_hdl, context); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_get_length_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_file_get_position_v1: + { + // Original API call: typedef int64_t(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_GET_POSITION_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_get_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_get_position_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_get_position_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + int64_t auto_gen_ret = kodi_addon_vfs_file_get_position_v1(this, auto_gen_hdl, context); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_get_position_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_file_get_chunk_size_v1: + { + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_GET_CHUNK_SIZE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_get_chunk_size_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_get_chunk_size_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_get_chunk_size_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + int auto_gen_ret = kodi_addon_vfs_file_get_chunk_size_v1(this, auto_gen_hdl, context); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_get_chunk_size_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_file_io_control_get_seek_possible_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_GET_SEEK_POSSIBLE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_io_control_get_seek_possible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_io_control_get_seek_possible_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_io_control_get_seek_possible_v1 t = + in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + bool auto_gen_ret = + kodi_addon_vfs_file_io_control_get_seek_possible_v1(this, auto_gen_hdl, context); + + msgpack::pack(out, + msgChild_OUT_kodi_addon_vfs_file_io_control_get_seek_possible_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_file_io_control_get_cache_status_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_GET_CACHE_STATUS_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, struct VFS_CACHE_STATUS* status); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_io_control_get_cache_status_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_io_control_get_cache_status_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_io_control_get_cache_status_v1 t = + in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + struct VFS_CACHE_STATUS status = {}; + bool auto_gen_ret = + kodi_addon_vfs_file_io_control_get_cache_status_v1(this, auto_gen_hdl, context, &status); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_io_control_get_cache_status_v1( + auto_gen_ret, &status)); + return true; + } + case funcChild_kodi_addon_vfs_file_io_control_set_cache_rate_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_SET_CACHE_RATE_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, uint32_t rate); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_io_control_set_cache_rate_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_io_control_set_cache_rate_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_io_control_set_cache_rate_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + uint32_t rate = std::get<2>(t); + bool auto_gen_ret = + kodi_addon_vfs_file_io_control_set_cache_rate_v1(this, auto_gen_hdl, context, rate); + + msgpack::pack(out, + msgChild_OUT_kodi_addon_vfs_file_io_control_set_cache_rate_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_file_io_control_set_retry_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_FILE_IO_CONTROL_SET_RETRY_V1)(const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context, bool retry); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_file_io_control_set_retry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_file_io_control_set_retry_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_file_io_control_set_retry_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_VFS_FILE_HDL context = reinterpret_cast(std::get<1>(t)); + bool retry = std::get<2>(t); + bool auto_gen_ret = + kodi_addon_vfs_file_io_control_set_retry_v1(this, auto_gen_hdl, context, retry); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_file_io_control_set_retry_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_stat_v1: + { + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_STAT_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, struct VFS_STAT_STRUCTURE* buffer); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_stat_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_stat_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_stat_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + std::get<1>(t).SetCStructure(&url); + struct VFS_STAT_STRUCTURE buffer = {}; + int auto_gen_ret = kodi_addon_vfs_stat_v1(this, auto_gen_hdl, &url, &buffer); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_stat_v1(auto_gen_ret, &buffer)); + return true; + } + case funcChild_kodi_addon_vfs_exists_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_EXISTS_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_exists_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_exists_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_exists_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + std::get<1>(t).SetCStructure(&url); + bool auto_gen_ret = kodi_addon_vfs_exists_v1(this, auto_gen_hdl, &url); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_exists_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_clear_out_idle_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_CLEAR_OUT_IDLE_V1)(const KODI_ADDON_VFS_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_clear_out_idle_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_clear_out_idle_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_clear_out_idle_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + kodi_addon_vfs_clear_out_idle_v1(this, auto_gen_hdl); + + return true; + } + case funcChild_kodi_addon_vfs_disconnect_all_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DISCONNECT_ALL_V1)(const KODI_ADDON_VFS_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_disconnect_all_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_disconnect_all_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_disconnect_all_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + kodi_addon_vfs_disconnect_all_v1(this, auto_gen_hdl); + + return true; + } + case funcChild_kodi_addon_vfs_delete_it_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DELETE_IT_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_delete_it_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_delete_it_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_delete_it_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + std::get<1>(t).SetCStructure(&url); + bool auto_gen_ret = kodi_addon_vfs_delete_it_v1(this, auto_gen_hdl, &url); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_delete_it_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_rename_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_RENAME_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, const struct KODI_ADDON_VFS_URL* url2); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_rename_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_rename_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_rename_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + KODI_ADDON_VFS_URL url2; + std::get<1>(t).SetCStructure(&url); + std::get<2>(t).SetCStructure(&url2); + bool auto_gen_ret = kodi_addon_vfs_rename_v1(this, auto_gen_hdl, &url, &url2); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_rename_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_directory_exists_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_EXISTS_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_directory_exists_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_directory_exists_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_directory_exists_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + std::get<1>(t).SetCStructure(&url); + bool auto_gen_ret = kodi_addon_vfs_directory_exists_v1(this, auto_gen_hdl, &url); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_directory_exists_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_directory_remove_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_REMOVE_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_directory_remove_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_directory_remove_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_directory_remove_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + std::get<1>(t).SetCStructure(&url); + bool auto_gen_ret = kodi_addon_vfs_directory_remove_v1(this, auto_gen_hdl, &url); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_directory_remove_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_directory_create_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_CREATE_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_directory_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_vfs_directory_create_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_directory_create_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + std::get<1>(t).SetCStructure(&url); + bool auto_gen_ret = kodi_addon_vfs_directory_create_v1(this, auto_gen_hdl, &url); + + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_directory_create_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_vfs_directory_get_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_GET_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, struct VFS_DIR_ENTRY** entries, size_t* num_entries, KODI_CTX_CB_HDL ctx_cb_hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_directory_get_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_vfs_directory_get_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_directory_get_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + std::get<1>(t).SetCStructure(&url); + struct VFS_DIR_ENTRY* entries = nullptr; + size_t num_entries = std::get<2>(t); + KODI_CTX_CB_HDL ctx_cb_hdl = reinterpret_cast(std::get<3>(t)); + bool auto_gen_ret = kodi_addon_vfs_directory_get_v1(this, auto_gen_hdl, &url, &entries, + &num_entries, ctx_cb_hdl); + + std::vector ifc_entries; + if (entries) + { + ifc_entries.reserve(num_entries); + for (size_t i = 0; i < num_entries; ++i) + { + ifc_entries.emplace_back(&entries[i]); + ifc_entries[i].CleanCStructure(&entries[i]); + } + free(entries); + } + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_directory_get_v1(auto_gen_ret, ifc_entries, + num_entries)); + return true; + } + case funcChild_kodi_addon_vfs_directory_contains_files_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VFS_DIRECTORY_CONTAINS_FILES_V1)(const KODI_ADDON_VFS_HDL hdl, const struct KODI_ADDON_VFS_URL* url, struct VFS_DIR_ENTRY** entries, size_t* num_entries, char** rootpath); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_vfs_directory_contains_files_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t, std::string> msgChild_OUT_kodi_addon_vfs_directory_contains_files_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_vfs_directory_contains_files_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VFS_URL url; + std::get<1>(t).SetCStructure(&url); + struct VFS_DIR_ENTRY* entries = nullptr; + size_t num_entries = std::get<2>(t); + char* rootpath = nullptr; + bool auto_gen_ret = kodi_addon_vfs_directory_contains_files_v1( + this, auto_gen_hdl, &url, &entries, &num_entries, &rootpath); + + std::vector ifc_entries; + if (entries) + { + ifc_entries.reserve(num_entries); + for (size_t i = 0; i < num_entries; ++i) + { + ifc_entries.emplace_back(&entries[i]); + ifc_entries[i].CleanCStructure(&entries[i]); + } + free(entries); + } + msgpack::pack(out, msgChild_OUT_kodi_addon_vfs_directory_contains_files_v1( + auto_gen_ret, ifc_entries, num_entries, rootpath ? rootpath : "")); + if (rootpath) + free(rootpath); + return true; + } + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +KODI_VFS_FILE_HDL CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_open_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + KODI_VFS_FILE_HDL auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_vfs.v1.file_open) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.file_open(union_data->hdl, url); + } + return auto_gen_ret; +} + +KODI_VFS_FILE_HDL CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_open_for_write_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + bool overwrite) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + KODI_VFS_FILE_HDL auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_vfs.v1.file_open_for_write) + { + auto_gen_ret = + union_data->types.kodi_addon_vfs.v1.file_open_for_write(union_data->hdl, url, overwrite); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_close_v1( + void* thisClassHdl, const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.file_close) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.file_close(union_data->hdl, context); + } + return auto_gen_ret; +} + +ssize_t CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_read_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + uint8_t* buffer, + size_t buf_size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + ssize_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_vfs.v1.file_read) + { + auto_gen_ret = + union_data->types.kodi_addon_vfs.v1.file_read(union_data->hdl, context, buffer, buf_size); + } + return auto_gen_ret; +} + +ssize_t CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_write_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + const uint8_t* buffer, + size_t buf_size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + ssize_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_vfs.v1.file_write) + { + auto_gen_ret = + union_data->types.kodi_addon_vfs.v1.file_write(union_data->hdl, context, buffer, buf_size); + } + return auto_gen_ret; +} + +int64_t CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_seek_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t position, + int whence) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int64_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_vfs.v1.file_seek) + { + auto_gen_ret = + union_data->types.kodi_addon_vfs.v1.file_seek(union_data->hdl, context, position, whence); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_truncate_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t size) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_vfs.v1.file_truncate) + { + auto_gen_ret = + union_data->types.kodi_addon_vfs.v1.file_truncate(union_data->hdl, context, size); + } + return auto_gen_ret; +} + +int64_t CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_get_length_v1( + void* thisClassHdl, const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int64_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_vfs.v1.file_get_length) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.file_get_length(union_data->hdl, context); + } + return auto_gen_ret; +} + +int64_t CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_get_position_v1( + void* thisClassHdl, const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int64_t auto_gen_ret = -1; + if (union_data->types.kodi_addon_vfs.v1.file_get_position) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.file_get_position(union_data->hdl, context); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_get_chunk_size_v1( + void* thisClassHdl, const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_vfs.v1.file_get_chunk_size) + { + auto_gen_ret = + union_data->types.kodi_addon_vfs.v1.file_get_chunk_size(union_data->hdl, context); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_io_control_get_seek_possible_v1( + void* thisClassHdl, const KODI_ADDON_VFS_HDL hdl, KODI_VFS_FILE_HDL context) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.file_io_control_get_seek_possible) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.file_io_control_get_seek_possible( + union_data->hdl, context); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_io_control_get_cache_status_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + struct VFS_CACHE_STATUS* status) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.file_io_control_get_cache_status) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.file_io_control_get_cache_status( + union_data->hdl, context, status); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_io_control_set_cache_rate_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + uint32_t rate) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.file_io_control_set_cache_rate) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.file_io_control_set_cache_rate( + union_data->hdl, context, rate); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_file_io_control_set_retry_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + bool retry) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.file_io_control_set_retry) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.file_io_control_set_retry(union_data->hdl, + context, retry); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_stat_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_STAT_STRUCTURE* buffer) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_vfs.v1.stat) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.stat(union_data->hdl, url, buffer); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_exists_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.exists) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.exists(union_data->hdl, url); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_clear_out_idle_v1( + void* thisClassHdl, const KODI_ADDON_VFS_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_vfs.v1.clear_out_idle) + { + union_data->types.kodi_addon_vfs.v1.clear_out_idle(union_data->hdl); + } +} + +void CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_disconnect_all_v1( + void* thisClassHdl, const KODI_ADDON_VFS_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_vfs.v1.disconnect_all) + { + union_data->types.kodi_addon_vfs.v1.disconnect_all(union_data->hdl); + } +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_delete_it_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.delete_it) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.delete_it(union_data->hdl, url); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_rename_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + const struct KODI_ADDON_VFS_URL* url2) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.rename) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.rename(union_data->hdl, url, url2); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_exists_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.directory_exists) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.directory_exists(union_data->hdl, url); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_remove_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.directory_remove) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.directory_remove(union_data->hdl, url); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_create_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.directory_create) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.directory_create(union_data->hdl, url); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_get_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** entries, + size_t* num_entries, + KODI_CTX_CB_HDL ctx_cb_hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.directory_get) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.directory_get(union_data->hdl, url, entries, + num_entries, ctx_cb_hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_vfs_h::kodi_addon_vfs_directory_contains_files_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** entries, + size_t* num_entries, + char** rootpath) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_vfs.v1.directory_contains_files) + { + auto_gen_ret = union_data->types.kodi_addon_vfs.v1.directory_contains_files( + union_data->hdl, url, entries, num_entries, rootpath); + } + return auto_gen_ret; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT bool kodi_addon_vfs_get_dir_cb__get_keyboard_input( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_CTX_CB_HDL ctx_cb_hdl, + const char* heading, + char** input, + bool hidden_input) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_vfs_get_dir_cb__get_keyboard_input( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_CTX_CB_HDL ctx_cb_hdl, const char* heading, char** input, bool hidden_input) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1; /* Autogenerated */ + + if (hdl == nullptr || ctx_cb_hdl == nullptr || heading == nullptr || input == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1( + PtrValue(hdl), PtrValue(ctx_cb_hdl), heading, hidden_input)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_vfs_h, + funcParent_kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1 t = + ident.get().as(); + + *input = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_vfs_h; + return auto_gen_group.kodi_addon_vfs_get_dir_cb__get_keyboard_input_v1( + auto_gen_group.thisClassHdl, hdl, ctx_cb_hdl, heading, input, hidden_input); +} + +ATTR_DLL_EXPORT void kodi_addon_vfs_get_dir_cb__set_error_dialog( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + KODI_CTX_CB_HDL ctx_cb_hdl, + const char* heading, + const char* line1, + const char* line2, + const char* line3) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_vfs_get_dir_cb__set_error_dialog( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_CTX_CB_HDL ctx_cb_hdl, const char* heading, const char* line1, const char* line2, const char* line3) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_vfs_get_dir_cb__set_error_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_vfs_get_dir_cb__set_error_dialog_v1; /* Autogenerated */ + + if (hdl == nullptr || ctx_cb_hdl == nullptr || heading == nullptr || line1 == nullptr || + line2 == nullptr || line3 == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_vfs_get_dir_cb__set_error_dialog_v1( + PtrValue(hdl), PtrValue(ctx_cb_hdl), heading, line1, line2, line3)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_vfs_h, funcParent_kodi_addon_vfs_get_dir_cb__set_error_dialog_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_vfs_h; + auto_gen_group.kodi_addon_vfs_get_dir_cb__set_error_dialog_v1( + auto_gen_group.thisClassHdl, hdl, ctx_cb_hdl, heading, line1, line2, line3); +} + +ATTR_DLL_EXPORT void kodi_addon_vfs_get_dir_cb__require_authentication( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_CTX_CB_HDL ctx_cb_hdl, const char* url) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_vfs_get_dir_cb__require_authentication( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, KODI_CTX_CB_HDL ctx_cb_hdl, const char* url) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_vfs_get_dir_cb__require_authentication_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_vfs_get_dir_cb__require_authentication_v1; /* Autogenerated */ + + if (hdl == nullptr || ctx_cb_hdl == nullptr || url == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_vfs_get_dir_cb__require_authentication_v1( + PtrValue(hdl), PtrValue(ctx_cb_hdl), url)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_vfs_h, + funcParent_kodi_addon_vfs_get_dir_cb__require_authentication_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_vfs_h; + auto_gen_group.kodi_addon_vfs_get_dir_cb__require_authentication_v1(auto_gen_group.thisClassHdl, + hdl, ctx_cb_hdl, url); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/vfs.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/vfs.h new file mode 100644 index 0000000000000..6c6e296a67ae4 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/vfs.h @@ -0,0 +1,184 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/vfs.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_vfs_h; +struct directFuncToKodi_addoninstance_vfs_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_vfs_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_vfs_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_vfs_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static KODI_VFS_FILE_HDL kodi_addon_vfs_file_open_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + static KODI_VFS_FILE_HDL kodi_addon_vfs_file_open_for_write_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + bool overwrite); // Added with API 1 + + static bool kodi_addon_vfs_file_close_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context); // Added with API 1 + + static ssize_t kodi_addon_vfs_file_read_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + uint8_t* buffer, + size_t buf_size); // Added with API 1 + + static ssize_t kodi_addon_vfs_file_write_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + const uint8_t* buffer, + size_t buf_size); // Added with API 1 + + static int64_t kodi_addon_vfs_file_seek_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t position, + int whence); // Added with API 1 + + static int kodi_addon_vfs_file_truncate_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + int64_t size); // Added with API 1 + + static int64_t kodi_addon_vfs_file_get_length_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context); // Added with API 1 + + static int64_t kodi_addon_vfs_file_get_position_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context); // Added with API 1 + + static int kodi_addon_vfs_file_get_chunk_size_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context); // Added with API 1 + + static bool kodi_addon_vfs_file_io_control_get_seek_possible_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context); // Added with API 1 + + static bool kodi_addon_vfs_file_io_control_get_cache_status_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + struct VFS_CACHE_STATUS* status); // Added with API 1 + + static bool kodi_addon_vfs_file_io_control_set_cache_rate_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + uint32_t rate); // Added with API 1 + + static bool kodi_addon_vfs_file_io_control_set_retry_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + KODI_VFS_FILE_HDL context, + bool retry); // Added with API 1 + + static int kodi_addon_vfs_stat_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_STAT_STRUCTURE* buffer); // Added with API 1 + + static bool kodi_addon_vfs_exists_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + static void kodi_addon_vfs_clear_out_idle_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl); // Added with API 1 + + static void kodi_addon_vfs_disconnect_all_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl); // Added with API 1 + + static bool kodi_addon_vfs_delete_it_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + static bool kodi_addon_vfs_rename_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + const struct KODI_ADDON_VFS_URL* url2); // Added with API 1 + + static bool kodi_addon_vfs_directory_exists_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + static bool kodi_addon_vfs_directory_remove_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + static bool kodi_addon_vfs_directory_create_v1( + void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url); // Added with API 1 + + static bool kodi_addon_vfs_directory_get_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** entries, + size_t* num_entries, + KODI_CTX_CB_HDL ctx_cb_hdl); // Added with API 1 + + static bool kodi_addon_vfs_directory_contains_files_v1(void* thisClassHdl, + const KODI_ADDON_VFS_HDL hdl, + const struct KODI_ADDON_VFS_URL* url, + struct VFS_DIR_ENTRY** entries, + size_t* num_entries, + char** rootpath); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/videocodec.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/videocodec.cpp new file mode 100644 index 0000000000000..d59361f2fe822 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/videocodec.cpp @@ -0,0 +1,234 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "videocodec.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_videocodec_h::InitDirect( + directFuncToAddon_addoninstance_videocodec_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_videocodec_create_v1 = kodi_addon_videocodec_create_v1; + ifcToAddon->kodi_addon_videocodec_destroy_v1 = kodi_addon_videocodec_destroy_v1; + ifcToAddon->kodi_addon_videocodec_open_v1 = kodi_addon_videocodec_open_v1; + ifcToAddon->kodi_addon_videocodec_reconfigure_v1 = kodi_addon_videocodec_reconfigure_v1; + ifcToAddon->kodi_addon_videocodec_add_data_v1 = kodi_addon_videocodec_add_data_v1; + ifcToAddon->kodi_addon_videocodec_get_picture_v1 = kodi_addon_videocodec_get_picture_v1; + ifcToAddon->kodi_addon_videocodec_get_name_v1 = kodi_addon_videocodec_get_name_v1; + ifcToAddon->kodi_addon_videocodec_reset_v1 = kodi_addon_videocodec_reset_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_videocodec_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_videocodec_h) + return false; + + switch (func) + { + /* NOTE: Ignored as direct api only is set! */ + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +KODI_ADDON_VIDEOCODEC_HDL CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_create_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(kodi_hdl); + KODI_ADDON_VIDEOCODEC_HDL auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_videocodec.v1.create) + { + auto_gen_ret = union_data->types.kodi_addon_videocodec.v1.create(kodi_hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_destroy_v1( + void* thisClassHdl, KODI_ADDON_VIDEOCODEC_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_videocodec.v1.destroy) + { + union_data->types.kodi_addon_videocodec.v1.destroy(union_data->hdl); + } +} + +bool CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_open_v1( + void* thisClassHdl, + KODI_ADDON_VIDEOCODEC_HDL hdl, + struct VIDEOCODEC_INITDATA* initData) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_videocodec.v1.open) + { + auto_gen_ret = union_data->types.kodi_addon_videocodec.v1.open(union_data->hdl, initData); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_reconfigure_v1( + void* thisClassHdl, + KODI_ADDON_VIDEOCODEC_HDL hdl, + struct VIDEOCODEC_INITDATA* initData) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_videocodec.v1.reconfigure) + { + auto_gen_ret = + union_data->types.kodi_addon_videocodec.v1.reconfigure(union_data->hdl, initData); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_add_data_v1( + void* thisClassHdl, + KODI_ADDON_VIDEOCODEC_HDL hdl, + const struct DEMUX_PACKET* packet) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_videocodec.v1.add_data) + { + auto_gen_ret = union_data->types.kodi_addon_videocodec.v1.add_data(union_data->hdl, packet); + } + return auto_gen_ret; +} + +enum VIDEOCODEC_RETVAL CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_get_picture_v1( + void* thisClassHdl, + KODI_ADDON_VIDEOCODEC_HDL hdl, + struct VIDEOCODEC_PICTURE* picture) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return VC_NONE; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum VIDEOCODEC_RETVAL auto_gen_ret = VC_NONE; + if (union_data->types.kodi_addon_videocodec.v1.get_picture) + { + auto_gen_ret = union_data->types.kodi_addon_videocodec.v1.get_picture(union_data->hdl, picture); + } + return auto_gen_ret; +} + +const char* CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_get_name_v1( + void* thisClassHdl, KODI_ADDON_VIDEOCODEC_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + const char* auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_videocodec.v1.get_name) + { + auto_gen_ret = union_data->types.kodi_addon_videocodec.v1.get_name(union_data->hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_videocodec_h::kodi_addon_videocodec_reset_v1( + void* thisClassHdl, KODI_ADDON_VIDEOCODEC_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_videocodec.v1.reset) + { + union_data->types.kodi_addon_videocodec.v1.reset(union_data->hdl); + } +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT bool kodi_addon_videocodec_get_frame_buffer(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct VIDEOCODEC_PICTURE* picture) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_videocodec_get_frame_buffer(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct VIDEOCODEC_PICTURE* picture) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || picture == nullptr) + return false; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_videocodec_h; + return auto_gen_group.kodi_addon_videocodec_get_frame_buffer_v1(auto_gen_group.thisClassHdl, hdl, + picture); +} + +ATTR_DLL_EXPORT void kodi_addon_videocodec_release_frame_buffer(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + struct VIDEOCODEC_PICTURE* picture) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_videocodec_release_frame_buffer( KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct VIDEOCODEC_PICTURE* picture) __INTRODUCED_IN_KODI(1); + if (hdl == nullptr || picture == nullptr) + return; + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_videocodec_h; + auto_gen_group.kodi_addon_videocodec_release_frame_buffer_v1(auto_gen_group.thisClassHdl, hdl, + picture); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/videocodec.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/videocodec.h new file mode 100644 index 0000000000000..bef8d52697fb7 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/videocodec.h @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/videocodec.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_videocodec_h; +struct directFuncToKodi_addoninstance_videocodec_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_videocodec_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_videocodec_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_videocodec_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static KODI_ADDON_VIDEOCODEC_HDL kodi_addon_videocodec_create_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); // Added with API 1 + + static void kodi_addon_videocodec_destroy_v1(void* thisClassHdl, + KODI_ADDON_VIDEOCODEC_HDL hdl); // Added with API 1 + + static bool kodi_addon_videocodec_open_v1( + void* thisClassHdl, + KODI_ADDON_VIDEOCODEC_HDL hdl, + struct VIDEOCODEC_INITDATA* initData); // Added with API 1 + + static bool kodi_addon_videocodec_reconfigure_v1( + void* thisClassHdl, + KODI_ADDON_VIDEOCODEC_HDL hdl, + struct VIDEOCODEC_INITDATA* initData); // Added with API 1 + + static bool kodi_addon_videocodec_add_data_v1( + void* thisClassHdl, + KODI_ADDON_VIDEOCODEC_HDL hdl, + const struct DEMUX_PACKET* packet); // Added with API 1 + + static enum VIDEOCODEC_RETVAL kodi_addon_videocodec_get_picture_v1( + void* thisClassHdl, + KODI_ADDON_VIDEOCODEC_HDL hdl, + struct VIDEOCODEC_PICTURE* picture); // Added with API 1 + + static const char* kodi_addon_videocodec_get_name_v1( + void* thisClassHdl, KODI_ADDON_VIDEOCODEC_HDL hdl); // Added with API 1 + + static void kodi_addon_videocodec_reset_v1(void* thisClassHdl, + KODI_ADDON_VIDEOCODEC_HDL hdl); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/visualization.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/visualization.cpp new file mode 100644 index 0000000000000..4faae208e6ab9 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/visualization.cpp @@ -0,0 +1,734 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "visualization.h" + +#include "src/addon/core/addon_offscreen_render_control.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_visualization_h::InitDirect( + directFuncToAddon_addoninstance_visualization_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_visualization_start_v1 = kodi_addon_visualization_start_v1; + ifcToAddon->kodi_addon_visualization_stop_v1 = kodi_addon_visualization_stop_v1; + ifcToAddon->kodi_addon_visualization_get_sync_delay_v1 = + kodi_addon_visualization_get_sync_delay_v1; + ifcToAddon->kodi_addon_visualization_audio_data_v1 = kodi_addon_visualization_audio_data_v1; + ifcToAddon->kodi_addon_visualization_is_dirty_v1 = kodi_addon_visualization_is_dirty_v1; + ifcToAddon->kodi_addon_visualization_render_v1 = kodi_addon_visualization_render_v1; + ifcToAddon->kodi_addon_visualization_get_presets_v1 = kodi_addon_visualization_get_presets_v1; + ifcToAddon->kodi_addon_visualization_get_active_preset_v1 = + kodi_addon_visualization_get_active_preset_v1; + ifcToAddon->kodi_addon_visualization_prev_preset_v1 = kodi_addon_visualization_prev_preset_v1; + ifcToAddon->kodi_addon_visualization_next_preset_v1 = kodi_addon_visualization_next_preset_v1; + ifcToAddon->kodi_addon_visualization_load_preset_v1 = kodi_addon_visualization_load_preset_v1; + ifcToAddon->kodi_addon_visualization_random_preset_v1 = kodi_addon_visualization_random_preset_v1; + ifcToAddon->kodi_addon_visualization_lock_preset_v1 = kodi_addon_visualization_lock_preset_v1; + ifcToAddon->kodi_addon_visualization_rate_preset_v1 = kodi_addon_visualization_rate_preset_v1; + ifcToAddon->kodi_addon_visualization_is_locked_v1 = kodi_addon_visualization_is_locked_v1; + ifcToAddon->kodi_addon_visualization_update_albumart_v1 = + kodi_addon_visualization_update_albumart_v1; + ifcToAddon->kodi_addon_visualization_update_track_v1 = kodi_addon_visualization_update_track_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_visualization_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_visualization_h) + return false; + + switch (func) + { + case funcChild_kodi_addon_visualization_start_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_START_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, int channels, int samples_per_sec, int bits_per_sample, const char* song_name); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_start_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_start_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_start_v1 t = in.get().as(); + PtrKodiOffscreen kodiOffsetHdl = std::get<0>(t); + uint64_t renderId = std::get<1>(t); + int x = std::get<2>(t); + int y = std::get<3>(t); + int width = std::get<4>(t); + int height = std::get<5>(t); + ADDON_HARDWARE_CONTEXT context = reinterpret_cast(std::get<6>(t)); + IAddonOffscreenRenderControl* auto_gen_render_control = + GenerateOffscreenControl(kodiOffsetHdl, renderId, x, y, width, height, context); + bool auto_gen_render_ret = auto_gen_render_control && auto_gen_render_control->Start(); + + const KODI_ADDON_VISUALIZATION_HDL hdl = + reinterpret_cast(std::get<7>(t)); + int channels = std::get<8>(t); + int samples_per_sec = std::get<9>(t); + int bits_per_sample = std::get<10>(t); + const std::string& song_name = std::get<11>(t); + bool auto_gen_ret = kodi_addon_visualization_start_v1(this, hdl, channels, samples_per_sec, + bits_per_sample, song_name.c_str()); + + msgpack::pack( + out, msgChild_OUT_kodi_addon_visualization_start_v1( + auto_gen_ret, PtrAddonOffscreen(auto_gen_render_control), auto_gen_render_ret)); + return true; + } + case funcChild_kodi_addon_visualization_stop_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_STOP_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_stop_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_stop_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_stop_v1 t = in.get().as(); + IAddonOffscreenRenderControl* auto_gen_render_control = + reinterpret_cast(std::get<0>(t)); + const KODI_ADDON_VISUALIZATION_HDL hdl = + reinterpret_cast(std::get<1>(t)); + kodi_addon_visualization_stop_v1(this, hdl); + + if (auto_gen_render_control) + { + { + auto_gen_render_control->Stop(); + delete auto_gen_render_control; + } + } + return true; + } + case funcChild_kodi_addon_visualization_get_sync_delay_v1: + { + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_GET_SYNC_DELAY_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_get_sync_delay_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_get_sync_delay_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_get_sync_delay_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + int auto_gen_ret = kodi_addon_visualization_get_sync_delay_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_get_sync_delay_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_audio_data_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_AUDIO_DATA_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, const float* audio_data, size_t audio_data_length); + // Tuple in: typedef std::tuple, size_t> msgChild__IN_kodi_addon_visualization_audio_data_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_audio_data_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_audio_data_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::vector& audio_data = std::get<1>(t); + size_t audio_data_length = std::get<2>(t); + kodi_addon_visualization_audio_data_v1(this, auto_gen_hdl, audio_data.data(), + audio_data_length); + + return true; + } + case funcChild_kodi_addon_visualization_is_dirty_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_IS_DIRTY_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_is_dirty_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_is_dirty_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_is_dirty_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + bool auto_gen_ret = kodi_addon_visualization_is_dirty_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_is_dirty_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_render_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_RENDER_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_render_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_render_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_render_v1 t = in.get().as(); + IAddonOffscreenRenderControl* auto_gen_render_control = + reinterpret_cast(std::get<0>(t)); + if (auto_gen_render_control) + auto_gen_render_control->RenderBegin(); + + const KODI_ADDON_VISUALIZATION_HDL hdl = + reinterpret_cast(std::get<1>(t)); + kodi_addon_visualization_render_v1(this, hdl); + + if (auto_gen_render_control) + auto_gen_render_control->RenderEnd(); + return true; + } + case funcChild_kodi_addon_visualization_get_presets_v1: + { + // Original API call: typedef unsigned int(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_GET_PRESETS_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_get_presets_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_get_presets_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_get_presets_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + unsigned int auto_gen_ret = kodi_addon_visualization_get_presets_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_get_presets_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_get_active_preset_v1: + { + // Original API call: typedef int(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_GET_ACTIVE_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_get_active_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_get_active_preset_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_get_active_preset_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + int auto_gen_ret = kodi_addon_visualization_get_active_preset_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_get_active_preset_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_prev_preset_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_PREV_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_prev_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_prev_preset_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_prev_preset_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + bool auto_gen_ret = kodi_addon_visualization_prev_preset_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_prev_preset_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_next_preset_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_NEXT_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_next_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_next_preset_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_next_preset_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + bool auto_gen_ret = kodi_addon_visualization_next_preset_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_next_preset_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_load_preset_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_LOAD_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, int select); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_load_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_load_preset_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_load_preset_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + int select = std::get<1>(t); + bool auto_gen_ret = kodi_addon_visualization_load_preset_v1(this, auto_gen_hdl, select); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_load_preset_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_random_preset_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_RANDOM_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_random_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_random_preset_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_random_preset_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + bool auto_gen_ret = kodi_addon_visualization_random_preset_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_random_preset_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_lock_preset_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_LOCK_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_lock_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_lock_preset_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_lock_preset_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + bool auto_gen_ret = kodi_addon_visualization_lock_preset_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_lock_preset_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_rate_preset_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_RATE_PRESET_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, bool plus_minus); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_rate_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_rate_preset_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_rate_preset_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + bool plus_minus = std::get<1>(t); + bool auto_gen_ret = kodi_addon_visualization_rate_preset_v1(this, auto_gen_hdl, plus_minus); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_rate_preset_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_is_locked_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_IS_LOCKED_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_is_locked_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_is_locked_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_is_locked_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + bool auto_gen_ret = kodi_addon_visualization_is_locked_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_is_locked_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_update_albumart_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_UPDATE_ALBUMART_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, const char* albumart); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_update_albumart_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_update_albumart_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_update_albumart_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& albumart = std::get<1>(t); + bool auto_gen_ret = + kodi_addon_visualization_update_albumart_v1(this, auto_gen_hdl, albumart.c_str()); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_update_albumart_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_visualization_update_track_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_VISUALIZATION_UPDATE_TRACK_V1)(const KODI_ADDON_VISUALIZATION_HDL hdl, const struct KODI_ADDON_VISUALIZATION_TRACK* track); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_visualization_update_track_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_visualization_update_track_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_visualization_update_track_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_VISUALIZATION_TRACK track; + std::get<1>(t).SetCStructure(&track); + bool auto_gen_ret = kodi_addon_visualization_update_track_v1(this, auto_gen_hdl, &track); + + msgpack::pack(out, msgChild_OUT_kodi_addon_visualization_update_track_v1(auto_gen_ret)); + return true; + } + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_start_v1( + void* thisClassHdl, + const KODI_ADDON_VISUALIZATION_HDL hdl, + int channels, + int samples_per_sec, + int bits_per_sample, + const char* song_name) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.start) + { + auto_gen_ret = union_data->types.kodi_addon_visualization.v1.start( + union_data->hdl, channels, samples_per_sec, bits_per_sample, song_name); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_stop_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_visualization.v1.stop) + { + union_data->types.kodi_addon_visualization.v1.stop(union_data->hdl); + } +} + +int CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_get_sync_delay_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_visualization.v1.get_sync_delay) + { + auto_gen_ret = union_data->types.kodi_addon_visualization.v1.get_sync_delay(union_data->hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_audio_data_v1( + void* thisClassHdl, + const KODI_ADDON_VISUALIZATION_HDL hdl, + const float* audio_data, + size_t audio_data_length) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_visualization.v1.audio_data) + { + union_data->types.kodi_addon_visualization.v1.audio_data(union_data->hdl, audio_data, + audio_data_length); + } +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_is_dirty_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.is_dirty) + { + auto_gen_ret = union_data->types.kodi_addon_visualization.v1.is_dirty(union_data->hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_render_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_visualization.v1.render) + { + union_data->types.kodi_addon_visualization.v1.render(union_data->hdl); + } +} + +unsigned int CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_get_presets_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return 0; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + unsigned int auto_gen_ret = 0; + if (union_data->types.kodi_addon_visualization.v1.get_presets) + { + auto_gen_ret = union_data->types.kodi_addon_visualization.v1.get_presets(union_data->hdl); + } + return auto_gen_ret; +} + +int CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_get_active_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return -1; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + int auto_gen_ret = -1; + if (union_data->types.kodi_addon_visualization.v1.get_active_preset) + { + auto_gen_ret = union_data->types.kodi_addon_visualization.v1.get_active_preset(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_prev_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.prev_preset) + { + auto_gen_ret = union_data->types.kodi_addon_visualization.v1.prev_preset(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_next_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.next_preset) + { + auto_gen_ret = union_data->types.kodi_addon_visualization.v1.next_preset(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_load_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl, int select) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.load_preset) + { + auto_gen_ret = + union_data->types.kodi_addon_visualization.v1.load_preset(union_data->hdl, select); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_random_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.random_preset) + { + auto_gen_ret = union_data->types.kodi_addon_visualization.v1.random_preset(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_lock_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.lock_preset) + { + auto_gen_ret = union_data->types.kodi_addon_visualization.v1.lock_preset(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_rate_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl, bool plus_minus) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.rate_preset) + { + auto_gen_ret = + union_data->types.kodi_addon_visualization.v1.rate_preset(union_data->hdl, plus_minus); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_is_locked_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.is_locked) + { + auto_gen_ret = union_data->types.kodi_addon_visualization.v1.is_locked(union_data->hdl); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_update_albumart_v1( + void* thisClassHdl, + const KODI_ADDON_VISUALIZATION_HDL hdl, + const char* albumart) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.update_albumart) + { + auto_gen_ret = + union_data->types.kodi_addon_visualization.v1.update_albumart(union_data->hdl, albumart); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_visualization_h::kodi_addon_visualization_update_track_v1( + void* thisClassHdl, + const KODI_ADDON_VISUALIZATION_HDL hdl, + const struct KODI_ADDON_VISUALIZATION_TRACK* track) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_visualization.v1.update_track) + { + auto_gen_ret = + union_data->types.kodi_addon_visualization.v1.update_track(union_data->hdl, track); + } + return auto_gen_ret; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_addon_visualization_get_properties( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct KODI_ADDON_VISUALIZATION_PROPS* props) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_visualization_get_properties(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, struct KODI_ADDON_VISUALIZATION_PROPS* props) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_visualization_get_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_visualization_get_properties_v1; /* Autogenerated */ + + if (hdl == nullptr || props == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_visualization_get_properties_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_visualization_h, + funcParent_kodi_addon_visualization_get_properties_v1, in, out)) + return; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_visualization_get_properties_v1 t = ident.get().as(); + + std::get<0>(t).SetCStructure(props); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_visualization_h; + auto_gen_group.kodi_addon_visualization_get_properties_v1(auto_gen_group.thisClassHdl, hdl, + props); +} + +ATTR_DLL_EXPORT void kodi_addon_visualization_transfer_preset( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* preset) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_visualization_transfer_preset(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* preset) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_visualization_transfer_preset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_visualization_transfer_preset_v1; /* Autogenerated */ + + if (hdl == nullptr || preset == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_addon_visualization_transfer_preset_v1(PtrValue(hdl), preset)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_visualization_h, + funcParent_kodi_addon_visualization_transfer_preset_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_visualization_h; + auto_gen_group.kodi_addon_visualization_transfer_preset_v1(auto_gen_group.thisClassHdl, hdl, + preset); +} + +ATTR_DLL_EXPORT void kodi_addon_visualization_clear_presets( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_visualization_clear_presets(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_visualization_clear_presets_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_visualization_clear_presets_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_visualization_clear_presets_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_visualization_h, + funcParent_kodi_addon_visualization_clear_presets_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_visualization_h; + auto_gen_group.kodi_addon_visualization_clear_presets_v1(auto_gen_group.thisClassHdl, hdl); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/visualization.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/visualization.h new file mode 100644 index 0000000000000..b7c68a19546d8 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/visualization.h @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/visualization.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_visualization_h; +struct directFuncToKodi_addoninstance_visualization_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_visualization_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_visualization_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_visualization_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static bool kodi_addon_visualization_start_v1(void* thisClassHdl, + const KODI_ADDON_VISUALIZATION_HDL hdl, + int channels, + int samples_per_sec, + int bits_per_sample, + const char* song_name); // Added with API 1 + + static void kodi_addon_visualization_stop_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static int kodi_addon_visualization_get_sync_delay_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static void kodi_addon_visualization_audio_data_v1(void* thisClassHdl, + const KODI_ADDON_VISUALIZATION_HDL hdl, + const float* audio_data, + size_t audio_data_length); // Added with API 1 + + static bool kodi_addon_visualization_is_dirty_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static void kodi_addon_visualization_render_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static unsigned int kodi_addon_visualization_get_presets_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static int kodi_addon_visualization_get_active_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static bool kodi_addon_visualization_prev_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static bool kodi_addon_visualization_next_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static bool kodi_addon_visualization_load_preset_v1(void* thisClassHdl, + const KODI_ADDON_VISUALIZATION_HDL hdl, + int select); // Added with API 1 + + static bool kodi_addon_visualization_random_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static bool kodi_addon_visualization_lock_preset_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static bool kodi_addon_visualization_rate_preset_v1(void* thisClassHdl, + const KODI_ADDON_VISUALIZATION_HDL hdl, + bool plus_minus); // Added with API 1 + + static bool kodi_addon_visualization_is_locked_v1( + void* thisClassHdl, const KODI_ADDON_VISUALIZATION_HDL hdl); // Added with API 1 + + static bool kodi_addon_visualization_update_albumart_v1(void* thisClassHdl, + const KODI_ADDON_VISUALIZATION_HDL hdl, + const char* albumart); // Added with API 1 + + static bool kodi_addon_visualization_update_track_v1( + void* thisClassHdl, + const KODI_ADDON_VISUALIZATION_HDL hdl, + const struct KODI_ADDON_VISUALIZATION_TRACK* track); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/web.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/web.cpp new file mode 100644 index 0000000000000..5a5506355b1da --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/web.cpp @@ -0,0 +1,1329 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "web.h" + +#include "src/addon/core/addon_offscreen_render_control.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addoninstance_web_h::InitDirect(directFuncToAddon_addoninstance_web_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_web_start_instance_v1 = kodi_addon_web_start_instance_v1; + ifcToAddon->kodi_addon_web_stop_instance_v1 = kodi_addon_web_stop_instance_v1; + ifcToAddon->kodi_addon_web_main_initialize_v1 = kodi_addon_web_main_initialize_v1; + ifcToAddon->kodi_addon_web_main_loop_v1 = kodi_addon_web_main_loop_v1; + ifcToAddon->kodi_addon_web_main_shutdown_v1 = kodi_addon_web_main_shutdown_v1; + ifcToAddon->kodi_addon_web_set_mute_v1 = kodi_addon_web_set_mute_v1; + ifcToAddon->kodi_addon_web_set_language_v1 = kodi_addon_web_set_language_v1; + ifcToAddon->kodi_addon_web_create_control_v1 = kodi_addon_web_create_control_v1; + ifcToAddon->kodi_addon_web_destroy_control_v1 = kodi_addon_web_destroy_control_v1; + ifcToAddon->kodi_addon_web_control_render_init_v1 = kodi_addon_web_control_render_init_v1; + ifcToAddon->kodi_addon_web_control_render_deinit_v1 = kodi_addon_web_control_render_deinit_v1; + ifcToAddon->kodi_addon_web_control_render_v1 = kodi_addon_web_control_render_v1; + ifcToAddon->kodi_addon_web_control_dirty_v1 = kodi_addon_web_control_dirty_v1; + ifcToAddon->kodi_addon_web_control_on_init_v1 = kodi_addon_web_control_on_init_v1; + ifcToAddon->kodi_addon_web_control_on_action_v1 = kodi_addon_web_control_on_action_v1; + ifcToAddon->kodi_addon_web_control_on_mouse_event_v1 = kodi_addon_web_control_on_mouse_event_v1; + ifcToAddon->kodi_addon_web_control_open_website_v1 = kodi_addon_web_control_open_website_v1; + ifcToAddon->kodi_addon_web_control_get_history_v1 = kodi_addon_web_control_get_history_v1; + ifcToAddon->kodi_addon_web_control_search_text_v1 = kodi_addon_web_control_search_text_v1; + ifcToAddon->kodi_addon_web_control_stop_search_v1 = kodi_addon_web_control_stop_search_v1; + ifcToAddon->kodi_addon_web_control_web_cmd_reload_v1 = kodi_addon_web_control_web_cmd_reload_v1; + ifcToAddon->kodi_addon_web_control_web_cmd_stop_load_v1 = + kodi_addon_web_control_web_cmd_stop_load_v1; + ifcToAddon->kodi_addon_web_control_web_cmd_nav_back_v1 = + kodi_addon_web_control_web_cmd_nav_back_v1; + ifcToAddon->kodi_addon_web_control_web_cmd_nav_forward_v1 = + kodi_addon_web_control_web_cmd_nav_forward_v1; + ifcToAddon->kodi_addon_web_control_web_open_own_context_menu_v1 = + kodi_addon_web_control_web_open_own_context_menu_v1; + ifcToAddon->kodi_addon_web_control_screen_size_change_v1 = + kodi_addon_web_control_screen_size_change_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addoninstance_web_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addoninstance_web_h) + return false; + + switch (func) + { + case funcChild_kodi_addon_web_start_instance_v1: + { + // Original API call: typedef enum WEB_ADDON_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_START_INSTANCE_V1)(const KODI_ADDON_WEB_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_start_instance_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_start_instance_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_start_instance_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + enum WEB_ADDON_ERROR auto_gen_ret = kodi_addon_web_start_instance_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_web_start_instance_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_web_stop_instance_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_STOP_INSTANCE_V1)(const KODI_ADDON_WEB_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_stop_instance_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_stop_instance_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_stop_instance_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + kodi_addon_web_stop_instance_v1(this, auto_gen_hdl); + + return true; + } + case funcChild_kodi_addon_web_main_initialize_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_MAIN_INITIALIZE_V1)(const KODI_ADDON_WEB_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_main_initialize_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_main_initialize_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_main_initialize_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + bool auto_gen_ret = kodi_addon_web_main_initialize_v1(this, auto_gen_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_web_main_initialize_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_web_main_loop_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_MAIN_LOOP_V1)(const KODI_ADDON_WEB_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_main_loop_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_main_loop_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_main_loop_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + kodi_addon_web_main_loop_v1(this, auto_gen_hdl); + + return true; + } + case funcChild_kodi_addon_web_main_shutdown_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_MAIN_SHUTDOWN_V1)(const KODI_ADDON_WEB_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_main_shutdown_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_main_shutdown_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_main_shutdown_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + kodi_addon_web_main_shutdown_v1(this, auto_gen_hdl); + + return true; + } + case funcChild_kodi_addon_web_set_mute_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_SET_MUTE_V1)(const KODI_ADDON_WEB_HDL hdl, bool mute); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_set_mute_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_set_mute_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_set_mute_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + bool mute = std::get<1>(t); + kodi_addon_web_set_mute_v1(this, auto_gen_hdl, mute); + + return true; + } + case funcChild_kodi_addon_web_set_language_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_SET_LANGUAGE_V1)(const KODI_ADDON_WEB_HDL hdl, const char* language); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_set_language_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_set_language_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_set_language_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& language = std::get<1>(t); + bool auto_gen_ret = kodi_addon_web_set_language_v1(this, auto_gen_hdl, language.c_str()); + + msgpack::pack(out, msgChild_OUT_kodi_addon_web_set_language_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_web_create_control_v1: + { + // Original API call: typedef enum WEB_ADDON_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CREATE_CONTROL_V1)(const KODI_ADDON_WEB_HDL hdl, const struct WEB_ADDON_GUI_PROPS* props, const char* start_url, WEB_KODI_CONTROL* handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_create_control_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_create_control_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_create_control_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + WEB_ADDON_GUI_PROPS props; + std::get<1>(t).SetCStructure(&props); + const std::string& start_url = std::get<2>(t); + WEB_KODI_CONTROL handle = nullptr; + enum WEB_ADDON_ERROR auto_gen_ret = + kodi_addon_web_create_control_v1(this, auto_gen_hdl, &props, start_url.c_str(), &handle); + + msgpack::pack(out, + msgChild_OUT_kodi_addon_web_create_control_v1(auto_gen_ret, PtrValue(handle))); + return true; + } + case funcChild_kodi_addon_web_destroy_control_v1: + { + // Original API call: typedef enum WEB_ADDON_ERROR(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_DESTROY_CONTROL_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, bool complete); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_destroy_control_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_destroy_control_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_destroy_control_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + bool complete = std::get<2>(t); + enum WEB_ADDON_ERROR auto_gen_ret = + kodi_addon_web_destroy_control_v1(this, auto_gen_hdl, handle, complete); + + msgpack::pack(out, msgChild_OUT_kodi_addon_web_destroy_control_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_web_control_render_init_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_RENDER_INIT_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_render_init_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_render_init_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_render_init_v1 t = in.get().as(); + PtrKodiOffscreen kodiOffsetHdl = std::get<0>(t); + uint64_t renderId = std::get<1>(t); + int x = std::get<2>(t); + int y = std::get<3>(t); + int width = std::get<4>(t); + int height = std::get<5>(t); + ADDON_HARDWARE_CONTEXT context = reinterpret_cast(std::get<6>(t)); + IAddonOffscreenRenderControl* auto_gen_render_control = + GenerateOffscreenControl(kodiOffsetHdl, renderId, x, y, width, height, context); + bool auto_gen_render_ret = auto_gen_render_control && auto_gen_render_control->Start(); + + const KODI_ADDON_WEB_HDL hdl = reinterpret_cast(std::get<7>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<8>(t)); + bool auto_gen_ret = kodi_addon_web_control_render_init_v1(this, hdl, handle); + + msgpack::pack( + out, msgChild_OUT_kodi_addon_web_control_render_init_v1( + auto_gen_ret, PtrAddonOffscreen(auto_gen_render_control), auto_gen_render_ret)); + return true; + } + case funcChild_kodi_addon_web_control_render_deinit_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_RENDER_DEINIT_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_render_deinit_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_render_deinit_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_render_deinit_v1 t = in.get().as(); + IAddonOffscreenRenderControl* auto_gen_render_control = + reinterpret_cast(std::get<0>(t)); + const KODI_ADDON_WEB_HDL hdl = reinterpret_cast(std::get<1>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<2>(t)); + kodi_addon_web_control_render_deinit_v1(this, hdl, handle); + + if (auto_gen_render_control) + { + { + auto_gen_render_control->Stop(); + delete auto_gen_render_control; + } + } + return true; + } + case funcChild_kodi_addon_web_control_render_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_RENDER_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_render_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_render_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_render_v1 t = in.get().as(); + IAddonOffscreenRenderControl* auto_gen_render_control = + reinterpret_cast(std::get<0>(t)); + if (auto_gen_render_control) + auto_gen_render_control->RenderBegin(); + + const KODI_ADDON_WEB_HDL hdl = reinterpret_cast(std::get<1>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<2>(t)); + kodi_addon_web_control_render_v1(this, hdl, handle); + + if (auto_gen_render_control) + auto_gen_render_control->RenderEnd(); + return true; + } + case funcChild_kodi_addon_web_control_dirty_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_DIRTY_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_dirty_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_dirty_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_dirty_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + bool auto_gen_ret = kodi_addon_web_control_dirty_v1(this, auto_gen_hdl, handle); + + msgpack::pack(out, msgChild_OUT_kodi_addon_web_control_dirty_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_web_control_on_init_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_ON_INIT_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_on_init_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_on_init_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_on_init_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + bool auto_gen_ret = kodi_addon_web_control_on_init_v1(this, auto_gen_hdl, handle); + + msgpack::pack(out, msgChild_OUT_kodi_addon_web_control_on_init_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_web_control_on_action_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_ON_ACTION_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, const struct KODI_ADDON_ACTION_DATA* action, int* nextItem); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_on_action_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_on_action_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_on_action_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_ACTION_DATA action; + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + std::get<2>(t).SetCStructure(&action); + int nextItem = std::get<3>(t); + bool auto_gen_ret = + kodi_addon_web_control_on_action_v1(this, auto_gen_hdl, handle, &action, &nextItem); + + msgpack::pack(out, msgChild_OUT_kodi_addon_web_control_on_action_v1(auto_gen_ret, nextItem)); + return true; + } + case funcChild_kodi_addon_web_control_on_mouse_event_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_ON_MOUSE_EVENT_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, int id, double x, double y, double offsetX, double offsetY, int state); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_on_mouse_event_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_on_mouse_event_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_on_mouse_event_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + int id = std::get<2>(t); + double x = std::get<3>(t); + double y = std::get<4>(t); + double offsetX = std::get<5>(t); + double offsetY = std::get<6>(t); + int state = std::get<7>(t); + bool auto_gen_ret = kodi_addon_web_control_on_mouse_event_v1(this, auto_gen_hdl, handle, id, + x, y, offsetX, offsetY, state); + + msgpack::pack(out, msgChild_OUT_kodi_addon_web_control_on_mouse_event_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_web_control_open_website_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_OPEN_WEBSITE_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, const char* url); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_open_website_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_open_website_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_open_website_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + const std::string& url = std::get<2>(t); + bool auto_gen_ret = + kodi_addon_web_control_open_website_v1(this, auto_gen_hdl, handle, url.c_str()); + + msgpack::pack(out, msgChild_OUT_kodi_addon_web_control_open_website_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_web_control_get_history_v1: + { + // Original API call: typedef bool(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_GET_HISTORY_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, char*** list, size_t* entries, bool behind_current); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_get_history_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgChild_OUT_kodi_addon_web_control_get_history_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_get_history_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + char** list = nullptr; + size_t entries = std::get<2>(t); + bool behind_current = std::get<3>(t); + bool auto_gen_ret = kodi_addon_web_control_get_history_v1(this, auto_gen_hdl, handle, &list, + &entries, behind_current); + + std::vector cpp_list; + cpp_list.reserve(entries); + if (list) + { + for (size_t i = 0; i < entries; ++i) + { + if (list[i]) + { + cpp_list.emplace_back(list[i]); + free(list[i]); + } + else + { + cpp_list.emplace_back(""); + } + } + free(list); + } + msgpack::pack( + out, msgChild_OUT_kodi_addon_web_control_get_history_v1(auto_gen_ret, cpp_list, entries)); + return true; + } + case funcChild_kodi_addon_web_control_search_text_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SEARCH_TEXT_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, const char* text, bool forward, bool matchCase, bool findNext); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_search_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_search_text_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_search_text_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + const std::string& text = std::get<2>(t); + bool forward = std::get<3>(t); + bool matchCase = std::get<4>(t); + bool findNext = std::get<5>(t); + kodi_addon_web_control_search_text_v1(this, auto_gen_hdl, handle, text.c_str(), forward, + matchCase, findNext); + + return true; + } + case funcChild_kodi_addon_web_control_stop_search_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_STOP_SEARCH_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, bool clearSelection); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_stop_search_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_stop_search_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_stop_search_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + bool clearSelection = std::get<2>(t); + kodi_addon_web_control_stop_search_v1(this, auto_gen_hdl, handle, clearSelection); + + return true; + } + case funcChild_kodi_addon_web_control_web_cmd_reload_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_RELOAD_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_web_cmd_reload_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_web_cmd_reload_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_web_cmd_reload_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + kodi_addon_web_control_web_cmd_reload_v1(this, auto_gen_hdl, handle); + + return true; + } + case funcChild_kodi_addon_web_control_web_cmd_stop_load_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_STOP_LOAD_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_web_cmd_stop_load_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_web_cmd_stop_load_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_web_cmd_stop_load_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + kodi_addon_web_control_web_cmd_stop_load_v1(this, auto_gen_hdl, handle); + + return true; + } + case funcChild_kodi_addon_web_control_web_cmd_nav_back_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_NAV_BACK_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_web_cmd_nav_back_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_web_cmd_nav_back_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_web_cmd_nav_back_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + kodi_addon_web_control_web_cmd_nav_back_v1(this, auto_gen_hdl, handle); + + return true; + } + case funcChild_kodi_addon_web_control_web_cmd_nav_forward_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_CMD_NAV_FORWARD_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_web_cmd_nav_forward_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_web_cmd_nav_forward_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_web_cmd_nav_forward_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + kodi_addon_web_control_web_cmd_nav_forward_v1(this, auto_gen_hdl, handle); + + return true; + } + case funcChild_kodi_addon_web_control_web_open_own_context_menu_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_WEB_OPEN_OWN_CONTEXT_MENU_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_web_open_own_context_menu_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_web_open_own_context_menu_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_web_open_own_context_menu_v1 t = + in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + kodi_addon_web_control_web_open_own_context_menu_v1(this, auto_gen_hdl, handle); + + return true; + } + case funcChild_kodi_addon_web_control_screen_size_change_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_WEB_CONTROL_SCREEN_SIZE_CHANGE_V1)(const KODI_ADDON_WEB_HDL hdl, const WEB_KODI_CONTROL handle, float x, float y, float width, float height, bool fullscreen); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_web_control_screen_size_change_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_web_control_screen_size_change_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_web_control_screen_size_change_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const WEB_KODI_CONTROL handle = reinterpret_cast(std::get<1>(t)); + float x = std::get<2>(t); + float y = std::get<3>(t); + float width = std::get<4>(t); + float height = std::get<5>(t); + bool fullscreen = std::get<6>(t); + kodi_addon_web_control_screen_size_change_v1(this, auto_gen_hdl, handle, x, y, width, height, + fullscreen); + + return true; + } + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +enum WEB_ADDON_ERROR CHdl_kodi_addoninstance_web_h::kodi_addon_web_start_instance_v1( + void* thisClassHdl, const KODI_ADDON_WEB_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return WEB_ADDON_ERROR_PERMANENT_FAILED; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum WEB_ADDON_ERROR auto_gen_ret = WEB_ADDON_ERROR_PERMANENT_FAILED; + if (union_data->types.kodi_addon_web.v1.start_instance) + { + auto_gen_ret = union_data->types.kodi_addon_web.v1.start_instance(union_data->hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_stop_instance_v1( + void* thisClassHdl, const KODI_ADDON_WEB_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.stop_instance) + { + union_data->types.kodi_addon_web.v1.stop_instance(union_data->hdl); + } +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_main_initialize_v1( + void* thisClassHdl, const KODI_ADDON_WEB_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_web.v1.main_initialize) + { + auto_gen_ret = union_data->types.kodi_addon_web.v1.main_initialize(union_data->hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_main_loop_v1( + void* thisClassHdl, const KODI_ADDON_WEB_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.main_loop) + { + union_data->types.kodi_addon_web.v1.main_loop(union_data->hdl); + } +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_main_shutdown_v1( + void* thisClassHdl, const KODI_ADDON_WEB_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.main_shutdown) + { + union_data->types.kodi_addon_web.v1.main_shutdown(union_data->hdl); + } +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_set_mute_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + bool mute) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.set_mute) + { + union_data->types.kodi_addon_web.v1.set_mute(union_data->hdl, mute); + } +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_set_language_v1( + void* thisClassHdl, const KODI_ADDON_WEB_HDL hdl, const char* language) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_web.v1.set_language) + { + auto_gen_ret = union_data->types.kodi_addon_web.v1.set_language(union_data->hdl, language); + } + return auto_gen_ret; +} + +enum WEB_ADDON_ERROR CHdl_kodi_addoninstance_web_h::kodi_addon_web_create_control_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const struct WEB_ADDON_GUI_PROPS* props, + const char* start_url, + WEB_KODI_CONTROL* handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return WEB_ADDON_ERROR_PERMANENT_FAILED; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum WEB_ADDON_ERROR auto_gen_ret = WEB_ADDON_ERROR_PERMANENT_FAILED; + if (union_data->types.kodi_addon_web.v1.create_control) + { + auto_gen_ret = union_data->types.kodi_addon_web.v1.create_control(union_data->hdl, props, + start_url, handle); + } + return auto_gen_ret; +} + +enum WEB_ADDON_ERROR CHdl_kodi_addoninstance_web_h::kodi_addon_web_destroy_control_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + bool complete) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return WEB_ADDON_ERROR_PERMANENT_FAILED; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum WEB_ADDON_ERROR auto_gen_ret = WEB_ADDON_ERROR_PERMANENT_FAILED; + if (union_data->types.kodi_addon_web.v1.destroy_control) + { + auto_gen_ret = + union_data->types.kodi_addon_web.v1.destroy_control(union_data->hdl, handle, complete); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_render_init_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_web.v1.control_render_init) + { + auto_gen_ret = union_data->types.kodi_addon_web.v1.control_render_init(union_data->hdl, handle); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_render_deinit_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.control_render_deinit) + { + union_data->types.kodi_addon_web.v1.control_render_deinit(union_data->hdl, handle); + } +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_render_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.control_render) + { + union_data->types.kodi_addon_web.v1.control_render(union_data->hdl, handle); + } +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_dirty_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_web.v1.control_dirty) + { + auto_gen_ret = union_data->types.kodi_addon_web.v1.control_dirty(union_data->hdl, handle); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_on_init_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_web.v1.control_on_init) + { + auto_gen_ret = union_data->types.kodi_addon_web.v1.control_on_init(union_data->hdl, handle); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_on_action_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const struct KODI_ADDON_ACTION_DATA* action, + int* nextItem) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_web.v1.control_on_action) + { + auto_gen_ret = union_data->types.kodi_addon_web.v1.control_on_action(union_data->hdl, handle, + action, nextItem); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_on_mouse_event_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + int id, + double x, + double y, + double offsetX, + double offsetY, + int state) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_web.v1.control_on_mouse_event) + { + auto_gen_ret = union_data->types.kodi_addon_web.v1.control_on_mouse_event( + union_data->hdl, handle, id, x, y, offsetX, offsetY, state); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_open_website_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* url) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_web.v1.control_open_website) + { + auto_gen_ret = + union_data->types.kodi_addon_web.v1.control_open_website(union_data->hdl, handle, url); + } + return auto_gen_ret; +} + +bool CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_get_history_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + char*** list, + size_t* entries, + bool behind_current) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return false; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + bool auto_gen_ret = false; + if (union_data->types.kodi_addon_web.v1.control_get_history) + { + auto_gen_ret = union_data->types.kodi_addon_web.v1.control_get_history( + union_data->hdl, handle, list, entries, behind_current); + } + return auto_gen_ret; +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_search_text_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* text, + bool forward, + bool matchCase, + bool findNext) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.control_search_text) + { + union_data->types.kodi_addon_web.v1.control_search_text(union_data->hdl, handle, text, forward, + matchCase, findNext); + } +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_stop_search_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + bool clearSelection) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.control_stop_search) + { + union_data->types.kodi_addon_web.v1.control_stop_search(union_data->hdl, handle, + clearSelection); + } +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_web_cmd_reload_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.control_web_cmd_reload) + { + union_data->types.kodi_addon_web.v1.control_web_cmd_reload(union_data->hdl, handle); + } +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_web_cmd_stop_load_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.control_web_cmd_stop_load) + { + union_data->types.kodi_addon_web.v1.control_web_cmd_stop_load(union_data->hdl, handle); + } +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_web_cmd_nav_back_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.control_web_cmd_nav_back) + { + union_data->types.kodi_addon_web.v1.control_web_cmd_nav_back(union_data->hdl, handle); + } +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_web_cmd_nav_forward_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.control_web_cmd_nav_forward) + { + union_data->types.kodi_addon_web.v1.control_web_cmd_nav_forward(union_data->hdl, handle); + } +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_web_open_own_context_menu_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.control_web_open_own_context_menu) + { + union_data->types.kodi_addon_web.v1.control_web_open_own_context_menu(union_data->hdl, handle); + } +} + +void CHdl_kodi_addoninstance_web_h::kodi_addon_web_control_screen_size_change_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + float x, + float y, + float width, + float height, + bool fullscreen) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_web.v1.control_screen_size_change) + { + union_data->types.kodi_addon_web.v1.control_screen_size_change(union_data->hdl, handle, x, y, + width, height, fullscreen); + } +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_addon_web_inhibit_shutdown(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + bool inhibit) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_inhibit_shutdown(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, bool inhibit); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_inhibit_shutdown_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_inhibit_shutdown_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_inhibit_shutdown_v1(PtrValue(hdl), inhibit)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_inhibit_shutdown_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_inhibit_shutdown_v1(auto_gen_group.thisClassHdl, hdl, inhibit); +} + +ATTR_DLL_EXPORT void kodi_addon_web_inhibit_screensaver(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + bool inhibit) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_inhibit_screensaver(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, bool inhibit); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_inhibit_screensaver_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_inhibit_screensaver_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_inhibit_screensaver_v1(PtrValue(hdl), inhibit)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_inhibit_screensaver_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_inhibit_screensaver_v1(auto_gen_group.thisClassHdl, hdl, inhibit); +} + +ATTR_DLL_EXPORT bool kodi_addon_web_is_muted(KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_web_is_muted(KODI_ADDON_INSTANCE_BACKEND_HDL hdl); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_is_muted_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_is_muted_v1; /* Autogenerated */ + + if (hdl == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_web_is_muted_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_is_muted_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_web_is_muted_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + return auto_gen_group.kodi_addon_web_is_muted_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_addon_web_control_set_control_ready(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool ready) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_control_ready(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, bool ready); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_control_ready_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_control_ready_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_control_set_control_ready_v1( + PtrValue(hdl), PtrValue(handle), ready)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_control_set_control_ready_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_control_set_control_ready_v1(auto_gen_group.thisClassHdl, hdl, + handle, ready); +} + +ATTR_DLL_EXPORT void kodi_addon_web_control_set_opened_address(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* title) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_opened_address(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* title); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_opened_address_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_opened_address_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || title == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_control_set_opened_address_v1( + PtrValue(hdl), PtrValue(handle), title)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_control_set_opened_address_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_control_set_opened_address_v1(auto_gen_group.thisClassHdl, hdl, + handle, title); +} + +ATTR_DLL_EXPORT void kodi_addon_web_control_set_opened_title(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* title) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_opened_title(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* title); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_opened_title_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_opened_title_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || title == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_control_set_opened_title_v1( + PtrValue(hdl), PtrValue(handle), title)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_control_set_opened_title_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_control_set_opened_title_v1(auto_gen_group.thisClassHdl, hdl, + handle, title); +} + +ATTR_DLL_EXPORT void kodi_addon_web_control_set_icon_url(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* icon) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_icon_url(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* icon); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_icon_url_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_icon_url_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || icon == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_control_set_icon_url_v1(PtrValue(hdl), + PtrValue(handle), icon)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_control_set_icon_url_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_control_set_icon_url_v1(auto_gen_group.thisClassHdl, hdl, handle, + icon); +} + +ATTR_DLL_EXPORT void kodi_addon_web_control_set_fullscreen(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool fullscreen) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_fullscreen(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, bool fullscreen); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_fullscreen_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_fullscreen_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_control_set_fullscreen_v1( + PtrValue(hdl), PtrValue(handle), fullscreen)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_control_set_fullscreen_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_control_set_fullscreen_v1(auto_gen_group.thisClassHdl, hdl, handle, + fullscreen); +} + +ATTR_DLL_EXPORT void kodi_addon_web_control_set_loading_state(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + bool isLoading, + bool canGoBack, + bool canGoForward) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_loading_state(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, bool isLoading, bool canGoBack, bool canGoForward); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_loading_state_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_loading_state_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_control_set_loading_state_v1( + PtrValue(hdl), PtrValue(handle), isLoading, canGoBack, canGoForward)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_control_set_loading_state_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_control_set_loading_state_v1( + auto_gen_group.thisClassHdl, hdl, handle, isLoading, canGoBack, canGoForward); +} + +ATTR_DLL_EXPORT void kodi_addon_web_control_set_tooltip(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* tooltip) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_tooltip(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* tooltip); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_tooltip_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_tooltip_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || tooltip == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_control_set_tooltip_v1( + PtrValue(hdl), PtrValue(handle), tooltip)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_control_set_tooltip_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_control_set_tooltip_v1(auto_gen_group.thisClassHdl, hdl, handle, + tooltip); +} + +ATTR_DLL_EXPORT void kodi_addon_web_control_set_status_message(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + WEB_KODI_CONTROL handle, + const char* status) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_set_status_message(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* status); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_set_status_message_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_set_status_message_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || status == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_control_set_status_message_v1( + PtrValue(hdl), PtrValue(handle), status)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, funcParent_kodi_addon_web_control_set_status_message_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_control_set_status_message_v1(auto_gen_group.thisClassHdl, hdl, + handle, status); +} + +ATTR_DLL_EXPORT void kodi_addon_web_control_request_open_site_in_new_tab( + KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* url) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_addon_web_control_request_open_site_in_new_tab(KODI_ADDON_INSTANCE_BACKEND_HDL hdl, WEB_KODI_CONTROL handle, const char* url); __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_web_control_request_open_site_in_new_tab_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_web_control_request_open_site_in_new_tab_v1; /* Autogenerated */ + + if (hdl == nullptr || handle == nullptr || url == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_addon_web_control_request_open_site_in_new_tab_v1( + PtrValue(hdl), PtrValue(handle), url)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addoninstance_web_h, + funcParent_kodi_addon_web_control_request_open_site_in_new_tab_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addoninstance_web_h; + auto_gen_group.kodi_addon_web_control_request_open_site_in_new_tab_v1(auto_gen_group.thisClassHdl, + hdl, handle, url); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/web.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/web.h new file mode 100644 index 0000000000000..9b81d52095a6f --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon-instance/web.h @@ -0,0 +1,192 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon-instance/web.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addoninstance_web_h; +struct directFuncToKodi_addoninstance_web_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addoninstance_web_h : public IMsgHdl +{ +public: + CHdl_kodi_addoninstance_web_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_addoninstance_web_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static enum WEB_ADDON_ERROR kodi_addon_web_start_instance_v1( + void* thisClassHdl, const KODI_ADDON_WEB_HDL hdl); // Added with API 1 + + static void kodi_addon_web_stop_instance_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl); // Added with API 1 + + static bool kodi_addon_web_main_initialize_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl); // Added with API 1 + + static void kodi_addon_web_main_loop_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl); // Added with API 1 + + static void kodi_addon_web_main_shutdown_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl); // Added with API 1 + + static void kodi_addon_web_set_mute_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + bool mute); // Added with API 1 + + static bool kodi_addon_web_set_language_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const char* language); // Added with API 1 + + static enum WEB_ADDON_ERROR kodi_addon_web_create_control_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const struct WEB_ADDON_GUI_PROPS* props, + const char* start_url, + WEB_KODI_CONTROL* handle); // Added with API 1 + + static enum WEB_ADDON_ERROR kodi_addon_web_destroy_control_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + bool complete); // Added with API 1 + + static bool kodi_addon_web_control_render_init_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + static void kodi_addon_web_control_render_deinit_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + static void kodi_addon_web_control_render_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + static bool kodi_addon_web_control_dirty_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + static bool kodi_addon_web_control_on_init_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + static bool kodi_addon_web_control_on_action_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const struct KODI_ADDON_ACTION_DATA* action, + int* nextItem); // Added with API 1 + + static bool kodi_addon_web_control_on_mouse_event_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + int id, + double x, + double y, + double offsetX, + double offsetY, + int state); // Added with API 1 + + static bool kodi_addon_web_control_open_website_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* url); // Added with API 1 + + static bool kodi_addon_web_control_get_history_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + char*** list, + size_t* entries, + bool behind_current); // Added with API 1 + + static void kodi_addon_web_control_search_text_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + const char* text, + bool forward, + bool matchCase, + bool findNext); // Added with API 1 + + static void kodi_addon_web_control_stop_search_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + bool clearSelection); // Added with API 1 + + static void kodi_addon_web_control_web_cmd_reload_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + static void kodi_addon_web_control_web_cmd_stop_load_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + static void kodi_addon_web_control_web_cmd_nav_back_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + static void kodi_addon_web_control_web_cmd_nav_forward_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + static void kodi_addon_web_control_web_open_own_context_menu_v1( + void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle); // Added with API 1 + + static void kodi_addon_web_control_screen_size_change_v1(void* thisClassHdl, + const KODI_ADDON_WEB_HDL hdl, + const WEB_KODI_CONTROL handle, + float x, + float y, + float width, + float height, + bool fullscreen); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon_base.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/addon_base.cpp new file mode 100644 index 0000000000000..daee7668e6856 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon_base.cpp @@ -0,0 +1,1787 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "addon_base.h" + +#include "include/kodi/tools/StringUtils.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_addon_base_h::InitDirect(directFuncToAddon_addon_base_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; + ifcToAddon->kodi_addon_create_v1 = kodi_addon_create_v1; + ifcToAddon->kodi_addon_destroy_v1 = kodi_addon_destroy_v1; + ifcToAddon->kodi_addon_setting_change_string_v1 = kodi_addon_setting_change_string_v1; + ifcToAddon->kodi_addon_setting_change_boolean_v1 = kodi_addon_setting_change_boolean_v1; + ifcToAddon->kodi_addon_setting_change_integer_v1 = kodi_addon_setting_change_integer_v1; + ifcToAddon->kodi_addon_setting_change_float_v1 = kodi_addon_setting_change_float_v1; + ifcToAddon->kodi_addon_create_instance_v1 = kodi_addon_create_instance_v1; + ifcToAddon->kodi_addon_destroy_instance_v1 = kodi_addon_destroy_instance_v1; + ifcToAddon->kodi_addon_instance_setting_change_string_v1 = + kodi_addon_instance_setting_change_string_v1; + ifcToAddon->kodi_addon_instance_setting_change_boolean_v1 = + kodi_addon_instance_setting_change_boolean_v1; + ifcToAddon->kodi_addon_instance_setting_change_integer_v1 = + kodi_addon_instance_setting_change_integer_v1; + ifcToAddon->kodi_addon_instance_setting_change_float_v1 = + kodi_addon_instance_setting_change_float_v1; + ifcToAddon->kodi_addon_instance_create_v1 = kodi_addon_instance_create_v1; + ifcToAddon->kodi_addon_instance_destroy_v1 = kodi_addon_instance_destroy_v1; +} + +#ifndef KODI_INHIBIT_SHARED +bool CHdl_kodi_addon_base_h::HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (funcGroup != funcGroup_addon_base_h) + return false; + + switch (func) + { + case funcChild_kodi_addon_create_v1: + { + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_CREATE_V1)(const struct KODI_ADDON_INSTANCE_INFO* first_instance, KODI_ADDON_HDL* hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_create_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_create_v1 t = in.get().as(); + KODI_ADDON_INSTANCE_INFO first_instance; + std::get<0>(t).SetCStructure(&first_instance); + KODI_ADDON_HDL hdl = nullptr; + enum ADDON_STATUS auto_gen_ret = kodi_addon_create_v1(this, &first_instance, &hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_create_v1(auto_gen_ret, PtrValue(hdl))); + return true; + } + case funcChild_kodi_addon_destroy_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_DESTROY_V1)(KODI_ADDON_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_destroy_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_destroy_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_destroy_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + kodi_addon_destroy_v1(this, auto_gen_hdl); + + return true; + } + case funcChild_kodi_addon_setting_change_string_v1: + { + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_STRING_V1)(const KODI_ADDON_HDL hdl, const char* name, const char* value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_setting_change_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_setting_change_string_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_setting_change_string_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& name = std::get<1>(t); + const std::string& value = std::get<2>(t); + enum ADDON_STATUS auto_gen_ret = + kodi_addon_setting_change_string_v1(this, auto_gen_hdl, name.c_str(), value.c_str()); + + msgpack::pack(out, msgChild_OUT_kodi_addon_setting_change_string_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_setting_change_boolean_v1: + { + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_BOOLEAN_V1)(const KODI_ADDON_HDL hdl, const char* name, bool value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_setting_change_boolean_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_setting_change_boolean_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_setting_change_boolean_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& name = std::get<1>(t); + bool value = std::get<2>(t); + enum ADDON_STATUS auto_gen_ret = + kodi_addon_setting_change_boolean_v1(this, auto_gen_hdl, name.c_str(), value); + + msgpack::pack(out, msgChild_OUT_kodi_addon_setting_change_boolean_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_setting_change_integer_v1: + { + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_INTEGER_V1)(const KODI_ADDON_HDL hdl, const char* name, int value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_setting_change_integer_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_setting_change_integer_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_setting_change_integer_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& name = std::get<1>(t); + int value = std::get<2>(t); + enum ADDON_STATUS auto_gen_ret = + kodi_addon_setting_change_integer_v1(this, auto_gen_hdl, name.c_str(), value); + + msgpack::pack(out, msgChild_OUT_kodi_addon_setting_change_integer_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_setting_change_float_v1: + { + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_SETTING_CHANGE_FLOAT_V1)(const KODI_ADDON_HDL hdl, const char* name, double value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_setting_change_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_setting_change_float_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_setting_change_float_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + const std::string& name = std::get<1>(t); + double value = std::get<2>(t); + enum ADDON_STATUS auto_gen_ret = + kodi_addon_setting_change_float_v1(this, auto_gen_hdl, name.c_str(), value); + + msgpack::pack(out, msgChild_OUT_kodi_addon_setting_change_float_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_create_instance_v1: + { + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_CREATE_INSTANCE_V1)(const KODI_ADDON_HDL hdl, const struct KODI_ADDON_INSTANCE_INFO* info, struct KODI_ADDON_INSTANCE_STRUCT* instance); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_create_instance_v1; /* OVERRIDE;USE_HAND_MAKE used, set this by hand */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_create_instance_v1; /* OVERRIDE;USE_HAND_MAKE used, set this by hand */ + + /*---AUTO_GEN_PARSE---*/ + msgChild__IN_kodi_addon_create_instance_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_HANDLE addonInstance = nullptr; + KODI_ADDON_INSTANCE_INFO info; /* CheckAPIUse_WAY_16 (0004) */ + std::get<1>(t).SetCStructure(&info); /* CheckAPIUse_WAY_16 (0004) */ + ADDON_STATUS status = + kodi_addon_create_instance_v1(this, auto_gen_hdl, &info, &addonInstance); + msgpack::pack(out, + msgChild_OUT_kodi_addon_create_instance_v1(status, PtrValue(addonInstance))); + /*---AUTO_GEN_PARSE---*/ + return true; + } + case funcChild_kodi_addon_destroy_instance_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_DESTROY_INSTANCE_V1)(const KODI_ADDON_HDL hdl, const struct KODI_ADDON_INSTANCE_INFO* info, const KODI_ADDON_INSTANCE_HDL instance_hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_destroy_instance_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_destroy_instance_v1; /* Autogenerated */ + + /*---AUTO_GEN_PARSE---*/ + msgChild__IN_kodi_addon_destroy_instance_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_HANDLE instance = reinterpret_cast(std::get<2>(t)); + if (instance) + { + KODI_ADDON_INSTANCE_INFO info; /* CheckAPIUse_WAY_16 (0004) */ + std::get<1>(t).SetCStructure(&info); /* CheckAPIUse_WAY_16 (0004) */ + kodi_addon_destroy_instance_v1(this, auto_gen_hdl, &info /* CheckAPIUse_WAY_16 (0004) */, + instance + /* CheckAPIUse_WAY_12 (0004) */); + } + + /*---AUTO_GEN_PARSE---*/ + return true; + } + case funcChild_kodi_addon_instance_setting_change_string_v1: + { + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_STRING_V1)(const KODI_ADDON_HDL hdl, const KODI_ADDON_INSTANCE_HDL instance_hdl, const char* name, const char* value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_setting_change_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_setting_change_string_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_instance_setting_change_string_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_INSTANCE_STRUCT* instance_hdl = + reinterpret_cast(std::get<1>(t)); + const std::string& name = std::get<2>(t); + const std::string& value = std::get<3>(t); + enum ADDON_STATUS auto_gen_ret = kodi_addon_instance_setting_change_string_v1( + this, auto_gen_hdl, instance_hdl->hdl, name.c_str(), value.c_str()); + + msgpack::pack(out, msgChild_OUT_kodi_addon_instance_setting_change_string_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_instance_setting_change_boolean_v1: + { + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_BOOLEAN_V1)(const KODI_ADDON_HDL hdl, const KODI_ADDON_INSTANCE_HDL instance_hdl, const char* name, bool value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_setting_change_boolean_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_setting_change_boolean_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_instance_setting_change_boolean_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_INSTANCE_STRUCT* instance_hdl = + reinterpret_cast(std::get<1>(t)); + const std::string& name = std::get<2>(t); + bool value = std::get<3>(t); + enum ADDON_STATUS auto_gen_ret = kodi_addon_instance_setting_change_boolean_v1( + this, auto_gen_hdl, instance_hdl->hdl, name.c_str(), value); + + msgpack::pack(out, msgChild_OUT_kodi_addon_instance_setting_change_boolean_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_instance_setting_change_integer_v1: + { + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_INTEGER_V1)(const KODI_ADDON_HDL hdl, const KODI_ADDON_INSTANCE_HDL instance_hdl, const char* name, int value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_setting_change_integer_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_setting_change_integer_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_instance_setting_change_integer_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_INSTANCE_STRUCT* instance_hdl = + reinterpret_cast(std::get<1>(t)); + const std::string& name = std::get<2>(t); + int value = std::get<3>(t); + enum ADDON_STATUS auto_gen_ret = kodi_addon_instance_setting_change_integer_v1( + this, auto_gen_hdl, instance_hdl->hdl, name.c_str(), value); + + msgpack::pack(out, msgChild_OUT_kodi_addon_instance_setting_change_integer_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_instance_setting_change_float_v1: + { + // Original API call: typedef enum ADDON_STATUS(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_SETTING_CHANGE_FLOAT_V1)(const KODI_ADDON_HDL hdl, const KODI_ADDON_INSTANCE_HDL instance_hdl, const char* name, double value); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_setting_change_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_setting_change_float_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_instance_setting_change_float_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_INSTANCE_STRUCT* instance_hdl = + reinterpret_cast(std::get<1>(t)); + const std::string& name = std::get<2>(t); + double value = std::get<3>(t); + enum ADDON_STATUS auto_gen_ret = kodi_addon_instance_setting_change_float_v1( + this, auto_gen_hdl, instance_hdl->hdl, name.c_str(), value); + + msgpack::pack(out, msgChild_OUT_kodi_addon_instance_setting_change_float_v1(auto_gen_ret)); + return true; + } + case funcChild_kodi_addon_instance_create_v1: + { + // Original API call: typedef KODI_ADDON_INSTANCE_HDL(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_CREATE_V1)(KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_create_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_instance_create_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl = + reinterpret_cast(std::get<0>(t)); + KODI_ADDON_INSTANCE_HDL auto_gen_ret = kodi_addon_instance_create_v1(this, kodi_hdl); + + msgpack::pack(out, msgChild_OUT_kodi_addon_instance_create_v1(PtrValue(auto_gen_ret))); + return true; + } + case funcChild_kodi_addon_instance_destroy_v1: + { + // Original API call: typedef void(ATTR_APIENTRYP PFN_KODI_ADDON_INSTANCE_DESTROY_V1)(KODI_ADDON_INSTANCE_HDL hdl); + // Tuple in: typedef std::tuple msgChild__IN_kodi_addon_instance_destroy_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgChild_OUT_kodi_addon_instance_destroy_v1; /* Autogenerated */ + + msgChild__IN_kodi_addon_instance_destroy_v1 t = in.get().as(); + KODI_ADDON_HDL auto_gen_hdl = reinterpret_cast(std::get<0>(t)); + + kodi_addon_instance_destroy_v1(this, auto_gen_hdl); + + return true; + } + default: + break; + } + return false; +} +#endif /* !KODI_INHIBIT_SHARED */ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ + +KODI::ADDONS::INTERFACE::DirectAddonIfc* kodi_check_direct_api(int argc, char* argv[]) +{ + static const char* value = "--direct-api="; + static std::string direct_api = "0"; + + for (int i = 1; i < argc; ++i) + { + if (argv[i] == nullptr) + break; + + std::string arg = argv[i]; + if (arg.rfind(value, 0) == 0) + { + direct_api = arg.substr(strlen(value)); + break; + } + else if ((arg == "-d") || (arg == "--direct-api")) + { + if (i + 1 < argc) // Make sure we aren't at the end of argv! + { + direct_api = argv[++i]; // Increment 'i' so we don't get the argument as the next argv[i]. + break; + } + } + } + + return reinterpret_cast(stoull(direct_api, 0, 16)); +} + +/*---AUTO_GEN_PARSE---*/ + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_create_v1( + void* thisClassHdl, + const struct KODI_ADDON_INSTANCE_INFO* first_instance, + KODI_ADDON_HDL* hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return ADDON_STATUS_OK; + + /*---AUTO_GEN_PARSE---*/ + + ADDON_STATUS status; + if (thisClass->m_ifc->functions.types.kodi_addon.v1.create) + { + status = thisClass->m_ifc->functions.types.kodi_addon.v1.create(first_instance, hdl); + thisClass->m_ifc->functions.hdl = *hdl; + } + else + status = ADDON_STATUS_NOT_IMPLEMENTED; + *hdl = &thisClass->m_ifc->functions; + return status; + + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addon_base_h::kodi_addon_destroy_v1(void* thisClassHdl, + KODI_ADDON_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon.v1.destroy) + { + union_data->types.kodi_addon.v1.destroy(union_data->hdl); + } +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_setting_change_string_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const char* name, + const char* value) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return ADDON_STATUS_OK; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum ADDON_STATUS auto_gen_ret = ADDON_STATUS_OK; + if (union_data->types.kodi_addon.v1.setting_change_string) + { + auto_gen_ret = + union_data->types.kodi_addon.v1.setting_change_string(union_data->hdl, name, value); + } + return auto_gen_ret; +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_setting_change_boolean_v1( + void* thisClassHdl, const KODI_ADDON_HDL hdl, const char* name, bool value) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return ADDON_STATUS_OK; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum ADDON_STATUS auto_gen_ret = ADDON_STATUS_OK; + if (union_data->types.kodi_addon.v1.setting_change_boolean) + { + auto_gen_ret = + union_data->types.kodi_addon.v1.setting_change_boolean(union_data->hdl, name, value); + } + return auto_gen_ret; +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_setting_change_integer_v1( + void* thisClassHdl, const KODI_ADDON_HDL hdl, const char* name, int value) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return ADDON_STATUS_OK; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum ADDON_STATUS auto_gen_ret = ADDON_STATUS_OK; + if (union_data->types.kodi_addon.v1.setting_change_integer) + { + auto_gen_ret = + union_data->types.kodi_addon.v1.setting_change_integer(union_data->hdl, name, value); + } + return auto_gen_ret; +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_setting_change_float_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const char* name, + double value) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return ADDON_STATUS_OK; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + enum ADDON_STATUS auto_gen_ret = ADDON_STATUS_OK; + if (union_data->types.kodi_addon.v1.setting_change_float) + { + auto_gen_ret = + union_data->types.kodi_addon.v1.setting_change_float(union_data->hdl, name, value); + } + return auto_gen_ret; +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_create_instance_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + KODI_HANDLE* instance) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return ADDON_STATUS_OK; + + /*---AUTO_GEN_PARSE---*/ + // Autogenerated by "Generate_kodi_addon_instance_construct.py", edit this for code changes! + ADDON_STATUS status; + UnionAddonFunctions* data = reinterpret_cast(hdl); + if (data->types.kodi_addon.v1.create_instance) + { + UnionAddonFunctions* instanceStruct = new UnionAddonFunctions(); + instanceStruct->type = info->type; + instanceStruct->kodi = info->kodi; + + KODI_ADDON_INSTANCE_STRUCT addonInstance; + addonInstance.dummy = &instanceStruct->types.dummy; + + status = data->types.kodi_addon.v1.create_instance(data->hdl, info, &addonInstance); + if (!addonInstance.dummy && status == ADDON_STATUS_OK) + { + status = ADDON_STATUS_PERMANENT_FAILURE; + } + else if (addonInstance.dummy) + { + if (info->type == ADDON_INSTANCE_AUDIODECODER) + { + if (&instanceStruct->types.kodi_addon_audiodecoder.v1 != + reinterpret_casttypes.kodi_addon_audiodecoder.v1)*>( + addonInstance.audiodecoder)) + instanceStruct->types.kodi_addon_audiodecoder.v1 = + *reinterpret_casttypes.kodi_addon_audiodecoder.v1)*>( + addonInstance.audiodecoder); + if (instanceStruct->types.kodi_addon_audiodecoder.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_audiodecoder.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + if (info->type == ADDON_INSTANCE_AUDIOENCODER) + { + if (&instanceStruct->types.kodi_addon_audioencoder.v1 != + reinterpret_casttypes.kodi_addon_audioencoder.v1)*>( + addonInstance.audioencoder)) + instanceStruct->types.kodi_addon_audioencoder.v1 = + *reinterpret_casttypes.kodi_addon_audioencoder.v1)*>( + addonInstance.audioencoder); + if (instanceStruct->types.kodi_addon_audioencoder.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_audioencoder.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + if (info->type == ADDON_INSTANCE_GAME) + { + if (&instanceStruct->types.kodi_addon_game.v1 != + reinterpret_casttypes.kodi_addon_game.v1)*>( + addonInstance.game)) + instanceStruct->types.kodi_addon_game.v1 = + *reinterpret_casttypes.kodi_addon_game.v1)*>( + addonInstance.game); + if (instanceStruct->types.kodi_addon_game.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_game.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + if (info->type == ADDON_INSTANCE_IMAGEDECODER) + { + if (&instanceStruct->types.kodi_addon_imagedecoder.v1 != + reinterpret_casttypes.kodi_addon_imagedecoder.v1)*>( + addonInstance.imagedecoder)) + instanceStruct->types.kodi_addon_imagedecoder.v1 = + *reinterpret_casttypes.kodi_addon_imagedecoder.v1)*>( + addonInstance.imagedecoder); + if (instanceStruct->types.kodi_addon_imagedecoder.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_imagedecoder.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + if (info->type == ADDON_INSTANCE_INPUTSTREAM) + { + if (&instanceStruct->types.kodi_addon_inputstream.v1 != + reinterpret_casttypes.kodi_addon_inputstream.v1)*>( + addonInstance.inputstream)) + instanceStruct->types.kodi_addon_inputstream.v1 = + *reinterpret_casttypes.kodi_addon_inputstream.v1)*>( + addonInstance.inputstream); + if (instanceStruct->types.kodi_addon_inputstream.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_inputstream.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + if (info->type == ADDON_INSTANCE_PERIPHERAL) + { + if (&instanceStruct->types.kodi_addon_peripheral.v1 != + reinterpret_casttypes.kodi_addon_peripheral.v1)*>( + addonInstance.peripheral)) + instanceStruct->types.kodi_addon_peripheral.v1 = + *reinterpret_casttypes.kodi_addon_peripheral.v1)*>( + addonInstance.peripheral); + if (instanceStruct->types.kodi_addon_peripheral.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_peripheral.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + if (info->type == ADDON_INSTANCE_SCREENSAVER) + { + if (&instanceStruct->types.kodi_addon_screensaver.v1 != + reinterpret_casttypes.kodi_addon_screensaver.v1)*>( + addonInstance.screensaver)) + instanceStruct->types.kodi_addon_screensaver.v1 = + *reinterpret_casttypes.kodi_addon_screensaver.v1)*>( + addonInstance.screensaver); + if (instanceStruct->types.kodi_addon_screensaver.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_screensaver.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + if (info->type == ADDON_INSTANCE_VFS) + { + if (&instanceStruct->types.kodi_addon_vfs.v1 != + reinterpret_casttypes.kodi_addon_vfs.v1)*>(addonInstance.vfs)) + instanceStruct->types.kodi_addon_vfs.v1 = + *reinterpret_casttypes.kodi_addon_vfs.v1)*>( + addonInstance.vfs); + if (instanceStruct->types.kodi_addon_vfs.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_vfs.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + if (info->type == ADDON_INSTANCE_VIDEOCODEC) + { + if (&instanceStruct->types.kodi_addon_videocodec.v1 != + reinterpret_casttypes.kodi_addon_videocodec.v1)*>( + addonInstance.videocodec)) + instanceStruct->types.kodi_addon_videocodec.v1 = + *reinterpret_casttypes.kodi_addon_videocodec.v1)*>( + addonInstance.videocodec); + if (instanceStruct->types.kodi_addon_videocodec.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_videocodec.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + if (info->type == ADDON_INSTANCE_VISUALIZATION) + { + if (&instanceStruct->types.kodi_addon_visualization.v1 != + reinterpret_casttypes.kodi_addon_visualization.v1)*>( + addonInstance.visualization)) + instanceStruct->types.kodi_addon_visualization.v1 = + *reinterpret_casttypes.kodi_addon_visualization.v1)*>( + addonInstance.visualization); + if (instanceStruct->types.kodi_addon_visualization.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_visualization.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + if (info->type == ADDON_INSTANCE_WEB) + { + if (&instanceStruct->types.kodi_addon_web.v1 != + reinterpret_casttypes.kodi_addon_web.v1)*>(addonInstance.web)) + instanceStruct->types.kodi_addon_web.v1 = + *reinterpret_casttypes.kodi_addon_web.v1)*>( + addonInstance.web); + if (instanceStruct->types.kodi_addon_web.v1.create) + instanceStruct->hdl = instanceStruct->types.kodi_addon_web.v1.create(instance); + else + instanceStruct->hdl = addonInstance.hdl; + goto done; + } + done: + *instance = instanceStruct; + return status; + } + + delete instanceStruct; + } + else + status = ADDON_STATUS_NOT_IMPLEMENTED; + + return status; + /*---AUTO_GEN_PARSE---*/ +} + +void CHdl_kodi_addon_base_h::kodi_addon_destroy_instance_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + const KODI_HANDLE instance) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + /*---AUTO_GEN_PARSE---*/ + // Autogenerated by "Generate_kodi_addon_instance_construct.py", edit this for code changes! + UnionAddonFunctions* data = reinterpret_cast(hdl); + UnionAddonFunctions* instanceStruct = reinterpret_cast(instance); + if (instanceStruct) + { + if (info->type == ADDON_INSTANCE_AUDIODECODER) + { + if (instanceStruct->types.kodi_addon_audiodecoder.v1.destroy) + instanceStruct->types.kodi_addon_audiodecoder.v1.destroy(instanceStruct->hdl); + goto done; + } + if (info->type == ADDON_INSTANCE_AUDIOENCODER) + { + if (instanceStruct->types.kodi_addon_audioencoder.v1.destroy) + instanceStruct->types.kodi_addon_audioencoder.v1.destroy(instanceStruct->hdl); + goto done; + } + if (info->type == ADDON_INSTANCE_GAME) + { + if (instanceStruct->types.kodi_addon_game.v1.destroy) + instanceStruct->types.kodi_addon_game.v1.destroy(instanceStruct->hdl); + goto done; + } + if (info->type == ADDON_INSTANCE_IMAGEDECODER) + { + if (instanceStruct->types.kodi_addon_imagedecoder.v1.destroy) + instanceStruct->types.kodi_addon_imagedecoder.v1.destroy(instanceStruct->hdl); + goto done; + } + if (info->type == ADDON_INSTANCE_INPUTSTREAM) + { + if (instanceStruct->types.kodi_addon_inputstream.v1.destroy) + instanceStruct->types.kodi_addon_inputstream.v1.destroy(instanceStruct->hdl); + goto done; + } + if (info->type == ADDON_INSTANCE_PERIPHERAL) + { + if (instanceStruct->types.kodi_addon_peripheral.v1.destroy) + instanceStruct->types.kodi_addon_peripheral.v1.destroy(instanceStruct->hdl); + goto done; + } + if (info->type == ADDON_INSTANCE_SCREENSAVER) + { + if (instanceStruct->types.kodi_addon_screensaver.v1.destroy) + instanceStruct->types.kodi_addon_screensaver.v1.destroy(instanceStruct->hdl); + goto done; + } + if (info->type == ADDON_INSTANCE_VFS) + { + if (instanceStruct->types.kodi_addon_vfs.v1.destroy) + instanceStruct->types.kodi_addon_vfs.v1.destroy(instanceStruct->hdl); + goto done; + } + if (info->type == ADDON_INSTANCE_VIDEOCODEC) + { + if (instanceStruct->types.kodi_addon_videocodec.v1.destroy) + instanceStruct->types.kodi_addon_videocodec.v1.destroy(instanceStruct->hdl); + goto done; + } + if (info->type == ADDON_INSTANCE_VISUALIZATION) + { + if (instanceStruct->types.kodi_addon_visualization.v1.destroy) + instanceStruct->types.kodi_addon_visualization.v1.destroy(instanceStruct->hdl); + goto done; + } + if (info->type == ADDON_INSTANCE_WEB) + { + if (instanceStruct->types.kodi_addon_web.v1.destroy) + instanceStruct->types.kodi_addon_web.v1.destroy(instanceStruct->hdl); + goto done; + } + done: + if (data->types.kodi_addon.v1.destroy_instance) + { + data->types.kodi_addon.v1.destroy_instance(data->hdl, info, instanceStruct->hdl); + } + delete instanceStruct; + } + /*---AUTO_GEN_PARSE---*/ +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_instance_setting_change_string_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + const char* value) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return ADDON_STATUS_OK; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + UnionAddonFunctions* instanceStruct = reinterpret_cast(instance_hdl); + enum ADDON_STATUS auto_gen_ret = ADDON_STATUS_OK; + if (union_data->types.kodi_addon.v1.instance_setting_change_string) + { + auto_gen_ret = union_data->types.kodi_addon.v1.instance_setting_change_string( + union_data->hdl, instanceStruct->hdl, name, value); + } + return auto_gen_ret; +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_instance_setting_change_boolean_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + bool value) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return ADDON_STATUS_OK; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + UnionAddonFunctions* instanceStruct = reinterpret_cast(instance_hdl); + enum ADDON_STATUS auto_gen_ret = ADDON_STATUS_OK; + if (union_data->types.kodi_addon.v1.instance_setting_change_boolean) + { + auto_gen_ret = union_data->types.kodi_addon.v1.instance_setting_change_boolean( + union_data->hdl, instanceStruct->hdl, name, value); + } + return auto_gen_ret; +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_instance_setting_change_integer_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + int value) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return ADDON_STATUS_OK; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + UnionAddonFunctions* instanceStruct = reinterpret_cast(instance_hdl); + enum ADDON_STATUS auto_gen_ret = ADDON_STATUS_OK; + if (union_data->types.kodi_addon.v1.instance_setting_change_integer) + { + auto_gen_ret = union_data->types.kodi_addon.v1.instance_setting_change_integer( + union_data->hdl, instanceStruct->hdl, name, value); + } + return auto_gen_ret; +} + +enum ADDON_STATUS CHdl_kodi_addon_base_h::kodi_addon_instance_setting_change_float_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + double value) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return ADDON_STATUS_OK; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + UnionAddonFunctions* instanceStruct = reinterpret_cast(instance_hdl); + enum ADDON_STATUS auto_gen_ret = ADDON_STATUS_OK; + if (union_data->types.kodi_addon.v1.instance_setting_change_float) + { + auto_gen_ret = union_data->types.kodi_addon.v1.instance_setting_change_float( + union_data->hdl, instanceStruct->hdl, name, value); + } + return auto_gen_ret; +} + +KODI_ADDON_INSTANCE_HDL CHdl_kodi_addon_base_h::kodi_addon_instance_create_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return nullptr; + + UnionAddonFunctions* union_data = reinterpret_cast(kodi_hdl); + KODI_ADDON_INSTANCE_HDL auto_gen_ret = nullptr; + if (union_data->types.kodi_addon_instance.v1.create) + { + auto_gen_ret = union_data->types.kodi_addon_instance.v1.create(kodi_hdl); + } + return auto_gen_ret; +} + +void CHdl_kodi_addon_base_h::kodi_addon_instance_destroy_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_HDL hdl) // Added with API 1 +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + UnionAddonFunctions* union_data = reinterpret_cast(hdl); + if (union_data->types.kodi_addon_instance.v1.destroy) + { + union_data->types.kodi_addon_instance.v1.destroy(union_data->hdl); + } +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT const char* kodi_check_main_shared(int argc, char* argv[]) +{ + // Original API call: ATTR_DLL_EXPORT const char* kodi_check_main_shared(int argc, char* argv[]) __INTRODUCED_IN_KODI(1); + // Tuple in: /* NOTE: msgParent__IN_kodi_check_main_shared - Override active to use inside dev-kit library only */ + // Tuple out: /* NOTE: msgParent_OUT_kodi_check_main_shared - Override active to use inside dev-kit library only */ + + /*---AUTO_GEN_PARSE---*/ + + static const char* value = "--main-shared="; + static std::string main_shared; + + for (int i = 0; i < argc; ++i) + { + if (argv[i] == nullptr) + break; + + std::string arg = argv[i]; + if (arg.rfind(value, 0) == 0) + { + main_shared = arg.substr(strlen(value)); + break; + } + else if ((arg == "-m") || (arg == "--main-shared")) + { + if (i + 1 < argc) // Make sure we aren't at the end of argv! + { + main_shared = argv[++i]; // Increment 'i' so we don't get the argument as the next argv[i]. + break; + } + } + } + + return main_shared.c_str(); + + /*---AUTO_GEN_PARSE---*/ +} + +ATTR_DLL_EXPORT KODI_IFC_HDL kodi_init(unsigned int api, + int argc, + char* argv[], + struct KODI_ADDON_FUNC* func, + bool via_main, + bool no_receive) +{ + // Original API call: ATTR_DLL_EXPORT KODI_IFC_HDL kodi_init(unsigned int api, int argc, char* argv[], struct KODI_ADDON_FUNC* func, bool via_main, bool no_receive) __INTRODUCED_IN_KODI(1); + // Tuple in: /* NOTE: msgParent__IN_kodi_init - Override active to use inside dev-kit library only */ + // Tuple out: /* NOTE: msgParent_OUT_kodi_init - Override active to use inside dev-kit library only */ + + /*---AUTO_GEN_PARSE---*/ + + if (AddonIfc::g_ifc) + { + fprintf(stderr, R"error( +FATAL: This class "CChildProcessor" should only be used one time in App. + Here becomes a second time called and child app becomes destroyed now. + Inform developer about this addon to fix it! + )error"); + exit(1); + } + + KODI_ADDON::INTERNAL::AddonIfc* ifc = new AddonIfc(); + ifc->api = api; + ifc->identifier = kodi_check_main_shared(argc, argv); + if (ifc->identifier.empty()) + { + fprintf(stderr, "FATAL: Started addon without valid identifier, Addon not usable!\n"); + exit(1); + } + + // ifc->kodiFirstInstance = kodi_check_for_first_instance(argc, argv); + ifc->direct = kodi_check_direct_api(argc, argv); + if (ifc->direct) + ifc->direct_used = true; + + if (func) + ifc->functions.types.kodi_addon.v1 = + *reinterpret_castfunctions.types.kodi_addon.v1)*>(func); + ifc->viaMainThread = via_main; + ifc->noReceive = no_receive; + ifc->control = std::unique_ptr(new CAddonControl(ifc)); + if (!ifc->control->Create()) + { + fprintf(stderr, "FATAL: Started addon without valid identifier, Addon not usable!\n"); + delete ifc; + exit(1); + } + + AddonIfc::g_ifc = ifc; + return AddonIfc::g_ifc; + + /*---AUTO_GEN_PARSE---*/ +} + +ATTR_DLL_EXPORT void kodi_deinit(KODI_IFC_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_deinit(KODI_IFC_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: /* NOTE: msgParent__IN_kodi_deinit - Override active to use inside dev-kit library only */ + // Tuple out: /* NOTE: msgParent_OUT_kodi_deinit - Override active to use inside dev-kit library only */ + + /*---AUTO_GEN_PARSE---*/ + + if (!AddonIfc::g_ifc) + return; + + delete AddonIfc::g_ifc; + AddonIfc::g_ifc = nullptr; + + /*---AUTO_GEN_PARSE---*/ +} + +ATTR_DLL_EXPORT bool kodi_process(KODI_IFC_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_process(KODI_IFC_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: /* NOTE: msgParent__IN_kodi_process - Override active to use inside dev-kit library only */ + // Tuple out: /* NOTE: msgParent_OUT_kodi_process - Override active to use inside dev-kit library only */ + + /*---AUTO_GEN_PARSE---*/ + + if (!AddonIfc::g_ifc) + return false; + return AddonIfc::g_ifc->control->ProcessOutside(); + + /*---AUTO_GEN_PARSE---*/ +} + +ATTR_DLL_EXPORT void kodi_log(enum ADDON_LOG loglevel, const char* format, ...) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_log(enum ADDON_LOG loglevel, const char* format, ...) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_log_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_log_v1; /* Autogenerated */ + + if (format == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + va_list args; + va_start(args, format); + const std::string cpp_format = kodi::tools::StringUtils::FormatV(format, args); + va_end(args); + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_log_v1(loglevel, cpp_format)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage(funcGroup_addon_base_h, + funcParent_kodi_log_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + auto_gen_group.kodi_log_v1(auto_gen_group.thisClassHdl, loglevel, format); +} + +ATTR_DLL_EXPORT char* kodi_addon_get_addon_path() +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_get_addon_path() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_addon_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_addon_path_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_addon_base_h, funcParent_kodi_addon_get_addon_path_v1, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_get_addon_path_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_get_addon_path_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT char* kodi_addon_get_lib_path() +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_get_lib_path() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_lib_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_lib_path_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_addon_base_h, funcParent_kodi_addon_get_lib_path_v1, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_get_lib_path_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_get_lib_path_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT char* kodi_addon_get_user_path() +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_get_user_path() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_user_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_user_path_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_addon_base_h, funcParent_kodi_addon_get_user_path_v1, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_get_user_path_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_get_user_path_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT char* kodi_addon_get_temp_path() +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_get_temp_path() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_temp_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_temp_path_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_addon_base_h, funcParent_kodi_addon_get_temp_path_v1, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_get_temp_path_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_get_temp_path_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT char* kodi_addon_localized_string(long label_id) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_localized_string(long label_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_localized_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_localized_string_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_localized_string_v1(label_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_localized_string_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_localized_string_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_localized_string_v1(auto_gen_group.thisClassHdl, label_id); +} + +ATTR_DLL_EXPORT char* kodi_addon_get_info(const char* id) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_get_info(const char* id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_info_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_info_v1; /* Autogenerated */ + + if (id == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_get_info_v1(id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_get_info_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_get_info_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_get_info_v1(auto_gen_group.thisClassHdl, id); +} + +ATTR_DLL_EXPORT bool kodi_addon_open_settings_dialog() +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_open_settings_dialog() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_open_settings_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_open_settings_dialog_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_addon_base_h, funcParent_kodi_addon_open_settings_dialog_v1, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_open_settings_dialog_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_open_settings_dialog_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT bool kodi_addon_is_setting_using_default(const char* id) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_is_setting_using_default(const char* id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_is_setting_using_default_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_is_setting_using_default_v1; /* Autogenerated */ + + if (id == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_is_setting_using_default_v1(id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_is_setting_using_default_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_is_setting_using_default_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_is_setting_using_default_v1(auto_gen_group.thisClassHdl, id); +} + +ATTR_DLL_EXPORT bool kodi_addon_get_setting_bool(const char* id, bool* value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_get_setting_bool(const char* id, bool* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_setting_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_setting_bool_v1; /* Autogenerated */ + + if (id == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_get_setting_bool_v1(id, *value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_get_setting_bool_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_get_setting_bool_v1 t = ident.get().as(); + + *value = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_get_setting_bool_v1(auto_gen_group.thisClassHdl, id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_get_setting_int(const char* id, int* value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_get_setting_int(const char* id, int* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_setting_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_setting_int_v1; /* Autogenerated */ + + if (id == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_get_setting_int_v1(id, *value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_get_setting_int_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_get_setting_int_v1 t = ident.get().as(); + + *value = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_get_setting_int_v1(auto_gen_group.thisClassHdl, id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_get_setting_float(const char* id, double* value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_get_setting_float(const char* id, double* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_setting_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_setting_float_v1; /* Autogenerated */ + + if (id == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_get_setting_float_v1(id, *value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_get_setting_float_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_get_setting_float_v1 t = ident.get().as(); + + *value = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_get_setting_float_v1(auto_gen_group.thisClassHdl, id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_get_setting_string(const char* id, char** value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_get_setting_string(const char* id, char** value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_get_setting_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_get_setting_string_v1; /* Autogenerated */ + + if (id == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_get_setting_string_v1(id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_get_setting_string_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_get_setting_string_v1 t = ident.get().as(); + + *value = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_get_setting_string_v1(auto_gen_group.thisClassHdl, id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_set_setting_bool(const char* id, bool value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_set_setting_bool(const char* id, bool value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_set_setting_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_set_setting_bool_v1; /* Autogenerated */ + + if (id == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_set_setting_bool_v1(id, value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_set_setting_bool_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_set_setting_bool_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_set_setting_bool_v1(auto_gen_group.thisClassHdl, id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_set_setting_int(const char* id, int value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_set_setting_int(const char* id, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_set_setting_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_set_setting_int_v1; /* Autogenerated */ + + if (id == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_set_setting_int_v1(id, value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_set_setting_int_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_set_setting_int_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_set_setting_int_v1(auto_gen_group.thisClassHdl, id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_set_setting_float(const char* id, double value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_set_setting_float(const char* id, double value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_set_setting_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_set_setting_float_v1; /* Autogenerated */ + + if (id == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_set_setting_float_v1(id, value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_set_setting_float_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_set_setting_float_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_set_setting_float_v1(auto_gen_group.thisClassHdl, id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_set_setting_string(const char* id, const char* value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_set_setting_string(const char* id, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_set_setting_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_set_setting_string_v1; /* Autogenerated */ + + if (id == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_set_setting_string_v1(id, value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_set_setting_string_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_set_setting_string_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_set_setting_string_v1(auto_gen_group.thisClassHdl, id, value); +} + +ATTR_DLL_EXPORT char* kodi_addon_instance_get_user_path(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_addon_instance_get_user_path(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_get_user_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_get_user_path_v1; /* Autogenerated */ + + if (hdl == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_instance_get_user_path_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_instance_get_user_path_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_instance_get_user_path_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_instance_get_user_path_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT bool kodi_addon_instance_is_setting_using_default( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_is_setting_using_default( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_is_setting_using_default_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_is_setting_using_default_v1; /* Autogenerated */ + + if (hdl == nullptr || id == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_addon_instance_is_setting_using_default_v1(PtrValue(hdl), id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_instance_is_setting_using_default_v1, in, + out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_instance_is_setting_using_default_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_instance_is_setting_using_default_v1(auto_gen_group.thisClassHdl, + hdl, id); +} + +ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_bool(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + bool* value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_bool( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, bool* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_get_setting_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_get_setting_bool_v1; /* Autogenerated */ + + if (hdl == nullptr || id == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_addon_instance_get_setting_bool_v1(PtrValue(hdl), id, *value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_instance_get_setting_bool_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_instance_get_setting_bool_v1 t = ident.get().as(); + + *value = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_instance_get_setting_bool_v1(auto_gen_group.thisClassHdl, hdl, + id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_int(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + int* value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_int( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, int* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_get_setting_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_get_setting_int_v1; /* Autogenerated */ + + if (hdl == nullptr || id == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_addon_instance_get_setting_int_v1(PtrValue(hdl), id, *value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_instance_get_setting_int_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_instance_get_setting_int_v1 t = ident.get().as(); + + *value = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_instance_get_setting_int_v1(auto_gen_group.thisClassHdl, hdl, id, + value); +} + +ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_float( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, double* value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_float( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, double* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_get_setting_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_get_setting_float_v1; /* Autogenerated */ + + if (hdl == nullptr || id == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_addon_instance_get_setting_float_v1(PtrValue(hdl), id, *value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_instance_get_setting_float_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_instance_get_setting_float_v1 t = ident.get().as(); + + *value = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_instance_get_setting_float_v1(auto_gen_group.thisClassHdl, hdl, + id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_string( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, char** value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_get_setting_string( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, char** value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_get_setting_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_get_setting_string_v1; /* Autogenerated */ + + if (hdl == nullptr || id == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_addon_instance_get_setting_string_v1(PtrValue(hdl), id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_instance_get_setting_string_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_instance_get_setting_string_v1 t = ident.get().as(); + + *value = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_instance_get_setting_string_v1(auto_gen_group.thisClassHdl, hdl, + id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_bool(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + bool value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_bool( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, bool value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_set_setting_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_set_setting_bool_v1; /* Autogenerated */ + + if (hdl == nullptr || id == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_addon_instance_set_setting_bool_v1(PtrValue(hdl), id, value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_instance_set_setting_bool_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_instance_set_setting_bool_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_instance_set_setting_bool_v1(auto_gen_group.thisClassHdl, hdl, + id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_int(const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, + const char* id, + int value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_int( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_set_setting_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_set_setting_int_v1; /* Autogenerated */ + + if (hdl == nullptr || id == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_addon_instance_set_setting_int_v1(PtrValue(hdl), id, value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_instance_set_setting_int_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_instance_set_setting_int_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_instance_set_setting_int_v1(auto_gen_group.thisClassHdl, hdl, id, + value); +} + +ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_float( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, double value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_float( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, double value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_set_setting_float_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_set_setting_float_v1; /* Autogenerated */ + + if (hdl == nullptr || id == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_addon_instance_set_setting_float_v1(PtrValue(hdl), id, value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_instance_set_setting_float_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_instance_set_setting_float_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_instance_set_setting_float_v1(auto_gen_group.thisClassHdl, hdl, + id, value); +} + +ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_string( + const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, const char* value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_addon_instance_set_setting_string( const KODI_ADDON_INSTANCE_BACKEND_HDL hdl, const char* id, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_addon_instance_set_setting_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_addon_instance_set_setting_string_v1; /* Autogenerated */ + + if (hdl == nullptr || id == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_addon_instance_set_setting_string_v1(PtrValue(hdl), id, value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_addon_base_h, funcParent_kodi_addon_instance_set_setting_string_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_addon_instance_set_setting_string_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.addon_base_h; + return auto_gen_group.kodi_addon_instance_set_setting_string_v1(auto_gen_group.thisClassHdl, hdl, + id, value); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/addon_base.h b/xbmc/addons/kodi-dev-kit/src/addon/api/addon_base.h new file mode 100644 index 0000000000000..3453a6e372c22 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/addon_base.h @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/addon_base.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_addon_base_h; +struct directFuncToKodi_addon_base_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_addon_base_h : public IMsgHdl +{ +public: + CHdl_kodi_addon_base_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_addon_base_h* ifcToAddon); + +#ifndef KODI_INHIBIT_SHARED + bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) override; +#endif /* !KODI_INHIBIT_SHARED */ + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ + + // Calls from Kodi to addon + static enum ADDON_STATUS kodi_addon_create_v1( + void* thisClassHdl, + const struct KODI_ADDON_INSTANCE_INFO* first_instance, + KODI_ADDON_HDL* hdl); // Added with API 1 + + static void kodi_addon_destroy_v1(void* thisClassHdl, KODI_ADDON_HDL hdl); // Added with API 1 + + static enum ADDON_STATUS kodi_addon_setting_change_string_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const char* name, + const char* value); // Added with API 1 + + static enum ADDON_STATUS kodi_addon_setting_change_boolean_v1(void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const char* name, + bool value); // Added with API 1 + + static enum ADDON_STATUS kodi_addon_setting_change_integer_v1(void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const char* name, + int value); // Added with API 1 + + static enum ADDON_STATUS kodi_addon_setting_change_float_v1(void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const char* name, + double value); // Added with API 1 + + static enum ADDON_STATUS kodi_addon_create_instance_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + KODI_HANDLE* instance); // Added with API 1 + + static void kodi_addon_destroy_instance_v1(void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const struct KODI_ADDON_INSTANCE_INFO* info, + const KODI_HANDLE instance); // Added with API 1 + + static enum ADDON_STATUS kodi_addon_instance_setting_change_string_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + const char* value); // Added with API 1 + + static enum ADDON_STATUS kodi_addon_instance_setting_change_boolean_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + bool value); // Added with API 1 + + static enum ADDON_STATUS kodi_addon_instance_setting_change_integer_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + int value); // Added with API 1 + + static enum ADDON_STATUS kodi_addon_instance_setting_change_float_v1( + void* thisClassHdl, + const KODI_ADDON_HDL hdl, + const KODI_ADDON_INSTANCE_HDL instance_hdl, + const char* name, + double value); // Added with API 1 + + static KODI_ADDON_INSTANCE_HDL kodi_addon_instance_create_v1( + void* thisClassHdl, KODI_ADDON_INSTANCE_BACKEND_HDL kodi_hdl); // Added with API 1 + + static void kodi_addon_instance_destroy_v1(void* thisClassHdl, + KODI_ADDON_INSTANCE_HDL hdl); // Added with API 1 +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/audio_engine.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/audio_engine.cpp new file mode 100644 index 0000000000000..68e6f0a7539b1 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/audio_engine.cpp @@ -0,0 +1,798 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "audio_engine.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_audio_engine_h::InitDirect(directFuncToAddon_audio_engine_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT bool kodi_audioengine_get_current_sink_format(struct AUDIO_ENGINE_FMT* fmt) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_audioengine_get_current_sink_format(struct AUDIO_ENGINE_FMT* fmt) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_get_current_sink_format_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_get_current_sink_format_v1; /* Autogenerated */ + + if (fmt == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_get_current_sink_format_v1, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_get_current_sink_format_v1 t = ident.get().as(); + + std::get<1>(t).SetCStructure(fmt); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_get_current_sink_format_v1(auto_gen_group.thisClassHdl, + fmt); +} + +ATTR_DLL_EXPORT bool kodi_audioengine_is_planar_format(enum AudioEngineDataFormat format) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_audioengine_is_planar_format(enum AudioEngineDataFormat format) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_is_planar_format_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_is_planar_format_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_is_planar_format_v1(format)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_is_planar_format_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_is_planar_format_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_is_planar_format_v1(auto_gen_group.thisClassHdl, format); +} + +ATTR_DLL_EXPORT KODI_AE_HDL kodi_audioengine_stream_make(const struct AUDIO_ENGINE_FMT* fmt, + unsigned int options) +{ + // Original API call: ATTR_DLL_EXPORT KODI_AE_HDL kodi_audioengine_stream_make(const struct AUDIO_ENGINE_FMT* fmt, unsigned int options) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_make_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_make_v1; /* Autogenerated */ + + if (fmt == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_make_v1(fmt, options)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_make_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_make_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_make_v1(auto_gen_group.thisClassHdl, fmt, options); +} + +ATTR_DLL_EXPORT void kodi_audioengine_stream_free(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_free(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_free_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_free_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_free_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_free_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + auto_gen_group.kodi_audioengine_stream_free_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_space(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_space(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_space_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_space_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_space_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_space_v1, in, out)) + return 0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_space_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_space_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_add_data(KODI_AE_HDL hdl, + uint8_t* const* data, + size_t planes, + size_t data_size, + unsigned int offset, + unsigned int frames, + unsigned int frame_size, + double pts, + bool hasDownmix, + double centerMixLevel) +{ + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_add_data(KODI_AE_HDL hdl, uint8_t* const* data, size_t planes, size_t data_size, unsigned int offset, unsigned int frames, unsigned int frame_size, double pts, bool hasDownmix, double centerMixLevel) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple>, size_t, size_t, unsigned int, unsigned int, unsigned int, double, bool, double> msgParent__IN_kodi_audioengine_stream_add_data_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_add_data_v1; /* Autogenerated */ + + if (hdl == nullptr || data == nullptr) + return 0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + std::vector> ifc_data; + ifc_data.resize(planes); + for (size_t i = 0; i < planes; ++i) + ifc_data[i] = std::vector(data[i], data[i] + data_size); + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_add_data_v1( + PtrValue(hdl), ifc_data, planes, data_size, offset, frames, frame_size, + pts, hasDownmix, centerMixLevel)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_add_data_v1, in, out)) + return 0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_add_data_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_add_data_v1( + auto_gen_group.thisClassHdl, hdl, data, planes, data_size, offset, frames, frame_size, pts, + hasDownmix, centerMixLevel); +} + +ATTR_DLL_EXPORT double kodi_audioengine_stream_get_delay(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT double kodi_audioengine_stream_get_delay(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_delay_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_delay_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0.0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_delay_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_delay_v1, in, out)) + return 0.0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_delay_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_delay_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_buffering(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_buffering(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_is_buffering_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_is_buffering_v1; /* Autogenerated */ + + if (hdl == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_is_buffering_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_is_buffering_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_is_buffering_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_is_buffering_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT double kodi_audioengine_stream_get_cache_time(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT double kodi_audioengine_stream_get_cache_time(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_cache_time_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_cache_time_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0.0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_cache_time_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_cache_time_v1, in, + out)) + return 0.0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_cache_time_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_cache_time_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT double kodi_audioengine_stream_get_cache_total(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT double kodi_audioengine_stream_get_cache_total(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_cache_total_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_cache_total_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0.0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_cache_total_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_cache_total_v1, in, + out)) + return 0.0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_cache_total_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_cache_total_v1(auto_gen_group.thisClassHdl, + hdl); +} + +ATTR_DLL_EXPORT void kodi_audioengine_stream_pause(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_pause(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_pause_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_pause_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_pause_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_pause_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + auto_gen_group.kodi_audioengine_stream_pause_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_audioengine_stream_resume(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_resume(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_resume_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_resume_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_resume_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_resume_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + auto_gen_group.kodi_audioengine_stream_resume_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_audioengine_stream_drain(KODI_AE_HDL hdl, bool wait) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_drain(KODI_AE_HDL hdl, bool wait) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_drain_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_drain_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_drain_v1(PtrValue(hdl), wait)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_drain_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + auto_gen_group.kodi_audioengine_stream_drain_v1(auto_gen_group.thisClassHdl, hdl, wait); +} + +ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_draining(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_draining(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_is_draining_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_is_draining_v1; /* Autogenerated */ + + if (hdl == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_is_draining_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_is_draining_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_is_draining_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_is_draining_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_drained(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_audioengine_stream_is_drained(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_is_drained_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_is_drained_v1; /* Autogenerated */ + + if (hdl == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_is_drained_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_is_drained_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_is_drained_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_is_drained_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_audioengine_stream_flush(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_flush(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_flush_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_flush_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_flush_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_flush_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + auto_gen_group.kodi_audioengine_stream_flush_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT float kodi_audioengine_stream_get_volume(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT float kodi_audioengine_stream_get_volume(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_volume_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_volume_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0.0f; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_volume_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_volume_v1, in, out)) + return 0.0f; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_volume_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_volume_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT void kodi_audioengine_stream_set_volume(KODI_AE_HDL hdl, float volume) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_set_volume(KODI_AE_HDL hdl, float volume) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_set_volume_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_set_volume_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_set_volume_v1(PtrValue(hdl), volume)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_set_volume_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + auto_gen_group.kodi_audioengine_stream_set_volume_v1(auto_gen_group.thisClassHdl, hdl, volume); +} + +ATTR_DLL_EXPORT float kodi_audioengine_stream_get_amplification(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT float kodi_audioengine_stream_get_amplification(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_amplification_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_amplification_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0.0f; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_amplification_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_amplification_v1, in, + out)) + return 0.0f; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_amplification_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_amplification_v1(auto_gen_group.thisClassHdl, + hdl); +} + +ATTR_DLL_EXPORT void kodi_audioengine_stream_set_amplification(KODI_AE_HDL hdl, float amplify) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_set_amplification(KODI_AE_HDL hdl, float amplify) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_set_amplification_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_set_amplification_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_audioengine_stream_set_amplification_v1(PtrValue(hdl), amplify)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_set_amplification_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + auto_gen_group.kodi_audioengine_stream_set_amplification_v1(auto_gen_group.thisClassHdl, hdl, + amplify); +} + +ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_frame_size(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_frame_size(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_frame_size_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_frame_size_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_frame_size_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_frame_size_v1, in, + out)) + return 0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_frame_size_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_frame_size_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_channel_count(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_channel_count(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_channel_count_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_channel_count_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_channel_count_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_channel_count_v1, in, + out)) + return 0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_channel_count_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_channel_count_v1(auto_gen_group.thisClassHdl, + hdl); +} + +ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_sample_rate(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_audioengine_stream_get_sample_rate(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_sample_rate_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_sample_rate_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_sample_rate_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_sample_rate_v1, in, + out)) + return 0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_sample_rate_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_sample_rate_v1(auto_gen_group.thisClassHdl, + hdl); +} + +ATTR_DLL_EXPORT enum AudioEngineDataFormat kodi_audioengine_stream_get_data_format(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT enum AudioEngineDataFormat kodi_audioengine_stream_get_data_format( KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_data_format_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_data_format_v1; /* Autogenerated */ + + if (hdl == nullptr) + return AUDIOENGINE_FMT_INVALID; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_data_format_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_data_format_v1, in, + out)) + return AUDIOENGINE_FMT_INVALID; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_data_format_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_data_format_v1(auto_gen_group.thisClassHdl, + hdl); +} + +ATTR_DLL_EXPORT double kodi_audioengine_stream_get_resample_ratio(KODI_AE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT double kodi_audioengine_stream_get_resample_ratio(KODI_AE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_get_resample_ratio_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_get_resample_ratio_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0.0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_audioengine_stream_get_resample_ratio_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_get_resample_ratio_v1, in, + out)) + return 0.0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_audioengine_stream_get_resample_ratio_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + return auto_gen_group.kodi_audioengine_stream_get_resample_ratio_v1(auto_gen_group.thisClassHdl, + hdl); +} + +ATTR_DLL_EXPORT void kodi_audioengine_stream_set_resample_ratio(KODI_AE_HDL hdl, double ratio) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_audioengine_stream_set_resample_ratio(KODI_AE_HDL hdl, double ratio) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_audioengine_stream_set_resample_ratio_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_audioengine_stream_set_resample_ratio_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_audioengine_stream_set_resample_ratio_v1(PtrValue(hdl), ratio)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_audio_engine_h, funcParent_kodi_audioengine_stream_set_resample_ratio_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.audio_engine_h; + auto_gen_group.kodi_audioengine_stream_set_resample_ratio_v1(auto_gen_group.thisClassHdl, hdl, + ratio); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/audio_engine.h b/xbmc/addons/kodi-dev-kit/src/addon/api/audio_engine.h new file mode 100644 index 0000000000000..cec070a014115 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/audio_engine.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/audio_engine.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_audio_engine_h; +struct directFuncToKodi_audio_engine_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_audio_engine_h : public IMsgHdl +{ +public: + CHdl_kodi_audio_engine_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_audio_engine_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/dl/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/api/dl/CMakeLists.txt new file mode 100644 index 0000000000000..42d26f54f98df --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/dl/CMakeLists.txt @@ -0,0 +1,13 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + kodi_api_1.c +) + +set(HEADERS +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_api_dl) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/dl/kodi_api_1.c b/xbmc/addons/kodi-dev-kit/src/addon/api/dl/kodi_api_1.c new file mode 100644 index 0000000000000..f0bb4726ce09b --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/dl/kodi_api_1.c @@ -0,0 +1,580 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +/* API_HASH */ + +#include "../../../../include/kodi/c-api/dl/kodi_api_1.h" +#include "include/kodi/c-api/addon_base.h" +#include "include/kodi/c-api/audio_engine.h" +#include "include/kodi/c-api/filesystem.h" +#include "include/kodi/c-api/general.h" +#include "include/kodi/c-api/gui/dialogs/context_menu.h" +#include "include/kodi/c-api/gui/dialogs/filebrowser.h" +#include "include/kodi/c-api/gui/dialogs/keyboard.h" +#include "include/kodi/c-api/gui/dialogs/numeric.h" +#include "include/kodi/c-api/gui/dialogs/ok.h" +#include "include/kodi/c-api/gui/dialogs/select.h" +#include "include/kodi/c-api/gui/dialogs/text_viewer.h" +#include "include/kodi/c-api/gui/dialogs/yes_no.h" +#include "include/kodi/c-api/gui/general.h" +#include "include/kodi/c-api/monitor.h" +#include "include/kodi/c-api/network.h" + +ATTR_DL_DLL_EXPORT bool load_kodi_api_1(struct kodi_api_1* api) +{ + if (api == NULL) + { + return false; + } + + // addon_base.h + api->kodi_addon_get_addon_path = &kodi_addon_get_addon_path; + api->kodi_addon_get_info = &kodi_addon_get_info; + api->kodi_addon_get_lib_path = &kodi_addon_get_lib_path; + api->kodi_addon_get_setting_bool = &kodi_addon_get_setting_bool; + api->kodi_addon_get_setting_float = &kodi_addon_get_setting_float; + api->kodi_addon_get_setting_int = &kodi_addon_get_setting_int; + api->kodi_addon_get_setting_string = &kodi_addon_get_setting_string; + api->kodi_addon_get_temp_path = &kodi_addon_get_temp_path; + api->kodi_addon_get_user_path = &kodi_addon_get_user_path; + api->kodi_addon_instance_get_setting_bool = &kodi_addon_instance_get_setting_bool; + api->kodi_addon_instance_get_setting_float = &kodi_addon_instance_get_setting_float; + api->kodi_addon_instance_get_setting_int = &kodi_addon_instance_get_setting_int; + api->kodi_addon_instance_get_setting_string = &kodi_addon_instance_get_setting_string; + api->kodi_addon_instance_get_user_path = &kodi_addon_instance_get_user_path; + api->kodi_addon_instance_is_setting_using_default = &kodi_addon_instance_is_setting_using_default; + api->kodi_addon_instance_set_setting_bool = &kodi_addon_instance_set_setting_bool; + api->kodi_addon_instance_set_setting_float = &kodi_addon_instance_set_setting_float; + api->kodi_addon_instance_set_setting_int = &kodi_addon_instance_set_setting_int; + api->kodi_addon_instance_set_setting_string = &kodi_addon_instance_set_setting_string; + api->kodi_addon_is_setting_using_default = &kodi_addon_is_setting_using_default; + api->kodi_addon_localized_string = &kodi_addon_localized_string; + api->kodi_addon_open_settings_dialog = &kodi_addon_open_settings_dialog; + api->kodi_addon_set_setting_bool = &kodi_addon_set_setting_bool; + api->kodi_addon_set_setting_float = &kodi_addon_set_setting_float; + api->kodi_addon_set_setting_int = &kodi_addon_set_setting_int; + api->kodi_addon_set_setting_string = &kodi_addon_set_setting_string; + api->kodi_check_main_shared = &kodi_check_main_shared; + api->kodi_deinit = &kodi_deinit; + api->kodi_init = &kodi_init; + api->kodi_log = &kodi_log; + api->kodi_process = &kodi_process; + + // audio_engine.h + api->kodi_audioengine_get_current_sink_format = &kodi_audioengine_get_current_sink_format; + api->kodi_audioengine_is_planar_format = &kodi_audioengine_is_planar_format; + api->kodi_audioengine_stream_add_data = &kodi_audioengine_stream_add_data; + api->kodi_audioengine_stream_drain = &kodi_audioengine_stream_drain; + api->kodi_audioengine_stream_flush = &kodi_audioengine_stream_flush; + api->kodi_audioengine_stream_free = &kodi_audioengine_stream_free; + api->kodi_audioengine_stream_get_amplification = &kodi_audioengine_stream_get_amplification; + api->kodi_audioengine_stream_get_cache_time = &kodi_audioengine_stream_get_cache_time; + api->kodi_audioengine_stream_get_cache_total = &kodi_audioengine_stream_get_cache_total; + api->kodi_audioengine_stream_get_channel_count = &kodi_audioengine_stream_get_channel_count; + api->kodi_audioengine_stream_get_data_format = &kodi_audioengine_stream_get_data_format; + api->kodi_audioengine_stream_get_delay = &kodi_audioengine_stream_get_delay; + api->kodi_audioengine_stream_get_frame_size = &kodi_audioengine_stream_get_frame_size; + api->kodi_audioengine_stream_get_resample_ratio = &kodi_audioengine_stream_get_resample_ratio; + api->kodi_audioengine_stream_get_sample_rate = &kodi_audioengine_stream_get_sample_rate; + api->kodi_audioengine_stream_get_space = &kodi_audioengine_stream_get_space; + api->kodi_audioengine_stream_get_volume = &kodi_audioengine_stream_get_volume; + api->kodi_audioengine_stream_is_buffering = &kodi_audioengine_stream_is_buffering; + api->kodi_audioengine_stream_is_drained = &kodi_audioengine_stream_is_drained; + api->kodi_audioengine_stream_is_draining = &kodi_audioengine_stream_is_draining; + api->kodi_audioengine_stream_make = &kodi_audioengine_stream_make; + api->kodi_audioengine_stream_pause = &kodi_audioengine_stream_pause; + api->kodi_audioengine_stream_resume = &kodi_audioengine_stream_resume; + api->kodi_audioengine_stream_set_amplification = &kodi_audioengine_stream_set_amplification; + api->kodi_audioengine_stream_set_resample_ratio = &kodi_audioengine_stream_set_resample_ratio; + api->kodi_audioengine_stream_set_volume = &kodi_audioengine_stream_set_volume; + + // filesystem.h + api->kodi_vfs_can_open_directory = &kodi_vfs_can_open_directory; + api->kodi_vfs_copy_file = &kodi_vfs_copy_file; + api->kodi_vfs_create_directory = &kodi_vfs_create_directory; + api->kodi_vfs_delete_file = &kodi_vfs_delete_file; + api->kodi_vfs_directory_exists = &kodi_vfs_directory_exists; + api->kodi_vfs_file_at_end = &kodi_vfs_file_at_end; + api->kodi_vfs_file_close = &kodi_vfs_file_close; + api->kodi_vfs_file_curl_add_option = &kodi_vfs_file_curl_add_option; + api->kodi_vfs_file_curl_create = &kodi_vfs_file_curl_create; + api->kodi_vfs_file_curl_open = &kodi_vfs_file_curl_open; + api->kodi_vfs_file_exists = &kodi_vfs_file_exists; + api->kodi_vfs_file_flush = &kodi_vfs_file_flush; + api->kodi_vfs_file_get_chunk_size = &kodi_vfs_file_get_chunk_size; + api->kodi_vfs_file_get_download_speed = &kodi_vfs_file_get_download_speed; + api->kodi_vfs_file_get_length = &kodi_vfs_file_get_length; + api->kodi_vfs_file_get_position = &kodi_vfs_file_get_position; + api->kodi_vfs_file_get_property_value = &kodi_vfs_file_get_property_value; + api->kodi_vfs_file_get_property_values = &kodi_vfs_file_get_property_values; + api->kodi_vfs_file_io_ctl_get_cache_status = &kodi_vfs_file_io_ctl_get_cache_status; + api->kodi_vfs_file_io_ctl_get_seek_possible = &kodi_vfs_file_io_ctl_get_seek_possible; + api->kodi_vfs_file_io_ctl_set_cache_rate = &kodi_vfs_file_io_ctl_set_cache_rate; + api->kodi_vfs_file_io_ctl_set_retry = &kodi_vfs_file_io_ctl_set_retry; + api->kodi_vfs_file_open = &kodi_vfs_file_open; + api->kodi_vfs_file_open_for_write = &kodi_vfs_file_open_for_write; + api->kodi_vfs_file_read = &kodi_vfs_file_read; + api->kodi_vfs_file_read_line = &kodi_vfs_file_read_line; + api->kodi_vfs_file_seek = &kodi_vfs_file_seek; + api->kodi_vfs_file_truncate = &kodi_vfs_file_truncate; + api->kodi_vfs_file_write = &kodi_vfs_file_write; + api->kodi_vfs_free_directory = &kodi_vfs_free_directory; + api->kodi_vfs_get_cache_thumb_name = &kodi_vfs_get_cache_thumb_name; + api->kodi_vfs_get_content_type = &kodi_vfs_get_content_type; + api->kodi_vfs_get_cookies = &kodi_vfs_get_cookies; + api->kodi_vfs_get_directory = &kodi_vfs_get_directory; + api->kodi_vfs_get_disk_space = &kodi_vfs_get_disk_space; + api->kodi_vfs_get_file_md5 = &kodi_vfs_get_file_md5; + api->kodi_vfs_get_mime_type = &kodi_vfs_get_mime_type; + api->kodi_vfs_http_header_close = &kodi_vfs_http_header_close; + api->kodi_vfs_http_header_get_charset = &kodi_vfs_http_header_get_charset; + api->kodi_vfs_http_header_get_header = &kodi_vfs_http_header_get_header; + api->kodi_vfs_http_header_get_mime_type = &kodi_vfs_http_header_get_mime_type; + api->kodi_vfs_http_header_get_proto_line = &kodi_vfs_http_header_get_proto_line; + api->kodi_vfs_http_header_get_value = &kodi_vfs_http_header_get_value; + api->kodi_vfs_http_header_get_values = &kodi_vfs_http_header_get_values; + api->kodi_vfs_http_header_open = &kodi_vfs_http_header_open; + api->kodi_vfs_is_internet_stream = &kodi_vfs_is_internet_stream; + api->kodi_vfs_is_local = &kodi_vfs_is_local; + api->kodi_vfs_is_on_lan = &kodi_vfs_is_on_lan; + api->kodi_vfs_is_remote = &kodi_vfs_is_remote; + api->kodi_vfs_is_url = &kodi_vfs_is_url; + api->kodi_vfs_make_legal_filename = &kodi_vfs_make_legal_filename; + api->kodi_vfs_make_legal_path = &kodi_vfs_make_legal_path; + api->kodi_vfs_remove_directory = &kodi_vfs_remove_directory; + api->kodi_vfs_remove_directory_recursive = &kodi_vfs_remove_directory_recursive; + api->kodi_vfs_rename_file = &kodi_vfs_rename_file; + api->kodi_vfs_stat_file = &kodi_vfs_stat_file; + api->kodi_vfs_translate_special_protocol = &kodi_vfs_translate_special_protocol; + + // general.h + api->kodi_change_keyboard_layout = &kodi_change_keyboard_layout; + api->kodi_get_current_skin_id = &kodi_get_current_skin_id; + api->kodi_get_digest = &kodi_get_digest; + api->kodi_get_free_mem = &kodi_get_free_mem; + api->kodi_get_global_idle_time = &kodi_get_global_idle_time; + api->kodi_get_keyboard_layout = &kodi_get_keyboard_layout; + api->kodi_get_language = &kodi_get_language; + api->kodi_get_localized_string = &kodi_get_localized_string; + api->kodi_get_region = &kodi_get_region; + api->kodi_is_addon_avilable = &kodi_is_addon_avilable; + api->kodi_play_sfx = &kodi_play_sfx; + api->kodi_queue_notification = &kodi_queue_notification; + api->kodi_stop_sfx = &kodi_stop_sfx; + api->kodi_unknown_to_utf8 = &kodi_unknown_to_utf8; + api->kodi_version = &kodi_version; + + // monitor.h + api->kodi_monitor_abort_requested = &kodi_monitor_abort_requested; + api->kodi_monitor_wait_for_abort = &kodi_monitor_wait_for_abort; + + // network.h + api->kodi_network_dns_lookup = &kodi_network_dns_lookup; + api->kodi_network_get_hostname = &kodi_network_get_hostname; + api->kodi_network_get_ip_address = &kodi_network_get_ip_address; + api->kodi_network_get_user_agent = &kodi_network_get_user_agent; + api->kodi_network_is_host_on_lan = &kodi_network_is_host_on_lan; + api->kodi_network_is_local_host = &kodi_network_is_local_host; + api->kodi_network_url_encode = &kodi_network_url_encode; + api->kodi_network_wake_on_lan = &kodi_network_wake_on_lan; + + // addon-instance/audioencoder.h + api->kodi_addon_audioencoder_seek = &kodi_addon_audioencoder_seek; + api->kodi_addon_audioencoder_write = &kodi_addon_audioencoder_write; + + // addon-instance/game.h + api->kodi_addon_game_add_stream_data = &kodi_addon_game_add_stream_data; + api->kodi_addon_game_close = &kodi_addon_game_close; + api->kodi_addon_game_close_stream = &kodi_addon_game_close_stream; + api->kodi_addon_game_get_stream_buffer = &kodi_addon_game_get_stream_buffer; + api->kodi_addon_game_hw_get_proc_address = &kodi_addon_game_hw_get_proc_address; + api->kodi_addon_game_input_event = &kodi_addon_game_input_event; + api->kodi_addon_game_open_stream = &kodi_addon_game_open_stream; + api->kodi_addon_game_release_stream_buffer = &kodi_addon_game_release_stream_buffer; + + // addon-instance/inputstream.h + api->kodi_addon_inputstream_allocate_demux_packet = &kodi_addon_inputstream_allocate_demux_packet; + api->kodi_addon_inputstream_allocate_encrypted_demux_packet = + &kodi_addon_inputstream_allocate_encrypted_demux_packet; + api->kodi_addon_inputstream_free_demux_packet = &kodi_addon_inputstream_free_demux_packet; + + // addon-instance/peripheral.h + api->kodi_addon_peripheral_feature_count = &kodi_addon_peripheral_feature_count; + api->kodi_addon_peripheral_feature_type = &kodi_addon_peripheral_feature_type; + api->kodi_addon_peripheral_refresh_button_maps = &kodi_addon_peripheral_refresh_button_maps; + api->kodi_addon_peripheral_trigger_scan = &kodi_addon_peripheral_trigger_scan; + + // addon-instance/pvr.h + api->kodi_addon_pvr_add_menu_hook = &kodi_addon_pvr_add_menu_hook; + api->kodi_addon_pvr_connection_state_change = &kodi_addon_pvr_connection_state_change; + api->kodi_addon_pvr_epg_event_state_change = &kodi_addon_pvr_epg_event_state_change; + api->kodi_addon_pvr_get_epg_max_future_days = &kodi_addon_pvr_get_epg_max_future_days; + api->kodi_addon_pvr_get_epg_max_past_days = &kodi_addon_pvr_get_epg_max_past_days; + api->kodi_addon_pvr_recording_notification = &kodi_addon_pvr_recording_notification; + api->kodi_addon_pvr_transfer_channel_entry = &kodi_addon_pvr_transfer_channel_entry; + api->kodi_addon_pvr_transfer_channel_group = &kodi_addon_pvr_transfer_channel_group; + api->kodi_addon_pvr_transfer_channel_group_member = &kodi_addon_pvr_transfer_channel_group_member; + api->kodi_addon_pvr_transfer_epg_entry = &kodi_addon_pvr_transfer_epg_entry; + api->kodi_addon_pvr_transfer_provider_entry = &kodi_addon_pvr_transfer_provider_entry; + api->kodi_addon_pvr_transfer_recording_entry = &kodi_addon_pvr_transfer_recording_entry; + api->kodi_addon_pvr_transfer_timer_entry = &kodi_addon_pvr_transfer_timer_entry; + api->kodi_addon_pvr_trigger_channel_groups_update = &kodi_addon_pvr_trigger_channel_groups_update; + api->kodi_addon_pvr_trigger_channel_update = &kodi_addon_pvr_trigger_channel_update; + api->kodi_addon_pvr_trigger_epg_update = &kodi_addon_pvr_trigger_epg_update; + api->kodi_addon_pvr_trigger_providers_update = &kodi_addon_pvr_trigger_providers_update; + api->kodi_addon_pvr_trigger_recording_update = &kodi_addon_pvr_trigger_recording_update; + api->kodi_addon_pvr_trigger_timer_update = &kodi_addon_pvr_trigger_timer_update; + + // addon-instance/screensaver.h + api->kodi_addon_screensaver_get_properties = &kodi_addon_screensaver_get_properties; + + // addon-instance/vfs.h + api->kodi_addon_vfs_get_dir_cb__get_keyboard_input = + &kodi_addon_vfs_get_dir_cb__get_keyboard_input; + api->kodi_addon_vfs_get_dir_cb__require_authentication = + &kodi_addon_vfs_get_dir_cb__require_authentication; + api->kodi_addon_vfs_get_dir_cb__set_error_dialog = &kodi_addon_vfs_get_dir_cb__set_error_dialog; + + // addon-instance/videocodec.h + api->kodi_addon_videocodec_get_frame_buffer = &kodi_addon_videocodec_get_frame_buffer; + api->kodi_addon_videocodec_release_frame_buffer = &kodi_addon_videocodec_release_frame_buffer; + + // addon-instance/visualization.h + api->kodi_addon_visualization_clear_presets = &kodi_addon_visualization_clear_presets; + api->kodi_addon_visualization_get_properties = &kodi_addon_visualization_get_properties; + api->kodi_addon_visualization_transfer_preset = &kodi_addon_visualization_transfer_preset; + + // addon-instance/web.h + api->kodi_addon_web_control_request_open_site_in_new_tab = + &kodi_addon_web_control_request_open_site_in_new_tab; + api->kodi_addon_web_control_set_control_ready = &kodi_addon_web_control_set_control_ready; + api->kodi_addon_web_control_set_fullscreen = &kodi_addon_web_control_set_fullscreen; + api->kodi_addon_web_control_set_icon_url = &kodi_addon_web_control_set_icon_url; + api->kodi_addon_web_control_set_loading_state = &kodi_addon_web_control_set_loading_state; + api->kodi_addon_web_control_set_opened_address = &kodi_addon_web_control_set_opened_address; + api->kodi_addon_web_control_set_opened_title = &kodi_addon_web_control_set_opened_title; + api->kodi_addon_web_control_set_status_message = &kodi_addon_web_control_set_status_message; + api->kodi_addon_web_control_set_tooltip = &kodi_addon_web_control_set_tooltip; + api->kodi_addon_web_inhibit_screensaver = &kodi_addon_web_inhibit_screensaver; + api->kodi_addon_web_inhibit_shutdown = &kodi_addon_web_inhibit_shutdown; + api->kodi_addon_web_is_muted = &kodi_addon_web_is_muted; + + // gui/general.h + api->kodi_gui_get_current_window_dialog_id = &kodi_gui_get_current_window_dialog_id; + api->kodi_gui_get_current_window_id = &kodi_gui_get_current_window_id; + api->kodi_gui_get_hw_context = &kodi_gui_get_hw_context; + api->kodi_gui_get_screen_height = &kodi_gui_get_screen_height; + api->kodi_gui_get_screen_width = &kodi_gui_get_screen_width; + api->kodi_gui_get_video_resolution = &kodi_gui_get_video_resolution; + api->kodi_gui_lock = &kodi_gui_lock; + api->kodi_gui_unlock = &kodi_gui_unlock; + + // gui/list_item.h + api->kodi_gui_listitem_create = &kodi_gui_listitem_create; + api->kodi_gui_listitem_destroy = &kodi_gui_listitem_destroy; + api->kodi_gui_listitem_get_art = &kodi_gui_listitem_get_art; + api->kodi_gui_listitem_get_label = &kodi_gui_listitem_get_label; + api->kodi_gui_listitem_get_label2 = &kodi_gui_listitem_get_label2; + api->kodi_gui_listitem_get_path = &kodi_gui_listitem_get_path; + api->kodi_gui_listitem_get_property = &kodi_gui_listitem_get_property; + api->kodi_gui_listitem_is_selected = &kodi_gui_listitem_is_selected; + api->kodi_gui_listitem_select = &kodi_gui_listitem_select; + api->kodi_gui_listitem_set_art = &kodi_gui_listitem_set_art; + api->kodi_gui_listitem_set_label = &kodi_gui_listitem_set_label; + api->kodi_gui_listitem_set_label2 = &kodi_gui_listitem_set_label2; + api->kodi_gui_listitem_set_path = &kodi_gui_listitem_set_path; + api->kodi_gui_listitem_set_property = &kodi_gui_listitem_set_property; + + // gui/window.h + api->kodi_gui_window_add_list_item = &kodi_gui_window_add_list_item; + api->kodi_gui_window_clear_item_list = &kodi_gui_window_clear_item_list; + api->kodi_gui_window_clear_properties = &kodi_gui_window_clear_properties; + api->kodi_gui_window_clear_property = &kodi_gui_window_clear_property; + api->kodi_gui_window_close = &kodi_gui_window_close; + api->kodi_gui_window_create = &kodi_gui_window_create; + api->kodi_gui_window_destroy = &kodi_gui_window_destroy; + api->kodi_gui_window_do_modal = &kodi_gui_window_do_modal; + api->kodi_gui_window_get_control_button = &kodi_gui_window_get_control_button; + api->kodi_gui_window_get_control_edit = &kodi_gui_window_get_control_edit; + api->kodi_gui_window_get_control_fade_label = &kodi_gui_window_get_control_fade_label; + api->kodi_gui_window_get_control_image = &kodi_gui_window_get_control_image; + api->kodi_gui_window_get_control_label = &kodi_gui_window_get_control_label; + api->kodi_gui_window_get_control_progress = &kodi_gui_window_get_control_progress; + api->kodi_gui_window_get_control_radio_button = &kodi_gui_window_get_control_radio_button; + api->kodi_gui_window_get_control_render_addon = &kodi_gui_window_get_control_render_addon; + api->kodi_gui_window_get_control_settings_slider = &kodi_gui_window_get_control_settings_slider; + api->kodi_gui_window_get_control_slider = &kodi_gui_window_get_control_slider; + api->kodi_gui_window_get_control_spin = &kodi_gui_window_get_control_spin; + api->kodi_gui_window_get_control_text_box = &kodi_gui_window_get_control_text_box; + api->kodi_gui_window_get_current_container_id = &kodi_gui_window_get_current_container_id; + api->kodi_gui_window_get_current_list_position = &kodi_gui_window_get_current_list_position; + api->kodi_gui_window_get_focus_id = &kodi_gui_window_get_focus_id; + api->kodi_gui_window_get_list_item = &kodi_gui_window_get_list_item; + api->kodi_gui_window_get_list_size = &kodi_gui_window_get_list_size; + api->kodi_gui_window_get_property = &kodi_gui_window_get_property; + api->kodi_gui_window_get_property_bool = &kodi_gui_window_get_property_bool; + api->kodi_gui_window_get_property_double = &kodi_gui_window_get_property_double; + api->kodi_gui_window_get_property_int = &kodi_gui_window_get_property_int; + api->kodi_gui_window_mark_dirty_region = &kodi_gui_window_mark_dirty_region; + api->kodi_gui_window_remove_list_item = &kodi_gui_window_remove_list_item; + api->kodi_gui_window_remove_list_item_from_position = + &kodi_gui_window_remove_list_item_from_position; + api->kodi_gui_window_set_container_content = &kodi_gui_window_set_container_content; + api->kodi_gui_window_set_container_property = &kodi_gui_window_set_container_property; + api->kodi_gui_window_set_control_label = &kodi_gui_window_set_control_label; + api->kodi_gui_window_set_control_selected = &kodi_gui_window_set_control_selected; + api->kodi_gui_window_set_control_visible = &kodi_gui_window_set_control_visible; + api->kodi_gui_window_set_current_list_position = &kodi_gui_window_set_current_list_position; + api->kodi_gui_window_set_focus_id = &kodi_gui_window_set_focus_id; + api->kodi_gui_window_set_property = &kodi_gui_window_set_property; + api->kodi_gui_window_set_property_bool = &kodi_gui_window_set_property_bool; + api->kodi_gui_window_set_property_double = &kodi_gui_window_set_property_double; + api->kodi_gui_window_set_property_int = &kodi_gui_window_set_property_int; + api->kodi_gui_window_show = &kodi_gui_window_show; + + // gui/controls/button.h + api->kodi_gui_controls_button_get_label = &kodi_gui_controls_button_get_label; + api->kodi_gui_controls_button_get_label2 = &kodi_gui_controls_button_get_label2; + api->kodi_gui_controls_button_set_enabled = &kodi_gui_controls_button_set_enabled; + api->kodi_gui_controls_button_set_label = &kodi_gui_controls_button_set_label; + api->kodi_gui_controls_button_set_label2 = &kodi_gui_controls_button_set_label2; + api->kodi_gui_controls_button_set_visible = &kodi_gui_controls_button_set_visible; + + // gui/controls/edit.h + api->kodi_gui_controls_edit_get_cursor_position = &kodi_gui_controls_edit_get_cursor_position; + api->kodi_gui_controls_edit_get_label = &kodi_gui_controls_edit_get_label; + api->kodi_gui_controls_edit_get_text = &kodi_gui_controls_edit_get_text; + api->kodi_gui_controls_edit_set_cursor_position = &kodi_gui_controls_edit_set_cursor_position; + api->kodi_gui_controls_edit_set_enabled = &kodi_gui_controls_edit_set_enabled; + api->kodi_gui_controls_edit_set_input_type = &kodi_gui_controls_edit_set_input_type; + api->kodi_gui_controls_edit_set_label = &kodi_gui_controls_edit_set_label; + api->kodi_gui_controls_edit_set_text = &kodi_gui_controls_edit_set_text; + api->kodi_gui_controls_edit_set_visible = &kodi_gui_controls_edit_set_visible; + + // gui/controls/fade_label.h + api->kodi_gui_controls_fade_label_add_label = &kodi_gui_controls_fade_label_add_label; + api->kodi_gui_controls_fade_label_get_label = &kodi_gui_controls_fade_label_get_label; + api->kodi_gui_controls_fade_label_reset = &kodi_gui_controls_fade_label_reset; + api->kodi_gui_controls_fade_label_set_scrolling = &kodi_gui_controls_fade_label_set_scrolling; + api->kodi_gui_controls_fade_label_set_visible = &kodi_gui_controls_fade_label_set_visible; + + // gui/controls/image.h + api->kodi_gui_controls_image_set_color_diffuse = &kodi_gui_controls_image_set_color_diffuse; + api->kodi_gui_controls_image_set_filename = &kodi_gui_controls_image_set_filename; + api->kodi_gui_controls_image_set_visible = &kodi_gui_controls_image_set_visible; + + // gui/controls/label.h + api->kodi_gui_controls_label_get_label = &kodi_gui_controls_label_get_label; + api->kodi_gui_controls_label_set_label = &kodi_gui_controls_label_set_label; + api->kodi_gui_controls_label_set_visible = &kodi_gui_controls_label_set_visible; + + // gui/controls/progress.h + api->kodi_gui_controls_progress_get_percentage = &kodi_gui_controls_progress_get_percentage; + api->kodi_gui_controls_progress_set_percentage = &kodi_gui_controls_progress_set_percentage; + api->kodi_gui_controls_progress_set_visible = &kodi_gui_controls_progress_set_visible; + + // gui/controls/radio_button.h + api->kodi_gui_controls_radio_button_get_label = &kodi_gui_controls_radio_button_get_label; + api->kodi_gui_controls_radio_button_is_selected = &kodi_gui_controls_radio_button_is_selected; + api->kodi_gui_controls_radio_button_set_enabled = &kodi_gui_controls_radio_button_set_enabled; + api->kodi_gui_controls_radio_button_set_label = &kodi_gui_controls_radio_button_set_label; + api->kodi_gui_controls_radio_button_set_selected = &kodi_gui_controls_radio_button_set_selected; + api->kodi_gui_controls_radio_button_set_visible = &kodi_gui_controls_radio_button_set_visible; + + // gui/controls/rendering.h + api->kodi_gui_controls_radio_rendering_destroy = &kodi_gui_controls_radio_rendering_destroy; + + // gui/controls/settings_slider.h + api->kodi_gui_controls_settings_slider_get_float_value = + &kodi_gui_controls_settings_slider_get_float_value; + api->kodi_gui_controls_settings_slider_get_int_value = + &kodi_gui_controls_settings_slider_get_int_value; + api->kodi_gui_controls_settings_slider_get_percentage = + &kodi_gui_controls_settings_slider_get_percentage; + api->kodi_gui_controls_settings_slider_reset = &kodi_gui_controls_settings_slider_reset; + api->kodi_gui_controls_settings_slider_set_enabled = + &kodi_gui_controls_settings_slider_set_enabled; + api->kodi_gui_controls_settings_slider_set_float_interval = + &kodi_gui_controls_settings_slider_set_float_interval; + api->kodi_gui_controls_settings_slider_set_float_range = + &kodi_gui_controls_settings_slider_set_float_range; + api->kodi_gui_controls_settings_slider_set_float_value = + &kodi_gui_controls_settings_slider_set_float_value; + api->kodi_gui_controls_settings_slider_set_int_interval = + &kodi_gui_controls_settings_slider_set_int_interval; + api->kodi_gui_controls_settings_slider_set_int_range = + &kodi_gui_controls_settings_slider_set_int_range; + api->kodi_gui_controls_settings_slider_set_int_value = + &kodi_gui_controls_settings_slider_set_int_value; + api->kodi_gui_controls_settings_slider_set_percentage = + &kodi_gui_controls_settings_slider_set_percentage; + api->kodi_gui_controls_settings_slider_set_text = &kodi_gui_controls_settings_slider_set_text; + api->kodi_gui_controls_settings_slider_set_visible = + &kodi_gui_controls_settings_slider_set_visible; + + // gui/controls/slider.h + api->kodi_gui_controls_slider_get_description = &kodi_gui_controls_slider_get_description; + api->kodi_gui_controls_slider_get_float_value = &kodi_gui_controls_slider_get_float_value; + api->kodi_gui_controls_slider_get_int_value = &kodi_gui_controls_slider_get_int_value; + api->kodi_gui_controls_slider_get_percentage = &kodi_gui_controls_slider_get_percentage; + api->kodi_gui_controls_slider_reset = &kodi_gui_controls_slider_reset; + api->kodi_gui_controls_slider_set_enabled = &kodi_gui_controls_slider_set_enabled; + api->kodi_gui_controls_slider_set_float_interval = &kodi_gui_controls_slider_set_float_interval; + api->kodi_gui_controls_slider_set_float_range = &kodi_gui_controls_slider_set_float_range; + api->kodi_gui_controls_slider_set_float_value = &kodi_gui_controls_slider_set_float_value; + api->kodi_gui_controls_slider_set_int_interval = &kodi_gui_controls_slider_set_int_interval; + api->kodi_gui_controls_slider_set_int_range = &kodi_gui_controls_slider_set_int_range; + api->kodi_gui_controls_slider_set_int_value = &kodi_gui_controls_slider_set_int_value; + api->kodi_gui_controls_slider_set_percentage = &kodi_gui_controls_slider_set_percentage; + api->kodi_gui_controls_slider_set_visible = &kodi_gui_controls_slider_set_visible; + + // gui/controls/spin.h + api->kodi_gui_controls_spin_add_int_label = &kodi_gui_controls_spin_add_int_label; + api->kodi_gui_controls_spin_add_string_label = &kodi_gui_controls_spin_add_string_label; + api->kodi_gui_controls_spin_get_float_value = &kodi_gui_controls_spin_get_float_value; + api->kodi_gui_controls_spin_get_int_value = &kodi_gui_controls_spin_get_int_value; + api->kodi_gui_controls_spin_get_string_value = &kodi_gui_controls_spin_get_string_value; + api->kodi_gui_controls_spin_reset = &kodi_gui_controls_spin_reset; + api->kodi_gui_controls_spin_set_enabled = &kodi_gui_controls_spin_set_enabled; + api->kodi_gui_controls_spin_set_float_interval = &kodi_gui_controls_spin_set_float_interval; + api->kodi_gui_controls_spin_set_float_range = &kodi_gui_controls_spin_set_float_range; + api->kodi_gui_controls_spin_set_float_value = &kodi_gui_controls_spin_set_float_value; + api->kodi_gui_controls_spin_set_int_range = &kodi_gui_controls_spin_set_int_range; + api->kodi_gui_controls_spin_set_int_value = &kodi_gui_controls_spin_set_int_value; + api->kodi_gui_controls_spin_set_string_value = &kodi_gui_controls_spin_set_string_value; + api->kodi_gui_controls_spin_set_text = &kodi_gui_controls_spin_set_text; + api->kodi_gui_controls_spin_set_type = &kodi_gui_controls_spin_set_type; + api->kodi_gui_controls_spin_set_visible = &kodi_gui_controls_spin_set_visible; + + // gui/controls/text_box.h + api->kodi_gui_controls_text_box_get_text = &kodi_gui_controls_text_box_get_text; + api->kodi_gui_controls_text_box_reset = &kodi_gui_controls_text_box_reset; + api->kodi_gui_controls_text_box_scroll = &kodi_gui_controls_text_box_scroll; + api->kodi_gui_controls_text_box_set_auto_scrolling = + &kodi_gui_controls_text_box_set_auto_scrolling; + api->kodi_gui_controls_text_box_set_text = &kodi_gui_controls_text_box_set_text; + api->kodi_gui_controls_text_box_set_visible = &kodi_gui_controls_text_box_set_visible; + + // gui/dialogs/context_menu.h + api->kodi_gui_dialogs_context_menu_open = &kodi_gui_dialogs_context_menu_open; + + // gui/dialogs/extended_progress.h + api->kodi_gui_dialogs_extended_progress_delete_dialog = + &kodi_gui_dialogs_extended_progress_delete_dialog; + api->kodi_gui_dialogs_extended_progress_get_percentage = + &kodi_gui_dialogs_extended_progress_get_percentage; + api->kodi_gui_dialogs_extended_progress_get_text = &kodi_gui_dialogs_extended_progress_get_text; + api->kodi_gui_dialogs_extended_progress_get_title = &kodi_gui_dialogs_extended_progress_get_title; + api->kodi_gui_dialogs_extended_progress_is_finished = + &kodi_gui_dialogs_extended_progress_is_finished; + api->kodi_gui_dialogs_extended_progress_mark_finished = + &kodi_gui_dialogs_extended_progress_mark_finished; + api->kodi_gui_dialogs_extended_progress_new_dialog = + &kodi_gui_dialogs_extended_progress_new_dialog; + api->kodi_gui_dialogs_extended_progress_set_percentage = + &kodi_gui_dialogs_extended_progress_set_percentage; + api->kodi_gui_dialogs_extended_progress_set_progress = + &kodi_gui_dialogs_extended_progress_set_progress; + api->kodi_gui_dialogs_extended_progress_set_text = &kodi_gui_dialogs_extended_progress_set_text; + api->kodi_gui_dialogs_extended_progress_set_title = &kodi_gui_dialogs_extended_progress_set_title; + + // gui/dialogs/filebrowser.h + api->kodi_gui_dialogs_file_browser_clear_file_list = + &kodi_gui_dialogs_file_browser_clear_file_list; + api->kodi_gui_dialogs_file_browser_show_and_get_directory = + &kodi_gui_dialogs_file_browser_show_and_get_directory; + api->kodi_gui_dialogs_file_browser_show_and_get_file = + &kodi_gui_dialogs_file_browser_show_and_get_file; + api->kodi_gui_dialogs_file_browser_show_and_get_file_from_dir = + &kodi_gui_dialogs_file_browser_show_and_get_file_from_dir; + api->kodi_gui_dialogs_file_browser_show_and_get_file_list = + &kodi_gui_dialogs_file_browser_show_and_get_file_list; + api->kodi_gui_dialogs_file_browser_show_and_get_image = + &kodi_gui_dialogs_file_browser_show_and_get_image; + api->kodi_gui_dialogs_file_browser_show_and_get_image_list = + &kodi_gui_dialogs_file_browser_show_and_get_image_list; + api->kodi_gui_dialogs_file_browser_show_and_get_source = + &kodi_gui_dialogs_file_browser_show_and_get_source; + + // gui/dialogs/keyboard.h + api->kodi_gui_dialogs_keyboard_is_keyboard_activated = + &kodi_gui_dialogs_keyboard_is_keyboard_activated; + api->kodi_gui_dialogs_keyboard_send_text_to_active_keyboard = + &kodi_gui_dialogs_keyboard_send_text_to_active_keyboard; + api->kodi_gui_dialogs_keyboard_show_and_get_filter = + &kodi_gui_dialogs_keyboard_show_and_get_filter; + api->kodi_gui_dialogs_keyboard_show_and_get_input = &kodi_gui_dialogs_keyboard_show_and_get_input; + api->kodi_gui_dialogs_keyboard_show_and_get_input_with_head = + &kodi_gui_dialogs_keyboard_show_and_get_input_with_head; + api->kodi_gui_dialogs_keyboard_show_and_get_new_password = + &kodi_gui_dialogs_keyboard_show_and_get_new_password; + api->kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head = + &kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head; + api->kodi_gui_dialogs_keyboard_show_and_verify_new_password = + &kodi_gui_dialogs_keyboard_show_and_verify_new_password; + api->kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head = + &kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head; + api->kodi_gui_dialogs_keyboard_show_and_verify_password = + &kodi_gui_dialogs_keyboard_show_and_verify_password; + + // gui/dialogs/numeric.h + api->kodi_gui_dialogs_numeric_show_and_get_date = &kodi_gui_dialogs_numeric_show_and_get_date; + api->kodi_gui_dialogs_numeric_show_and_get_ip_address = + &kodi_gui_dialogs_numeric_show_and_get_ip_address; + api->kodi_gui_dialogs_numeric_show_and_get_number = &kodi_gui_dialogs_numeric_show_and_get_number; + api->kodi_gui_dialogs_numeric_show_and_get_seconds = + &kodi_gui_dialogs_numeric_show_and_get_seconds; + api->kodi_gui_dialogs_numeric_show_and_get_time = &kodi_gui_dialogs_numeric_show_and_get_time; + api->kodi_gui_dialogs_numeric_show_and_verify_input = + &kodi_gui_dialogs_numeric_show_and_verify_input; + api->kodi_gui_dialogs_numeric_show_and_verify_new_password = + &kodi_gui_dialogs_numeric_show_and_verify_new_password; + api->kodi_gui_dialogs_numeric_show_and_verify_password = + &kodi_gui_dialogs_numeric_show_and_verify_password; + + // gui/dialogs/ok.h + api->kodi_gui_dialogs_ok_show_and_get_input_line_text = + &kodi_gui_dialogs_ok_show_and_get_input_line_text; + api->kodi_gui_dialogs_ok_show_and_get_input_single_text = + &kodi_gui_dialogs_ok_show_and_get_input_single_text; + + // gui/dialogs/progress.h + api->kodi_gui_dialogs_progress_abort = &kodi_gui_dialogs_progress_abort; + api->kodi_gui_dialogs_progress_delete_dialog = &kodi_gui_dialogs_progress_delete_dialog; + api->kodi_gui_dialogs_progress_get_percentage = &kodi_gui_dialogs_progress_get_percentage; + api->kodi_gui_dialogs_progress_is_canceled = &kodi_gui_dialogs_progress_is_canceled; + api->kodi_gui_dialogs_progress_new_dialog = &kodi_gui_dialogs_progress_new_dialog; + api->kodi_gui_dialogs_progress_open = &kodi_gui_dialogs_progress_open; + api->kodi_gui_dialogs_progress_set_can_cancel = &kodi_gui_dialogs_progress_set_can_cancel; + api->kodi_gui_dialogs_progress_set_heading = &kodi_gui_dialogs_progress_set_heading; + api->kodi_gui_dialogs_progress_set_line = &kodi_gui_dialogs_progress_set_line; + api->kodi_gui_dialogs_progress_set_percentage = &kodi_gui_dialogs_progress_set_percentage; + api->kodi_gui_dialogs_progress_set_progress_advance = + &kodi_gui_dialogs_progress_set_progress_advance; + api->kodi_gui_dialogs_progress_set_progress_max = &kodi_gui_dialogs_progress_set_progress_max; + api->kodi_gui_dialogs_progress_show_progress_bar = &kodi_gui_dialogs_progress_show_progress_bar; + + // gui/dialogs/select.h + api->kodi_gui_dialogs_select_open = &kodi_gui_dialogs_select_open; + api->kodi_gui_dialogs_select_open_multi_select = &kodi_gui_dialogs_select_open_multi_select; + + // gui/dialogs/text_viewer.h + api->kodi_gui_dialogs_text_viewer_show = &kodi_gui_dialogs_text_viewer_show; + + // gui/dialogs/yes_no.h + api->kodi_gui_dialogs_yesno_show_and_get_input_line_button_text = + &kodi_gui_dialogs_yesno_show_and_get_input_line_button_text; + api->kodi_gui_dialogs_yesno_show_and_get_input_line_text = + &kodi_gui_dialogs_yesno_show_and_get_input_line_text; + api->kodi_gui_dialogs_yesno_show_and_get_input_single_text = + &kodi_gui_dialogs_yesno_show_and_get_input_single_text; + + return true; +} diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/filesystem.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/filesystem.cpp new file mode 100644 index 0000000000000..d7ef08df80105 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/filesystem.cpp @@ -0,0 +1,1762 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "filesystem.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_filesystem_h::InitDirect(directFuncToAddon_filesystem_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT bool kodi_vfs_can_open_directory(const char* url) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_can_open_directory(const char* url) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_can_open_directory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_can_open_directory_v1; /* Autogenerated */ + + if (url == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_can_open_directory_v1(url)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_can_open_directory_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_can_open_directory_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_can_open_directory_v1(auto_gen_group.thisClassHdl, url); +} + +ATTR_DLL_EXPORT bool kodi_vfs_create_directory(const char* path) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_create_directory(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_create_directory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_create_directory_v1; /* Autogenerated */ + + if (path == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_create_directory_v1(path)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_create_directory_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_create_directory_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_create_directory_v1(auto_gen_group.thisClassHdl, path); +} + +ATTR_DLL_EXPORT bool kodi_vfs_remove_directory(const char* path) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_remove_directory(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_remove_directory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_remove_directory_v1; /* Autogenerated */ + + if (path == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_remove_directory_v1(path)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_remove_directory_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_remove_directory_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_remove_directory_v1(auto_gen_group.thisClassHdl, path); +} + +ATTR_DLL_EXPORT bool kodi_vfs_remove_directory_recursive(const char* path) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_remove_directory_recursive(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_remove_directory_recursive_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_remove_directory_recursive_v1; /* Autogenerated */ + + if (path == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_remove_directory_recursive_v1(path)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_remove_directory_recursive_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_remove_directory_recursive_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_remove_directory_recursive_v1(auto_gen_group.thisClassHdl, path); +} + +ATTR_DLL_EXPORT bool kodi_vfs_directory_exists(const char* path) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_directory_exists(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_directory_exists_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_directory_exists_v1; /* Autogenerated */ + + if (path == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_directory_exists_v1(path)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_directory_exists_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_directory_exists_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_directory_exists_v1(auto_gen_group.thisClassHdl, path); +} + +ATTR_DLL_EXPORT bool kodi_vfs_get_directory(const char* path, + const char* mask, + struct VFS_DIR_ENTRY** items, + size_t* num_items) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_get_directory(const char* path, const char* mask, struct VFS_DIR_ENTRY** items, size_t* num_items) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_directory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgParent_OUT_kodi_vfs_get_directory_v1; /* Autogenerated */ + + if (path == nullptr || mask == nullptr || items == nullptr || num_items == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_get_directory_v1(path, mask, *num_items)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_get_directory_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_get_directory_v1 t = ident.get().as(); + + std::vector& ifc_items = std::get<1>(t); + *num_items = std::get<2>(t); + *items = static_cast(calloc(ifc_items.size(), sizeof(VFS_DIR_ENTRY))); + for (size_t i = 0; i < ifc_items.size(); ++i) + ifc_items[i].SetCStructure(&(*items)[i]); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_get_directory_v1(auto_gen_group.thisClassHdl, path, mask, items, + num_items); +} + +ATTR_DLL_EXPORT void kodi_vfs_free_directory(struct VFS_DIR_ENTRY* items, size_t num_items) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_vfs_free_directory(struct VFS_DIR_ENTRY* items, size_t num_items) __INTRODUCED_IN_KODI(1); + // Tuple in: /* NOTE: msgParent__IN_kodi_vfs_free_directory - Override active to use inside dev-kit library only */ + // Tuple out: /* NOTE: msgParent_OUT_kodi_vfs_free_directory - Override active to use inside dev-kit library only */ + + /*---AUTO_GEN_PARSE---*/ + + for (unsigned int i = 0; i < num_items; ++i) + { + if (items[i].label) + { + free(items[i].label); + items[i].label = nullptr; + } + if (items[i].title) + { + free(items[i].title); + items[i].title = nullptr; + } + if (items[i].path) + { + free(items[i].path); + items[i].path = nullptr; + } + if (items[i].properties) + { + free(items[i].properties); + items[i].properties = nullptr; + } + } + free(items); + + /*---AUTO_GEN_PARSE---*/ +} + +ATTR_DLL_EXPORT bool kodi_vfs_file_exists(const char* filename, bool useCache) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_exists(const char* filename, bool useCache) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_exists_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_exists_v1; /* Autogenerated */ + + if (filename == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_exists_v1(filename, useCache)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_exists_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_exists_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_exists_v1(auto_gen_group.thisClassHdl, filename, useCache); +} + +ATTR_DLL_EXPORT bool kodi_vfs_stat_file(const char* filename, struct VFS_STAT_STRUCTURE* buffer) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_stat_file(const char* filename, struct VFS_STAT_STRUCTURE* buffer) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_stat_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_stat_file_v1; /* Autogenerated */ + + if (filename == nullptr || buffer == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_stat_file_v1(filename)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_stat_file_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_stat_file_v1 t = ident.get().as(); + + std::get<1>(t).SetCStructure(buffer); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_stat_file_v1(auto_gen_group.thisClassHdl, filename, buffer); +} + +ATTR_DLL_EXPORT bool kodi_vfs_delete_file(const char* filename) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_delete_file(const char* filename) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_delete_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_delete_file_v1; /* Autogenerated */ + + if (filename == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_delete_file_v1(filename)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_delete_file_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_delete_file_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_delete_file_v1(auto_gen_group.thisClassHdl, filename); +} + +ATTR_DLL_EXPORT bool kodi_vfs_rename_file(const char* filename, const char* newFileName) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_rename_file(const char* filename, const char* newFileName) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_rename_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_rename_file_v1; /* Autogenerated */ + + if (filename == nullptr || newFileName == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_rename_file_v1(filename, newFileName)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_rename_file_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_rename_file_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_rename_file_v1(auto_gen_group.thisClassHdl, filename, newFileName); +} + +ATTR_DLL_EXPORT bool kodi_vfs_copy_file(const char* filename, const char* dest) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_copy_file(const char* filename, const char* dest) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_copy_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_copy_file_v1; /* Autogenerated */ + + if (filename == nullptr || dest == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_copy_file_v1(filename, dest)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_copy_file_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_copy_file_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_copy_file_v1(auto_gen_group.thisClassHdl, filename, dest); +} + +ATTR_DLL_EXPORT char* kodi_vfs_get_file_md5(const char* filename) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_get_file_md5(const char* filename) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_file_md5_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_file_md5_v1; /* Autogenerated */ + + if (filename == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_get_file_md5_v1(filename)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_get_file_md5_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_get_file_md5_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_get_file_md5_v1(auto_gen_group.thisClassHdl, filename); +} + +ATTR_DLL_EXPORT char* kodi_vfs_get_cache_thumb_name(const char* filename) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_get_cache_thumb_name(const char* filename) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_cache_thumb_name_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_cache_thumb_name_v1; /* Autogenerated */ + + if (filename == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_get_cache_thumb_name_v1(filename)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_get_cache_thumb_name_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_get_cache_thumb_name_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_get_cache_thumb_name_v1(auto_gen_group.thisClassHdl, filename); +} + +ATTR_DLL_EXPORT char* kodi_vfs_make_legal_filename(const char* filename) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_make_legal_filename(const char* filename) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_make_legal_filename_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_make_legal_filename_v1; /* Autogenerated */ + + if (filename == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_make_legal_filename_v1(filename)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_make_legal_filename_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_make_legal_filename_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_make_legal_filename_v1(auto_gen_group.thisClassHdl, filename); +} + +ATTR_DLL_EXPORT char* kodi_vfs_make_legal_path(const char* path) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_make_legal_path(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_make_legal_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_make_legal_path_v1; /* Autogenerated */ + + if (path == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_make_legal_path_v1(path)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_make_legal_path_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_make_legal_path_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_make_legal_path_v1(auto_gen_group.thisClassHdl, path); +} + +ATTR_DLL_EXPORT char* kodi_vfs_translate_special_protocol(const char* strSource) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_translate_special_protocol(const char* strSource) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_translate_special_protocol_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_translate_special_protocol_v1; /* Autogenerated */ + + if (strSource == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_translate_special_protocol_v1(strSource)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_translate_special_protocol_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_translate_special_protocol_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_translate_special_protocol_v1(auto_gen_group.thisClassHdl, + strSource); +} + +ATTR_DLL_EXPORT bool kodi_vfs_is_internet_stream(const char* path, bool strictCheck) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_is_internet_stream(const char* path, bool strictCheck) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_is_internet_stream_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_is_internet_stream_v1; /* Autogenerated */ + + if (path == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_is_internet_stream_v1(path, strictCheck)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_is_internet_stream_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_is_internet_stream_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_is_internet_stream_v1(auto_gen_group.thisClassHdl, path, + strictCheck); +} + +ATTR_DLL_EXPORT bool kodi_vfs_is_on_lan(const char* path) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_is_on_lan(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_is_on_lan_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_is_on_lan_v1; /* Autogenerated */ + + if (path == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_is_on_lan_v1(path)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_is_on_lan_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_is_on_lan_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_is_on_lan_v1(auto_gen_group.thisClassHdl, path); +} + +ATTR_DLL_EXPORT bool kodi_vfs_is_remote(const char* path) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_is_remote(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_is_remote_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_is_remote_v1; /* Autogenerated */ + + if (path == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_is_remote_v1(path)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_is_remote_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_is_remote_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_is_remote_v1(auto_gen_group.thisClassHdl, path); +} + +ATTR_DLL_EXPORT bool kodi_vfs_is_local(const char* path) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_is_local(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_is_local_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_is_local_v1; /* Autogenerated */ + + if (path == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_is_local_v1(path)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_is_local_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_is_local_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_is_local_v1(auto_gen_group.thisClassHdl, path); +} + +ATTR_DLL_EXPORT bool kodi_vfs_is_url(const char* path) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_is_url(const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_is_url_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_is_url_v1; /* Autogenerated */ + + if (path == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_is_url_v1(path)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_is_url_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_is_url_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_is_url_v1(auto_gen_group.thisClassHdl, path); +} + +ATTR_DLL_EXPORT bool kodi_vfs_get_mime_type(const char* url, char** content, const char* useragent) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_get_mime_type(const char* url, char** content, const char* useragent) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_mime_type_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_mime_type_v1; /* Autogenerated */ + + if (url == nullptr || content == nullptr || useragent == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_get_mime_type_v1(url, useragent)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_get_mime_type_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_get_mime_type_v1 t = ident.get().as(); + + *content = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_get_mime_type_v1(auto_gen_group.thisClassHdl, url, content, + useragent); +} + +ATTR_DLL_EXPORT bool kodi_vfs_get_content_type(const char* url, + char** content, + const char* useragent) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_get_content_type(const char* url, char** content, const char* useragent) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_content_type_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_content_type_v1; /* Autogenerated */ + + if (url == nullptr || content == nullptr || useragent == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_get_content_type_v1(url, useragent)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_get_content_type_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_get_content_type_v1 t = ident.get().as(); + + *content = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_get_content_type_v1(auto_gen_group.thisClassHdl, url, content, + useragent); +} + +ATTR_DLL_EXPORT bool kodi_vfs_get_cookies(const char* url, char** cookies) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_get_cookies(const char* url, char** cookies) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_cookies_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_cookies_v1; /* Autogenerated */ + + if (url == nullptr || cookies == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_get_cookies_v1(url)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_get_cookies_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_get_cookies_v1 t = ident.get().as(); + + *cookies = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_get_cookies_v1(auto_gen_group.thisClassHdl, url, cookies); +} + +ATTR_DLL_EXPORT bool kodi_vfs_get_disk_space(const char* path, + uint64_t* capacity, + uint64_t* free, + uint64_t* available) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_get_disk_space(const char* path, uint64_t* capacity, uint64_t* free, uint64_t* available) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_get_disk_space_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_get_disk_space_v1; /* Autogenerated */ + + if (path == nullptr || capacity == nullptr || free == nullptr || available == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_get_disk_space_v1(path, *capacity, *free, *available)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_get_disk_space_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_get_disk_space_v1 t = ident.get().as(); + + *capacity = std::get<1>(t); + *free = std::get<2>(t); + *available = std::get<3>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_get_disk_space_v1(auto_gen_group.thisClassHdl, path, capacity, + free, available); +} + +ATTR_DLL_EXPORT KODI_HTTP_HEADER_HDL kodi_vfs_http_header_open(const char* url) +{ + // Original API call: ATTR_DLL_EXPORT KODI_HTTP_HEADER_HDL kodi_vfs_http_header_open(const char* url) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_open_v1; /* Autogenerated */ + + if (url == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_http_header_open_v1(url)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_http_header_open_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_http_header_open_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_http_header_open_v1(auto_gen_group.thisClassHdl, url); +} + +ATTR_DLL_EXPORT void kodi_vfs_http_header_close(KODI_HTTP_HEADER_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_vfs_http_header_close(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_close_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_close_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_vfs_http_header_close_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_http_header_close_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + auto_gen_group.kodi_vfs_http_header_close_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_value(KODI_HTTP_HEADER_HDL hdl, const char* param) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_value(KODI_HTTP_HEADER_HDL hdl, const char* param) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_get_value_v1; /* Autogenerated */ + + if (hdl == nullptr || param == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_http_header_get_value_v1(PtrValue(hdl), param)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_http_header_get_value_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_http_header_get_value_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_http_header_get_value_v1(auto_gen_group.thisClassHdl, hdl, param); +} + +ATTR_DLL_EXPORT char** kodi_vfs_http_header_get_values(KODI_HTTP_HEADER_HDL hdl, + const char* param, + size_t* length) +{ + // Original API call: ATTR_DLL_EXPORT char** kodi_vfs_http_header_get_values(KODI_HTTP_HEADER_HDL hdl, const char* param, size_t* length) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_values_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgParent_OUT_kodi_vfs_http_header_get_values_v1; /* Autogenerated */ + + if (hdl == nullptr || param == nullptr || length == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_vfs_http_header_get_values_v1(PtrValue(hdl), param, *length)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_http_header_get_values_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_http_header_get_values_v1 t = ident.get().as(); + + *length = std::get<1>(t); + const std::vector& values = std::get<0>(t); + char** ret = static_cast(malloc(sizeof(char*) * values.size())); + for (size_t i = 0; i < *length; ++i) + { + ret[i] = strdup(values[i].c_str()); + } + return ret; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_http_header_get_values_v1(auto_gen_group.thisClassHdl, hdl, param, + length); +} + +ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_header(KODI_HTTP_HEADER_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_header(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_header_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_get_header_v1; /* Autogenerated */ + + if (hdl == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_http_header_get_header_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_http_header_get_header_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_http_header_get_header_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_http_header_get_header_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_mime_type(KODI_HTTP_HEADER_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_mime_type(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_mime_type_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_get_mime_type_v1; /* Autogenerated */ + + if (hdl == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_http_header_get_mime_type_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_http_header_get_mime_type_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_http_header_get_mime_type_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_http_header_get_mime_type_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_charset(KODI_HTTP_HEADER_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_charset(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_charset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_get_charset_v1; /* Autogenerated */ + + if (hdl == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_http_header_get_charset_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_http_header_get_charset_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_http_header_get_charset_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_http_header_get_charset_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_proto_line(KODI_HTTP_HEADER_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_http_header_get_proto_line(KODI_HTTP_HEADER_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_http_header_get_proto_line_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_http_header_get_proto_line_v1; /* Autogenerated */ + + if (hdl == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_http_header_get_proto_line_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_http_header_get_proto_line_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_http_header_get_proto_line_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_http_header_get_proto_line_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_open(const char* filename, unsigned int flags) +{ + // Original API call: ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_open(const char* filename, unsigned int flags) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_open_v1; /* Autogenerated */ + + if (filename == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_open_v1(filename, flags)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_open_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_open_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_open_v1(auto_gen_group.thisClassHdl, filename, flags); +} + +ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_open_for_write(const char* filename, bool overwrite) +{ + // Original API call: ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_open_for_write(const char* filename, bool overwrite) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_open_for_write_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_open_for_write_v1; /* Autogenerated */ + + if (filename == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_open_for_write_v1(filename, overwrite)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_open_for_write_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_open_for_write_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_open_for_write_v1(auto_gen_group.thisClassHdl, filename, + overwrite); +} + +ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_curl_create(const char* url) +{ + // Original API call: ATTR_DLL_EXPORT KODI_FILE_HDL kodi_vfs_file_curl_create(const char* url) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_curl_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_curl_create_v1; /* Autogenerated */ + + if (url == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_curl_create_v1(url)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_curl_create_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_curl_create_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_curl_create_v1(auto_gen_group.thisClassHdl, url); +} + +ATTR_DLL_EXPORT bool kodi_vfs_file_curl_add_option(KODI_FILE_HDL hdl, + enum CURLOptiontype type, + const char* name, + const char* value) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_curl_add_option(KODI_FILE_HDL hdl, enum CURLOptiontype type, const char* name, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_curl_add_option_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_curl_add_option_v1; /* Autogenerated */ + + if (hdl == nullptr || name == nullptr || value == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_vfs_file_curl_add_option_v1(PtrValue(hdl), type, name, value)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_curl_add_option_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_curl_add_option_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_curl_add_option_v1(auto_gen_group.thisClassHdl, hdl, type, + name, value); +} + +ATTR_DLL_EXPORT bool kodi_vfs_file_curl_open(KODI_FILE_HDL hdl, unsigned int flags) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_curl_open(KODI_FILE_HDL hdl, unsigned int flags) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_curl_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_curl_open_v1; /* Autogenerated */ + + if (hdl == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_curl_open_v1(PtrValue(hdl), flags)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_curl_open_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_curl_open_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_curl_open_v1(auto_gen_group.thisClassHdl, hdl, flags); +} + +ATTR_DLL_EXPORT void kodi_vfs_file_close(KODI_FILE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_vfs_file_close(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_close_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_close_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_close_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage(funcGroup_filesystem_h, + funcParent_kodi_vfs_file_close_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + auto_gen_group.kodi_vfs_file_close_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT ssize_t kodi_vfs_file_read(KODI_FILE_HDL hdl, uint8_t* ptr, size_t size) +{ + // Original API call: ATTR_DLL_EXPORT ssize_t kodi_vfs_file_read(KODI_FILE_HDL hdl, uint8_t* ptr, size_t size) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_read_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple> msgParent_OUT_kodi_vfs_file_read_v1; /* Autogenerated */ + + if (hdl == nullptr || ptr == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_read_v1(PtrValue(hdl), size)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_read_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_read_v1 t = ident.get().as(); + + std::memcpy(ptr, std::get<1>(t).data(), sizeof(uint8_t) * size); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_read_v1(auto_gen_group.thisClassHdl, hdl, ptr, size); +} + +ATTR_DLL_EXPORT bool kodi_vfs_file_read_line(KODI_FILE_HDL hdl, char* szLine, size_t lineLength) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_read_line(KODI_FILE_HDL hdl, char* szLine, size_t lineLength) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_read_line_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_read_line_v1; /* Autogenerated */ + + if (hdl == nullptr || szLine == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_read_line_v1(PtrValue(hdl), lineLength)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_read_line_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_read_line_v1 t = ident.get().as(); + + strncpy(szLine, std::get<1>(t).c_str(), lineLength); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_read_line_v1(auto_gen_group.thisClassHdl, hdl, szLine, + lineLength); +} + +ATTR_DLL_EXPORT ssize_t kodi_vfs_file_write(KODI_FILE_HDL hdl, const uint8_t* ptr, size_t size) +{ + // Original API call: ATTR_DLL_EXPORT ssize_t kodi_vfs_file_write(KODI_FILE_HDL hdl, const uint8_t* ptr, size_t size) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple, size_t> msgParent__IN_kodi_vfs_file_write_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_write_v1; /* Autogenerated */ + + if (hdl == nullptr || ptr == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_write_v1( + PtrValue(hdl), std::vector(ptr, ptr + size), size)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_write_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_write_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_write_v1(auto_gen_group.thisClassHdl, hdl, ptr, size); +} + +ATTR_DLL_EXPORT void kodi_vfs_file_flush(KODI_FILE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_vfs_file_flush(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_flush_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_flush_v1; /* Autogenerated */ + + if (hdl == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_flush_v1(PtrValue(hdl))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage(funcGroup_filesystem_h, + funcParent_kodi_vfs_file_flush_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + auto_gen_group.kodi_vfs_file_flush_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT int64_t kodi_vfs_file_seek(KODI_FILE_HDL hdl, int64_t position, int whence) +{ + // Original API call: ATTR_DLL_EXPORT int64_t kodi_vfs_file_seek(KODI_FILE_HDL hdl, int64_t position, int whence) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_seek_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_seek_v1; /* Autogenerated */ + + if (hdl == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_seek_v1(PtrValue(hdl), position, whence)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_seek_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_seek_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_seek_v1(auto_gen_group.thisClassHdl, hdl, position, whence); +} + +ATTR_DLL_EXPORT int kodi_vfs_file_truncate(KODI_FILE_HDL hdl, int64_t size) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_vfs_file_truncate(KODI_FILE_HDL hdl, int64_t size) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_truncate_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_truncate_v1; /* Autogenerated */ + + if (hdl == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_truncate_v1(PtrValue(hdl), size)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_truncate_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_truncate_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_truncate_v1(auto_gen_group.thisClassHdl, hdl, size); +} + +ATTR_DLL_EXPORT int64_t kodi_vfs_file_get_position(KODI_FILE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT int64_t kodi_vfs_file_get_position(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_get_position_v1; /* Autogenerated */ + + if (hdl == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_get_position_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_get_position_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_get_position_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_get_position_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT int64_t kodi_vfs_file_get_length(KODI_FILE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT int64_t kodi_vfs_file_get_length(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_length_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_get_length_v1; /* Autogenerated */ + + if (hdl == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_get_length_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_get_length_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_get_length_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_get_length_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT bool kodi_vfs_file_at_end(KODI_FILE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_at_end(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_at_end_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_at_end_v1; /* Autogenerated */ + + if (hdl == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_at_end_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_at_end_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_at_end_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_at_end_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT double kodi_vfs_file_get_download_speed(KODI_FILE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT double kodi_vfs_file_get_download_speed(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_download_speed_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_get_download_speed_v1; /* Autogenerated */ + + if (hdl == nullptr) + return 0.0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_get_download_speed_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_get_download_speed_v1, in, out)) + return 0.0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_get_download_speed_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_get_download_speed_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT int kodi_vfs_file_get_chunk_size(KODI_FILE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_vfs_file_get_chunk_size(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_chunk_size_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_get_chunk_size_v1; /* Autogenerated */ + + if (hdl == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_get_chunk_size_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_get_chunk_size_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_get_chunk_size_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_get_chunk_size_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_get_seek_possible(KODI_FILE_HDL hdl) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_get_seek_possible(KODI_FILE_HDL hdl) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_io_ctl_get_seek_possible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_io_ctl_get_seek_possible_v1; /* Autogenerated */ + + if (hdl == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_io_ctl_get_seek_possible_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_io_ctl_get_seek_possible_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_io_ctl_get_seek_possible_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_io_ctl_get_seek_possible_v1(auto_gen_group.thisClassHdl, hdl); +} + +ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_get_cache_status(KODI_FILE_HDL hdl, + struct VFS_CACHE_STATUS* status) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_get_cache_status(KODI_FILE_HDL hdl, struct VFS_CACHE_STATUS* status) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_io_ctl_get_cache_status_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_io_ctl_get_cache_status_v1; /* Autogenerated */ + + if (hdl == nullptr || status == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_io_ctl_get_cache_status_v1(PtrValue(hdl))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_io_ctl_get_cache_status_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_io_ctl_get_cache_status_v1 t = ident.get().as(); + + std::get<1>(t).SetCStructure(status); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_io_ctl_get_cache_status_v1(auto_gen_group.thisClassHdl, hdl, + status); +} + +ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_set_cache_rate(KODI_FILE_HDL hdl, uint32_t rate) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_set_cache_rate(KODI_FILE_HDL hdl, uint32_t rate) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_io_ctl_set_cache_rate_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_io_ctl_set_cache_rate_v1; /* Autogenerated */ + + if (hdl == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_io_ctl_set_cache_rate_v1(PtrValue(hdl), rate)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_io_ctl_set_cache_rate_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_io_ctl_set_cache_rate_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_io_ctl_set_cache_rate_v1(auto_gen_group.thisClassHdl, hdl, + rate); +} + +ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_set_retry(KODI_FILE_HDL hdl, bool retry) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_vfs_file_io_ctl_set_retry(KODI_FILE_HDL hdl, bool retry) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_io_ctl_set_retry_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_io_ctl_set_retry_v1; /* Autogenerated */ + + if (hdl == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_io_ctl_set_retry_v1(PtrValue(hdl), retry)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_io_ctl_set_retry_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_io_ctl_set_retry_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_io_ctl_set_retry_v1(auto_gen_group.thisClassHdl, hdl, retry); +} + +ATTR_DLL_EXPORT char* kodi_vfs_file_get_property_value(KODI_FILE_HDL hdl, + enum FilePropertyTypes type, + const char* name) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_vfs_file_get_property_value(KODI_FILE_HDL hdl, enum FilePropertyTypes type, const char* name) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_property_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_vfs_file_get_property_value_v1; /* Autogenerated */ + + if (hdl == nullptr || name == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_vfs_file_get_property_value_v1(PtrValue(hdl), type, name)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_get_property_value_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_get_property_value_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_get_property_value_v1(auto_gen_group.thisClassHdl, hdl, type, + name); +} + +ATTR_DLL_EXPORT char** kodi_vfs_file_get_property_values(KODI_FILE_HDL hdl, + enum FilePropertyTypes type, + const char* name, + size_t* length) +{ + // Original API call: ATTR_DLL_EXPORT char** kodi_vfs_file_get_property_values(KODI_FILE_HDL hdl, enum FilePropertyTypes type, const char* name, size_t* length) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_vfs_file_get_property_values_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgParent_OUT_kodi_vfs_file_get_property_values_v1; /* Autogenerated */ + + if (hdl == nullptr || name == nullptr || length == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_vfs_file_get_property_values_v1(PtrValue(hdl), type, name, *length)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_filesystem_h, funcParent_kodi_vfs_file_get_property_values_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_vfs_file_get_property_values_v1 t = ident.get().as(); + + *length = std::get<1>(t); + const std::vector& values = std::get<0>(t); + char** ret = static_cast(malloc(sizeof(char*) * values.size())); + for (size_t i = 0; i < *length; ++i) + { + ret[i] = strdup(values[i].c_str()); + } + return ret; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.filesystem_h; + return auto_gen_group.kodi_vfs_file_get_property_values_v1(auto_gen_group.thisClassHdl, hdl, type, + name, length); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/filesystem.h b/xbmc/addons/kodi-dev-kit/src/addon/api/filesystem.h new file mode 100644 index 0000000000000..2a7f94e53cf2a --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/filesystem.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/filesystem.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_filesystem_h; +struct directFuncToKodi_filesystem_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_filesystem_h : public IMsgHdl +{ +public: + CHdl_kodi_filesystem_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_filesystem_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/general.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/general.cpp new file mode 100644 index 0000000000000..921a3f47ec186 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/general.cpp @@ -0,0 +1,478 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "general.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_general_h::InitDirect(directFuncToAddon_general_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT char* kodi_get_localized_string(long label_id) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_get_localized_string(long label_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_localized_string_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_localized_string_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_get_localized_string_v1(label_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_general_h, funcParent_kodi_get_localized_string_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_get_localized_string_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + return auto_gen_group.kodi_get_localized_string_v1(auto_gen_group.thisClassHdl, label_id); +} + +ATTR_DLL_EXPORT void kodi_get_free_mem(long* free, long* total, bool as_bytes) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_get_free_mem(long* free, long* total, bool as_bytes) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_free_mem_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_free_mem_v1; /* Autogenerated */ + + if (free == nullptr || total == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_get_free_mem_v1(*free, *total, as_bytes)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_general_h, funcParent_kodi_get_free_mem_v1, in, out)) + return; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_get_free_mem_v1 t = ident.get().as(); + + *free = std::get<0>(t); + *total = std::get<1>(t); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + auto_gen_group.kodi_get_free_mem_v1(auto_gen_group.thisClassHdl, free, total, as_bytes); +} + +ATTR_DLL_EXPORT char* kodi_unknown_to_utf8(const char* source, bool* ret, bool failOnBadChar) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_unknown_to_utf8(const char* source, bool* ret, bool failOnBadChar) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_unknown_to_utf8_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_unknown_to_utf8_v1; /* Autogenerated */ + + if (source == nullptr || ret == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_unknown_to_utf8_v1(source, *ret, failOnBadChar)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_general_h, funcParent_kodi_unknown_to_utf8_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_unknown_to_utf8_v1 t = ident.get().as(); + + *ret = std::get<1>(t); + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + return auto_gen_group.kodi_unknown_to_utf8_v1(auto_gen_group.thisClassHdl, source, ret, + failOnBadChar); +} + +ATTR_DLL_EXPORT char* kodi_get_language(enum LangFormats format, bool region) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_get_language(enum LangFormats format, bool region) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_language_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_language_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_get_language_v1(format, region)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_general_h, funcParent_kodi_get_language_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_get_language_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + return auto_gen_group.kodi_get_language_v1(auto_gen_group.thisClassHdl, format, region); +} + +ATTR_DLL_EXPORT void kodi_queue_notification(enum QueueMsg type, + const char* header, + const char* message, + const char* imageFile, + unsigned int displayTime, + bool withSound, + unsigned int messageTime) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_queue_notification(enum QueueMsg type, const char* header, const char* message, const char* imageFile, unsigned int displayTime, bool withSound, unsigned int messageTime) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_queue_notification_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_queue_notification_v1; /* Autogenerated */ + + if (header == nullptr || message == nullptr || imageFile == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_queue_notification_v1( + type, header, message, imageFile, displayTime, withSound, messageTime)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_general_h, funcParent_kodi_queue_notification_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + auto_gen_group.kodi_queue_notification_v1(auto_gen_group.thisClassHdl, type, header, message, + imageFile, displayTime, withSound, messageTime); +} + +ATTR_DLL_EXPORT char* kodi_get_digest(enum DigestType type, const char* text) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_get_digest(enum DigestType type, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_digest_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_digest_v1; /* Autogenerated */ + + if (text == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_get_digest_v1(type, text)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_general_h, funcParent_kodi_get_digest_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_get_digest_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + return auto_gen_group.kodi_get_digest_v1(auto_gen_group.thisClassHdl, type, text); +} + +ATTR_DLL_EXPORT char* kodi_get_region(const char* id) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_get_region(const char* id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_region_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_region_v1; /* Autogenerated */ + + if (id == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_get_region_v1(id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_general_h, funcParent_kodi_get_region_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_get_region_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + return auto_gen_group.kodi_get_region_v1(auto_gen_group.thisClassHdl, id); +} + +ATTR_DLL_EXPORT int kodi_get_global_idle_time() +{ + // Original API call: ATTR_DLL_EXPORT int kodi_get_global_idle_time() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_global_idle_time_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_global_idle_time_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_general_h, funcParent_kodi_get_global_idle_time_v1, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_get_global_idle_time_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + return auto_gen_group.kodi_get_global_idle_time_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT bool kodi_is_addon_avilable(const char* id, char** version, bool* enabled) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_is_addon_avilable(const char* id, char** version, bool* enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_is_addon_avilable_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_is_addon_avilable_v1; /* Autogenerated */ + + if (id == nullptr || version == nullptr || enabled == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_is_addon_avilable_v1(id, *enabled)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_general_h, funcParent_kodi_is_addon_avilable_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_is_addon_avilable_v1 t = ident.get().as(); + + *version = strdup(std::get<1>(t).c_str()); + *enabled = std::get<2>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + return auto_gen_group.kodi_is_addon_avilable_v1(auto_gen_group.thisClassHdl, id, version, + enabled); +} + +ATTR_DLL_EXPORT void kodi_version( + char** compile_name, int* major, int* minor, char** revision, char** tag, char** tagversion) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_version( char** compile_name, int* major, int* minor, char** revision, char** tag, char** tagversion) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_version_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_version_v1; /* Autogenerated */ + + if (compile_name == nullptr || major == nullptr || minor == nullptr || revision == nullptr || + tag == nullptr || tagversion == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_version_v1(*major, *minor)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage(funcGroup_general_h, + funcParent_kodi_version_v1, in, out)) + return; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_version_v1 t = ident.get().as(); + + *compile_name = strdup(std::get<0>(t).c_str()); + *major = std::get<1>(t); + *minor = std::get<2>(t); + *revision = strdup(std::get<3>(t).c_str()); + *tag = strdup(std::get<4>(t).c_str()); + *tagversion = strdup(std::get<5>(t).c_str()); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + auto_gen_group.kodi_version_v1(auto_gen_group.thisClassHdl, compile_name, major, minor, revision, + tag, tagversion); +} + +ATTR_DLL_EXPORT char* kodi_get_current_skin_id() +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_get_current_skin_id() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_current_skin_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_current_skin_id_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_general_h, funcParent_kodi_get_current_skin_id_v1, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_get_current_skin_id_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + return auto_gen_group.kodi_get_current_skin_id_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT bool kodi_get_keyboard_layout(int modifier_key, + char** layout_name, + struct AddonKeyboardKeyTable* layout) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_get_keyboard_layout(int modifier_key, char** layout_name, struct AddonKeyboardKeyTable* layout) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_get_keyboard_layout_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_get_keyboard_layout_v1; /* Autogenerated */ + + if (layout_name == nullptr || layout == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_get_keyboard_layout_v1(modifier_key)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_general_h, funcParent_kodi_get_keyboard_layout_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_get_keyboard_layout_v1 t = ident.get().as(); + + *layout_name = strdup(std::get<1>(t).c_str()); + std::get<2>(t).SetCStructure(layout); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + return auto_gen_group.kodi_get_keyboard_layout_v1(auto_gen_group.thisClassHdl, modifier_key, + layout_name, layout); +} + +ATTR_DLL_EXPORT bool kodi_change_keyboard_layout(char** layout_name) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_change_keyboard_layout(char** layout_name) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_change_keyboard_layout_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_change_keyboard_layout_v1; /* Autogenerated */ + + if (layout_name == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_general_h, funcParent_kodi_change_keyboard_layout_v1, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_change_keyboard_layout_v1 t = ident.get().as(); + + *layout_name = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + return auto_gen_group.kodi_change_keyboard_layout_v1(auto_gen_group.thisClassHdl, layout_name); +} + +ATTR_DLL_EXPORT void kodi_play_sfx(const char* filename, bool use_cached) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_play_sfx(const char* filename, bool use_cached) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_play_sfx_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_play_sfx_v1; /* Autogenerated */ + + if (filename == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_play_sfx_v1(filename, use_cached)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage(funcGroup_general_h, + funcParent_kodi_play_sfx_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + auto_gen_group.kodi_play_sfx_v1(auto_gen_group.thisClassHdl, filename, use_cached); +} + +ATTR_DLL_EXPORT void kodi_stop_sfx() +{ + // Original API call: ATTR_DLL_EXPORT void kodi_stop_sfx() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_stop_sfx_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_stop_sfx_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage(funcGroup_general_h, + funcParent_kodi_stop_sfx_v1); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.general_h; + auto_gen_group.kodi_stop_sfx_v1(auto_gen_group.thisClassHdl); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/general.h b/xbmc/addons/kodi-dev-kit/src/addon/api/general.h new file mode 100644 index 0000000000000..331139752b669 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/general.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/general.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_general_h; +struct directFuncToKodi_general_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_general_h : public IMsgHdl +{ +public: + CHdl_kodi_general_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_general_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/CMakeLists.txt new file mode 100644 index 0000000000000..d8b03d03c33a5 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/CMakeLists.txt @@ -0,0 +1,18 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + general.cpp + list_item.cpp + window.cpp +) + +set(HEADERS + general.h + list_item.h + window.h +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_api_gui) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/CMakeLists.txt new file mode 100644 index 0000000000000..1a88a865432b6 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/CMakeLists.txt @@ -0,0 +1,36 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + button.cpp + edit.cpp + fade_label.cpp + image.cpp + label.cpp + progress.cpp + radio_button.cpp + rendering.cpp + settings_slider.cpp + slider.cpp + spin.cpp + text_box.cpp +) + +set(HEADERS + button.h + edit.h + fade_label.h + image.h + label.h + progress.h + radio_button.h + rendering.h + settings_slider.h + slider.h + spin.h + text_box.h +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_api_gui_controls) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/button.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/button.cpp new file mode 100644 index 0000000000000..7ba0707fa175b --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/button.cpp @@ -0,0 +1,217 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "button.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_button_h::InitDirect( + directFuncToAddon_gui_controls_button_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_button_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_button_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_button_set_visible_v1(PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_button_h, funcParent_kodi_gui_controls_button_set_visible_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_button_h; + auto_gen_group.kodi_gui_controls_button_set_visible_v1(auto_gen_group.thisClassHdl, handle, + visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_button_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_button_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_set_enabled_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_button_set_enabled_v1(PtrValue(handle), enabled)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_button_h, funcParent_kodi_gui_controls_button_set_enabled_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_button_h; + auto_gen_group.kodi_gui_controls_button_set_enabled_v1(auto_gen_group.thisClassHdl, handle, + enabled); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_button_set_label(KODI_GUI_CONTROL_HANDLE handle, + const char* label) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_button_set_label(KODI_GUI_CONTROL_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_set_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_set_label_v1; /* Autogenerated */ + + if (handle == nullptr || label == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_button_set_label_v1(PtrValue(handle), label)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_button_h, funcParent_kodi_gui_controls_button_set_label_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_button_h; + auto_gen_group.kodi_gui_controls_button_set_label_v1(auto_gen_group.thisClassHdl, handle, label); +} + +ATTR_DLL_EXPORT char* kodi_gui_controls_button_get_label(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_button_get_label(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_get_label_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_button_get_label_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_button_h, funcParent_kodi_gui_controls_button_get_label_v1, in, + out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_button_get_label_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_button_h; + return auto_gen_group.kodi_gui_controls_button_get_label_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_button_set_label2(KODI_GUI_CONTROL_HANDLE handle, + const char* label) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_button_set_label2(KODI_GUI_CONTROL_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_set_label2_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_set_label2_v1; /* Autogenerated */ + + if (handle == nullptr || label == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_button_set_label2_v1(PtrValue(handle), label)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_button_h, funcParent_kodi_gui_controls_button_set_label2_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_button_h; + auto_gen_group.kodi_gui_controls_button_set_label2_v1(auto_gen_group.thisClassHdl, handle, label); +} + +ATTR_DLL_EXPORT char* kodi_gui_controls_button_get_label2(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_button_get_label2(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_button_get_label2_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_button_get_label2_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_button_get_label2_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_button_h, funcParent_kodi_gui_controls_button_get_label2_v1, in, + out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_button_get_label2_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_button_h; + return auto_gen_group.kodi_gui_controls_button_get_label2_v1(auto_gen_group.thisClassHdl, handle); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/button.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/button.h new file mode 100644 index 0000000000000..091d3d11bd71d --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/button.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/button.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_button_h; +struct directFuncToKodi_gui_controls_button_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_button_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_button_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_button_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/edit.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/edit.cpp new file mode 100644 index 0000000000000..9e4e3e5785da6 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/edit.cpp @@ -0,0 +1,302 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "edit.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_edit_h::InitDirect(directFuncToAddon_gui_controls_edit_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_edit_set_visible_v1(PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_edit_h, funcParent_kodi_gui_controls_edit_set_visible_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_edit_h; + auto_gen_group.kodi_gui_controls_edit_set_visible_v1(auto_gen_group.thisClassHdl, handle, + visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_enabled_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_edit_set_enabled_v1(PtrValue(handle), enabled)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_edit_h, funcParent_kodi_gui_controls_edit_set_enabled_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_edit_h; + auto_gen_group.kodi_gui_controls_edit_set_enabled_v1(auto_gen_group.thisClassHdl, handle, + enabled); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_label(KODI_GUI_CONTROL_HANDLE handle, + const char* label) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_label(KODI_GUI_CONTROL_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_label_v1; /* Autogenerated */ + + if (handle == nullptr || label == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_edit_set_label_v1(PtrValue(handle), label)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_edit_h, funcParent_kodi_gui_controls_edit_set_label_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_edit_h; + auto_gen_group.kodi_gui_controls_edit_set_label_v1(auto_gen_group.thisClassHdl, handle, label); +} + +ATTR_DLL_EXPORT char* kodi_gui_controls_edit_get_label(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_edit_get_label(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_get_label_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_edit_get_label_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_edit_h, funcParent_kodi_gui_controls_edit_get_label_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_edit_get_label_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_edit_h; + return auto_gen_group.kodi_gui_controls_edit_get_label_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_text(KODI_GUI_CONTROL_HANDLE handle, + const char* text) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_text(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_text_v1; /* Autogenerated */ + + if (handle == nullptr || text == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_edit_set_text_v1(PtrValue(handle), text)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_edit_h, funcParent_kodi_gui_controls_edit_set_text_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_edit_h; + auto_gen_group.kodi_gui_controls_edit_set_text_v1(auto_gen_group.thisClassHdl, handle, text); +} + +ATTR_DLL_EXPORT char* kodi_gui_controls_edit_get_text(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_edit_get_text(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_get_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_get_text_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_edit_get_text_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_edit_h, funcParent_kodi_gui_controls_edit_get_text_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_edit_get_text_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_edit_h; + return auto_gen_group.kodi_gui_controls_edit_get_text_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_cursor_position(KODI_GUI_CONTROL_HANDLE handle, + unsigned int position) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_cursor_position(KODI_GUI_CONTROL_HANDLE handle, unsigned int position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_cursor_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_cursor_position_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_edit_set_cursor_position_v1(PtrValue(handle), + position)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_edit_h, funcParent_kodi_gui_controls_edit_set_cursor_position_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_edit_h; + auto_gen_group.kodi_gui_controls_edit_set_cursor_position_v1(auto_gen_group.thisClassHdl, handle, + position); +} + +ATTR_DLL_EXPORT unsigned int kodi_gui_controls_edit_get_cursor_position( + KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT unsigned int kodi_gui_controls_edit_get_cursor_position( KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_get_cursor_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_get_cursor_position_v1; /* Autogenerated */ + + if (handle == nullptr) + return 0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_edit_get_cursor_position_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_edit_h, funcParent_kodi_gui_controls_edit_get_cursor_position_v1, + in, out)) + return 0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_edit_get_cursor_position_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_edit_h; + return auto_gen_group.kodi_gui_controls_edit_get_cursor_position_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_input_type(KODI_GUI_CONTROL_HANDLE handle, + int type, + const char* heading) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_edit_set_input_type(KODI_GUI_CONTROL_HANDLE handle, int type, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_edit_set_input_type_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_edit_set_input_type_v1; /* Autogenerated */ + + if (handle == nullptr || heading == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_edit_set_input_type_v1(PtrValue(handle), type, + heading)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_edit_h, funcParent_kodi_gui_controls_edit_set_input_type_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_edit_h; + auto_gen_group.kodi_gui_controls_edit_set_input_type_v1(auto_gen_group.thisClassHdl, handle, type, + heading); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/edit.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/edit.h new file mode 100644 index 0000000000000..b1825ea47d7b7 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/edit.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/edit.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_edit_h; +struct directFuncToKodi_gui_controls_edit_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_edit_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_edit_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_edit_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/fade_label.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/fade_label.cpp new file mode 100644 index 0000000000000..86c1b1620d9ec --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/fade_label.cpp @@ -0,0 +1,191 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "fade_label.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_fade_label_h::InitDirect( + directFuncToAddon_gui_controls_fade_label_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_fade_label_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_fade_label_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_fade_label_set_visible_v1(PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_fade_label_h, funcParent_kodi_gui_controls_fade_label_set_visible_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_fade_label_h; + auto_gen_group.kodi_gui_controls_fade_label_set_visible_v1(auto_gen_group.thisClassHdl, handle, + visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_add_label(KODI_GUI_CONTROL_HANDLE handle, + const char* text) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_add_label(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_fade_label_add_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_fade_label_add_label_v1; /* Autogenerated */ + + if (handle == nullptr || text == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_fade_label_add_label_v1(PtrValue(handle), text)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_fade_label_h, funcParent_kodi_gui_controls_fade_label_add_label_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_fade_label_h; + auto_gen_group.kodi_gui_controls_fade_label_add_label_v1(auto_gen_group.thisClassHdl, handle, + text); +} + +ATTR_DLL_EXPORT char* kodi_gui_controls_fade_label_get_label(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_fade_label_get_label(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_fade_label_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_fade_label_get_label_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_fade_label_get_label_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_fade_label_h, + funcParent_kodi_gui_controls_fade_label_get_label_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_fade_label_get_label_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_fade_label_h; + return auto_gen_group.kodi_gui_controls_fade_label_get_label_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_set_scrolling(KODI_GUI_CONTROL_HANDLE handle, + bool scroll) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_set_scrolling(KODI_GUI_CONTROL_HANDLE handle, bool scroll) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_fade_label_set_scrolling_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_fade_label_set_scrolling_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_fade_label_set_scrolling_v1(PtrValue(handle), scroll)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_fade_label_h, + funcParent_kodi_gui_controls_fade_label_set_scrolling_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_fade_label_h; + auto_gen_group.kodi_gui_controls_fade_label_set_scrolling_v1(auto_gen_group.thisClassHdl, handle, + scroll); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_reset(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_fade_label_reset(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_fade_label_reset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_fade_label_reset_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_fade_label_reset_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_fade_label_h, funcParent_kodi_gui_controls_fade_label_reset_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_fade_label_h; + auto_gen_group.kodi_gui_controls_fade_label_reset_v1(auto_gen_group.thisClassHdl, handle); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/fade_label.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/fade_label.h new file mode 100644 index 0000000000000..252dc537629dd --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/fade_label.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/fade_label.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_fade_label_h; +struct directFuncToKodi_gui_controls_fade_label_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_fade_label_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_fade_label_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_fade_label_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/image.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/image.cpp new file mode 100644 index 0000000000000..33123917925bc --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/image.cpp @@ -0,0 +1,134 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "image.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_image_h::InitDirect(directFuncToAddon_gui_controls_image_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_image_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_image_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_image_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_image_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_image_set_visible_v1(PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_image_h, funcParent_kodi_gui_controls_image_set_visible_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_image_h; + auto_gen_group.kodi_gui_controls_image_set_visible_v1(auto_gen_group.thisClassHdl, handle, + visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_image_set_filename(KODI_GUI_CONTROL_HANDLE handle, + const char* filename, + bool use_cache) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_image_set_filename(KODI_GUI_CONTROL_HANDLE handle, const char* filename, bool use_cache) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_image_set_filename_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_image_set_filename_v1; /* Autogenerated */ + + if (handle == nullptr || filename == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_image_set_filename_v1(PtrValue(handle), + filename, use_cache)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_image_h, funcParent_kodi_gui_controls_image_set_filename_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_image_h; + auto_gen_group.kodi_gui_controls_image_set_filename_v1(auto_gen_group.thisClassHdl, handle, + filename, use_cache); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_image_set_color_diffuse(KODI_GUI_CONTROL_HANDLE handle, + uint32_t color_diffuse) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_image_set_color_diffuse(KODI_GUI_CONTROL_HANDLE handle, uint32_t color_diffuse) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_image_set_color_diffuse_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_image_set_color_diffuse_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_image_set_color_diffuse_v1(PtrValue(handle), + color_diffuse)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_image_h, funcParent_kodi_gui_controls_image_set_color_diffuse_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_image_h; + auto_gen_group.kodi_gui_controls_image_set_color_diffuse_v1(auto_gen_group.thisClassHdl, handle, + color_diffuse); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/image.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/image.h new file mode 100644 index 0000000000000..929bd0a38d26d --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/image.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/image.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_image_h; +struct directFuncToKodi_gui_controls_image_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_image_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_image_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_image_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/label.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/label.cpp new file mode 100644 index 0000000000000..c63ae4bb6407d --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/label.cpp @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "label.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_label_h::InitDirect(directFuncToAddon_gui_controls_label_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_label_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_label_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_label_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_label_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_label_set_visible_v1(PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_label_h, funcParent_kodi_gui_controls_label_set_visible_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_label_h; + auto_gen_group.kodi_gui_controls_label_set_visible_v1(auto_gen_group.thisClassHdl, handle, + visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_label_set_label(KODI_GUI_CONTROL_HANDLE handle, + const char* text) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_label_set_label(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_label_set_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_label_set_label_v1; /* Autogenerated */ + + if (handle == nullptr || text == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_label_set_label_v1(PtrValue(handle), text)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_label_h, funcParent_kodi_gui_controls_label_set_label_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_label_h; + auto_gen_group.kodi_gui_controls_label_set_label_v1(auto_gen_group.thisClassHdl, handle, text); +} + +ATTR_DLL_EXPORT char* kodi_gui_controls_label_get_label(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_label_get_label(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_label_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_label_get_label_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_label_get_label_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_label_h, funcParent_kodi_gui_controls_label_get_label_v1, in, + out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_label_get_label_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_label_h; + return auto_gen_group.kodi_gui_controls_label_get_label_v1(auto_gen_group.thisClassHdl, handle); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/label.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/label.h new file mode 100644 index 0000000000000..3fddde73e8d5b --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/label.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/label.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_label_h; +struct directFuncToKodi_gui_controls_label_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_label_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_label_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_label_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/progress.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/progress.cpp new file mode 100644 index 0000000000000..51440b46b7866 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/progress.cpp @@ -0,0 +1,139 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "progress.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_progress_h::InitDirect( + directFuncToAddon_gui_controls_progress_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_progress_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_progress_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_progress_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_progress_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_progress_set_visible_v1(PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_progress_h, funcParent_kodi_gui_controls_progress_set_visible_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_progress_h; + auto_gen_group.kodi_gui_controls_progress_set_visible_v1(auto_gen_group.thisClassHdl, handle, + visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_progress_set_percentage(KODI_GUI_CONTROL_HANDLE handle, + float percent) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_progress_set_percentage(KODI_GUI_CONTROL_HANDLE handle, float percent) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_progress_set_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_progress_set_percentage_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_progress_set_percentage_v1(PtrValue(handle), percent)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_progress_h, funcParent_kodi_gui_controls_progress_set_percentage_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_progress_h; + auto_gen_group.kodi_gui_controls_progress_set_percentage_v1(auto_gen_group.thisClassHdl, handle, + percent); +} + +ATTR_DLL_EXPORT float kodi_gui_controls_progress_get_percentage(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_progress_get_percentage(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_progress_get_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_progress_get_percentage_v1; /* Autogenerated */ + + if (handle == nullptr) + return 0.0f; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_progress_get_percentage_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_progress_h, + funcParent_kodi_gui_controls_progress_get_percentage_v1, in, out)) + return 0.0f; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_progress_get_percentage_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_progress_h; + return auto_gen_group.kodi_gui_controls_progress_get_percentage_v1(auto_gen_group.thisClassHdl, + handle); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/progress.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/progress.h new file mode 100644 index 0000000000000..3069a191db429 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/progress.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/progress.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_progress_h; +struct directFuncToKodi_gui_controls_progress_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_progress_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_progress_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_progress_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/radio_button.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/radio_button.cpp new file mode 100644 index 0000000000000..cbd5615586883 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/radio_button.cpp @@ -0,0 +1,227 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "radio_button.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_radio_button_h::InitDirect( + directFuncToAddon_gui_controls_radio_button_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_radio_button_set_visible_v1(PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_radio_button_h, + funcParent_kodi_gui_controls_radio_button_set_visible_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_radio_button_h; + auto_gen_group.kodi_gui_controls_radio_button_set_visible_v1(auto_gen_group.thisClassHdl, handle, + visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_set_enabled_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_radio_button_set_enabled_v1(PtrValue(handle), enabled)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_radio_button_h, + funcParent_kodi_gui_controls_radio_button_set_enabled_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_radio_button_h; + auto_gen_group.kodi_gui_controls_radio_button_set_enabled_v1(auto_gen_group.thisClassHdl, handle, + enabled); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_label(KODI_GUI_CONTROL_HANDLE handle, + const char* text) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_label(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_set_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_set_label_v1; /* Autogenerated */ + + if (handle == nullptr || text == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_radio_button_set_label_v1(PtrValue(handle), text)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_radio_button_h, + funcParent_kodi_gui_controls_radio_button_set_label_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_radio_button_h; + auto_gen_group.kodi_gui_controls_radio_button_set_label_v1(auto_gen_group.thisClassHdl, handle, + text); +} + +ATTR_DLL_EXPORT char* kodi_gui_controls_radio_button_get_label(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_radio_button_get_label(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_get_label_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_radio_button_get_label_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_radio_button_h, + funcParent_kodi_gui_controls_radio_button_get_label_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_radio_button_get_label_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_radio_button_h; + return auto_gen_group.kodi_gui_controls_radio_button_get_label_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_selected(KODI_GUI_CONTROL_HANDLE handle, + bool selected) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_radio_button_set_selected(KODI_GUI_CONTROL_HANDLE handle, bool selected) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_set_selected_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_set_selected_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_radio_button_set_selected_v1(PtrValue(handle), + selected)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_radio_button_h, + funcParent_kodi_gui_controls_radio_button_set_selected_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_radio_button_h; + auto_gen_group.kodi_gui_controls_radio_button_set_selected_v1(auto_gen_group.thisClassHdl, handle, + selected); +} + +ATTR_DLL_EXPORT bool kodi_gui_controls_radio_button_is_selected(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_controls_radio_button_is_selected(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_button_is_selected_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_button_is_selected_v1; /* Autogenerated */ + + if (handle == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_radio_button_is_selected_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_radio_button_h, + funcParent_kodi_gui_controls_radio_button_is_selected_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_radio_button_is_selected_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_radio_button_h; + return auto_gen_group.kodi_gui_controls_radio_button_is_selected_v1(auto_gen_group.thisClassHdl, + handle); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/radio_button.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/radio_button.h new file mode 100644 index 0000000000000..f7ad06474de37 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/radio_button.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/radio_button.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_radio_button_h; +struct directFuncToKodi_gui_controls_radio_button_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_radio_button_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_radio_button_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_radio_button_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/rendering.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/rendering.cpp new file mode 100644 index 0000000000000..75e285b1fe435 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/rendering.cpp @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "rendering.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_rendering_h::InitDirect( + directFuncToAddon_gui_controls_rendering_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_radio_rendering_destroy(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_radio_rendering_destroy(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_radio_rendering_destroy_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_radio_rendering_destroy_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_radio_rendering_destroy_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_rendering_h, funcParent_kodi_gui_controls_radio_rendering_destroy_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_rendering_h; + auto_gen_group.kodi_gui_controls_radio_rendering_destroy_v1(auto_gen_group.thisClassHdl, handle); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/rendering.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/rendering.h new file mode 100644 index 0000000000000..658be59115667 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/rendering.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/rendering.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_rendering_h; +struct directFuncToKodi_gui_controls_rendering_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_rendering_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_rendering_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_rendering_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/settings_slider.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/settings_slider.cpp new file mode 100644 index 0000000000000..65c3574146379 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/settings_slider.cpp @@ -0,0 +1,459 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "settings_slider.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_settings_slider_h::InitDirect( + directFuncToAddon_gui_controls_settings_slider_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_settings_slider_set_visible_v1( + PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_set_visible_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_set_visible_v1(auto_gen_group.thisClassHdl, + handle, visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_enabled_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_settings_slider_set_enabled_v1( + PtrValue(handle), enabled)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_set_enabled_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_set_enabled_v1(auto_gen_group.thisClassHdl, + handle, enabled); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_text(KODI_GUI_CONTROL_HANDLE handle, + const char* label) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_text(KODI_GUI_CONTROL_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_text_v1; /* Autogenerated */ + + if (handle == nullptr || label == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_settings_slider_set_text_v1(PtrValue(handle), label)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_set_text_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_set_text_v1(auto_gen_group.thisClassHdl, handle, + label); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_reset(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_reset(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_reset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_reset_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_settings_slider_reset_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_reset_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_reset_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_range(KODI_GUI_CONTROL_HANDLE handle, + int start, + int end) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_range( KODI_GUI_CONTROL_HANDLE handle, int start, int end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_int_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_int_range_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_settings_slider_set_int_range_v1( + PtrValue(handle), start, end)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_set_int_range_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_set_int_range_v1(auto_gen_group.thisClassHdl, + handle, start, end); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_value(KODI_GUI_CONTROL_HANDLE handle, + int value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_value( KODI_GUI_CONTROL_HANDLE handle, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_int_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_settings_slider_set_int_value_v1( + PtrValue(handle), value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_set_int_value_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_set_int_value_v1(auto_gen_group.thisClassHdl, + handle, value); +} + +ATTR_DLL_EXPORT int kodi_gui_controls_settings_slider_get_int_value(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_controls_settings_slider_get_int_value( KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_get_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_get_int_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_settings_slider_get_int_value_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_get_int_value_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_settings_slider_get_int_value_v1 t = + ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + return auto_gen_group.kodi_gui_controls_settings_slider_get_int_value_v1( + auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_interval( + KODI_GUI_CONTROL_HANDLE handle, int interval) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_int_interval( KODI_GUI_CONTROL_HANDLE handle, int interval) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_int_interval_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_int_interval_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_settings_slider_set_int_interval_v1( + PtrValue(handle), interval)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_set_int_interval_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_set_int_interval_v1(auto_gen_group.thisClassHdl, + handle, interval); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_percentage( + KODI_GUI_CONTROL_HANDLE handle, float percent) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_percentage( KODI_GUI_CONTROL_HANDLE handle, float percent) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_percentage_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_settings_slider_set_percentage_v1( + PtrValue(handle), percent)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_set_percentage_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_set_percentage_v1(auto_gen_group.thisClassHdl, + handle, percent); +} + +ATTR_DLL_EXPORT float kodi_gui_controls_settings_slider_get_percentage( + KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_settings_slider_get_percentage( KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_get_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_get_percentage_v1; /* Autogenerated */ + + if (handle == nullptr) + return 0.0f; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_settings_slider_get_percentage_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_get_percentage_v1, in, out)) + return 0.0f; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_settings_slider_get_percentage_v1 t = + ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + return auto_gen_group.kodi_gui_controls_settings_slider_get_percentage_v1( + auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_range( + KODI_GUI_CONTROL_HANDLE handle, float start, float end) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_range( KODI_GUI_CONTROL_HANDLE handle, float start, float end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_float_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_float_range_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_settings_slider_set_float_range_v1( + PtrValue(handle), start, end)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_set_float_range_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_set_float_range_v1(auto_gen_group.thisClassHdl, + handle, start, end); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_value( + KODI_GUI_CONTROL_HANDLE handle, float value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_value( KODI_GUI_CONTROL_HANDLE handle, float value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_float_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_settings_slider_set_float_value_v1( + PtrValue(handle), value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_set_float_value_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_set_float_value_v1(auto_gen_group.thisClassHdl, + handle, value); +} + +ATTR_DLL_EXPORT float kodi_gui_controls_settings_slider_get_float_value( + KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_settings_slider_get_float_value( KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_get_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_get_float_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return 0.0f; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_settings_slider_get_float_value_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_get_float_value_v1, in, out)) + return 0.0f; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_settings_slider_get_float_value_v1 t = + ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + return auto_gen_group.kodi_gui_controls_settings_slider_get_float_value_v1( + auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_interval( + KODI_GUI_CONTROL_HANDLE handle, float interval) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_settings_slider_set_float_interval( KODI_GUI_CONTROL_HANDLE handle, float interval) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_settings_slider_set_float_interval_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_settings_slider_set_float_interval_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_settings_slider_set_float_interval_v1( + PtrValue(handle), interval)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_settings_slider_h, + funcParent_kodi_gui_controls_settings_slider_set_float_interval_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_settings_slider_h; + auto_gen_group.kodi_gui_controls_settings_slider_set_float_interval_v1( + auto_gen_group.thisClassHdl, handle, interval); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/settings_slider.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/settings_slider.h new file mode 100644 index 0000000000000..ca05a66431eb1 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/settings_slider.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/settings_slider.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_settings_slider_h; +struct directFuncToKodi_gui_controls_settings_slider_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_settings_slider_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_settings_slider_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_settings_slider_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/slider.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/slider.cpp new file mode 100644 index 0000000000000..74a527097719a --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/slider.cpp @@ -0,0 +1,449 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "slider.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_slider_h::InitDirect( + directFuncToAddon_gui_controls_slider_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_slider_set_visible_v1(PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_set_visible_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + auto_gen_group.kodi_gui_controls_slider_set_visible_v1(auto_gen_group.thisClassHdl, handle, + visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_enabled_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_slider_set_enabled_v1(PtrValue(handle), enabled)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_set_enabled_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + auto_gen_group.kodi_gui_controls_slider_set_enabled_v1(auto_gen_group.thisClassHdl, handle, + enabled); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_slider_reset(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_reset(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_reset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_reset_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_slider_reset_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_reset_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + auto_gen_group.kodi_gui_controls_slider_reset_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT char* kodi_gui_controls_slider_get_description(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_slider_get_description(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_get_description_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_get_description_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_slider_get_description_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_get_description_v1, + in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_slider_get_description_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + return auto_gen_group.kodi_gui_controls_slider_get_description_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_range(KODI_GUI_CONTROL_HANDLE handle, + int start, + int end) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_range(KODI_GUI_CONTROL_HANDLE handle, int start, int end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_int_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_int_range_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_slider_set_int_range_v1(PtrValue(handle), start, end)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_set_int_range_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + auto_gen_group.kodi_gui_controls_slider_set_int_range_v1(auto_gen_group.thisClassHdl, handle, + start, end); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_value(KODI_GUI_CONTROL_HANDLE handle, + int value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_value(KODI_GUI_CONTROL_HANDLE handle, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_int_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_slider_set_int_value_v1(PtrValue(handle), value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_set_int_value_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + auto_gen_group.kodi_gui_controls_slider_set_int_value_v1(auto_gen_group.thisClassHdl, handle, + value); +} + +ATTR_DLL_EXPORT int kodi_gui_controls_slider_get_int_value(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_controls_slider_get_int_value(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_get_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_get_int_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_slider_get_int_value_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_get_int_value_v1, + in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_slider_get_int_value_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + return auto_gen_group.kodi_gui_controls_slider_get_int_value_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_interval(KODI_GUI_CONTROL_HANDLE handle, + int interval) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_int_interval(KODI_GUI_CONTROL_HANDLE handle, int interval) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_int_interval_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_int_interval_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_slider_set_int_interval_v1(PtrValue(handle), interval)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_set_int_interval_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + auto_gen_group.kodi_gui_controls_slider_set_int_interval_v1(auto_gen_group.thisClassHdl, handle, + interval); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_percentage(KODI_GUI_CONTROL_HANDLE handle, + float percent) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_percentage(KODI_GUI_CONTROL_HANDLE handle, float percent) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_percentage_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_slider_set_percentage_v1(PtrValue(handle), percent)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_set_percentage_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + auto_gen_group.kodi_gui_controls_slider_set_percentage_v1(auto_gen_group.thisClassHdl, handle, + percent); +} + +ATTR_DLL_EXPORT float kodi_gui_controls_slider_get_percentage(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_slider_get_percentage(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_get_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_get_percentage_v1; /* Autogenerated */ + + if (handle == nullptr) + return 0.0f; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_slider_get_percentage_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_get_percentage_v1, + in, out)) + return 0.0f; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_slider_get_percentage_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + return auto_gen_group.kodi_gui_controls_slider_get_percentage_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_range(KODI_GUI_CONTROL_HANDLE handle, + float start, + float end) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_range(KODI_GUI_CONTROL_HANDLE handle, float start, float end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_float_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_float_range_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_slider_set_float_range_v1(PtrValue(handle), + start, end)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_set_float_range_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + auto_gen_group.kodi_gui_controls_slider_set_float_range_v1(auto_gen_group.thisClassHdl, handle, + start, end); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_value(KODI_GUI_CONTROL_HANDLE handle, + float value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_value(KODI_GUI_CONTROL_HANDLE handle, float value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_float_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_slider_set_float_value_v1(PtrValue(handle), value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_set_float_value_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + auto_gen_group.kodi_gui_controls_slider_set_float_value_v1(auto_gen_group.thisClassHdl, handle, + value); +} + +ATTR_DLL_EXPORT float kodi_gui_controls_slider_get_float_value(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_slider_get_float_value(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_get_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_get_float_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return 0.0f; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_slider_get_float_value_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_get_float_value_v1, + in, out)) + return 0.0f; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_slider_get_float_value_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + return auto_gen_group.kodi_gui_controls_slider_get_float_value_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_interval(KODI_GUI_CONTROL_HANDLE handle, + float interval) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_slider_set_float_interval(KODI_GUI_CONTROL_HANDLE handle, float interval) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_slider_set_float_interval_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_slider_set_float_interval_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_slider_set_float_interval_v1(PtrValue(handle), + interval)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_slider_h, funcParent_kodi_gui_controls_slider_set_float_interval_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_slider_h; + auto_gen_group.kodi_gui_controls_slider_set_float_interval_v1(auto_gen_group.thisClassHdl, handle, + interval); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/slider.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/slider.h new file mode 100644 index 0000000000000..c2a1d4355ed8a --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/slider.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/slider.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_slider_h; +struct directFuncToKodi_gui_controls_slider_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_slider_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_slider_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_slider_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/spin.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/spin.cpp new file mode 100644 index 0000000000000..29e8398f48a0b --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/spin.cpp @@ -0,0 +1,490 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "spin.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_spin_h::InitDirect(directFuncToAddon_gui_controls_spin_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_spin_set_visible_v1(PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_set_visible_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_set_visible_v1(auto_gen_group.thisClassHdl, handle, + visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_enabled(KODI_GUI_CONTROL_HANDLE handle, + bool enabled) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_enabled(KODI_GUI_CONTROL_HANDLE handle, bool enabled) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_enabled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_enabled_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_spin_set_enabled_v1(PtrValue(handle), enabled)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_set_enabled_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_set_enabled_v1(auto_gen_group.thisClassHdl, handle, + enabled); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_text(KODI_GUI_CONTROL_HANDLE handle, + const char* text) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_text(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_text_v1; /* Autogenerated */ + + if (handle == nullptr || text == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_spin_set_text_v1(PtrValue(handle), text)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_set_text_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_set_text_v1(auto_gen_group.thisClassHdl, handle, text); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_reset(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_reset(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_reset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_reset_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_spin_reset_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_reset_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_reset_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_type(KODI_GUI_CONTROL_HANDLE handle, int type) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_type(KODI_GUI_CONTROL_HANDLE handle, int type) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_type_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_type_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_spin_set_type_v1(PtrValue(handle), type)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_set_type_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_set_type_v1(auto_gen_group.thisClassHdl, handle, type); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_add_string_label(KODI_GUI_CONTROL_HANDLE handle, + const char* label, + const char* value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_add_string_label(KODI_GUI_CONTROL_HANDLE handle, const char* label, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_add_string_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_add_string_label_v1; /* Autogenerated */ + + if (handle == nullptr || label == nullptr || value == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_spin_add_string_label_v1(PtrValue(handle), + label, value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_add_string_label_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_add_string_label_v1(auto_gen_group.thisClassHdl, handle, + label, value); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_string_value(KODI_GUI_CONTROL_HANDLE handle, + const char* value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_string_value(KODI_GUI_CONTROL_HANDLE handle, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_string_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_string_value_v1; /* Autogenerated */ + + if (handle == nullptr || value == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_spin_set_string_value_v1(PtrValue(handle), value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_set_string_value_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_set_string_value_v1(auto_gen_group.thisClassHdl, handle, + value); +} + +ATTR_DLL_EXPORT char* kodi_gui_controls_spin_get_string_value(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_spin_get_string_value(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_get_string_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_get_string_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_spin_get_string_value_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_get_string_value_v1, + in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_spin_get_string_value_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + return auto_gen_group.kodi_gui_controls_spin_get_string_value_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_add_int_label(KODI_GUI_CONTROL_HANDLE handle, + const char* label, + int value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_add_int_label(KODI_GUI_CONTROL_HANDLE handle, const char* label, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_add_int_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_add_int_label_v1; /* Autogenerated */ + + if (handle == nullptr || label == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_spin_add_int_label_v1(PtrValue(handle), label, value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_add_int_label_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_add_int_label_v1(auto_gen_group.thisClassHdl, handle, label, + value); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_int_range(KODI_GUI_CONTROL_HANDLE handle, + int start, + int end) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_int_range(KODI_GUI_CONTROL_HANDLE handle, int start, int end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_int_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_int_range_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_spin_set_int_range_v1(PtrValue(handle), start, end)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_set_int_range_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_set_int_range_v1(auto_gen_group.thisClassHdl, handle, start, + end); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_int_value(KODI_GUI_CONTROL_HANDLE handle, int value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_int_value(KODI_GUI_CONTROL_HANDLE handle, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_int_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_spin_set_int_value_v1(PtrValue(handle), value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_set_int_value_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_set_int_value_v1(auto_gen_group.thisClassHdl, handle, + value); +} + +ATTR_DLL_EXPORT int kodi_gui_controls_spin_get_int_value(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_controls_spin_get_int_value(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_get_int_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_get_int_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_spin_get_int_value_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_get_int_value_v1, in, + out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_spin_get_int_value_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + return auto_gen_group.kodi_gui_controls_spin_get_int_value_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_range(KODI_GUI_CONTROL_HANDLE handle, + float start, + float end) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_range(KODI_GUI_CONTROL_HANDLE handle, float start, float end) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_float_range_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_float_range_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_spin_set_float_range_v1(PtrValue(handle), start, end)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_set_float_range_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_set_float_range_v1(auto_gen_group.thisClassHdl, handle, + start, end); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_value(KODI_GUI_CONTROL_HANDLE handle, + float value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_value(KODI_GUI_CONTROL_HANDLE handle, float value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_float_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_spin_set_float_value_v1(PtrValue(handle), value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_set_float_value_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_set_float_value_v1(auto_gen_group.thisClassHdl, handle, + value); +} + +ATTR_DLL_EXPORT float kodi_gui_controls_spin_get_float_value(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT float kodi_gui_controls_spin_get_float_value(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_get_float_value_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_get_float_value_v1; /* Autogenerated */ + + if (handle == nullptr) + return 0.0f; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_spin_get_float_value_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_get_float_value_v1, in, + out)) + return 0.0f; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_spin_get_float_value_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + return auto_gen_group.kodi_gui_controls_spin_get_float_value_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_interval(KODI_GUI_CONTROL_HANDLE handle, + float interval) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_spin_set_float_interval(KODI_GUI_CONTROL_HANDLE handle, float interval) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_spin_set_float_interval_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_spin_set_float_interval_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_spin_set_float_interval_v1(PtrValue(handle), interval)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_spin_h, funcParent_kodi_gui_controls_spin_set_float_interval_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_spin_h; + auto_gen_group.kodi_gui_controls_spin_set_float_interval_v1(auto_gen_group.thisClassHdl, handle, + interval); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/spin.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/spin.h new file mode 100644 index 0000000000000..adc0684444b87 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/spin.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/spin.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_spin_h; +struct directFuncToKodi_gui_controls_spin_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_spin_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_spin_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_spin_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/text_box.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/text_box.cpp new file mode 100644 index 0000000000000..afde2ce9b4b0c --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/text_box.cpp @@ -0,0 +1,216 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "text_box.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_controls_text_box_h::InitDirect( + directFuncToAddon_gui_controls_text_box_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_visible(KODI_GUI_CONTROL_HANDLE handle, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_visible(KODI_GUI_CONTROL_HANDLE handle, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_set_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_set_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_controls_text_box_set_visible_v1(PtrValue(handle), visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_text_box_h, funcParent_kodi_gui_controls_text_box_set_visible_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_text_box_h; + auto_gen_group.kodi_gui_controls_text_box_set_visible_v1(auto_gen_group.thisClassHdl, handle, + visible); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_text_box_reset(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_text_box_reset(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_reset_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_reset_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_text_box_reset_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_text_box_h, funcParent_kodi_gui_controls_text_box_reset_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_text_box_h; + auto_gen_group.kodi_gui_controls_text_box_reset_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_text(KODI_GUI_CONTROL_HANDLE handle, + const char* text) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_text(KODI_GUI_CONTROL_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_set_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_set_text_v1; /* Autogenerated */ + + if (handle == nullptr || text == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_text_box_set_text_v1(PtrValue(handle), text)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_text_box_h, funcParent_kodi_gui_controls_text_box_set_text_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_text_box_h; + auto_gen_group.kodi_gui_controls_text_box_set_text_v1(auto_gen_group.thisClassHdl, handle, text); +} + +ATTR_DLL_EXPORT char* kodi_gui_controls_text_box_get_text(KODI_GUI_CONTROL_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_controls_text_box_get_text(KODI_GUI_CONTROL_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_get_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_get_text_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_text_box_get_text_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_text_box_h, funcParent_kodi_gui_controls_text_box_get_text_v1, + in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_controls_text_box_get_text_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_text_box_h; + return auto_gen_group.kodi_gui_controls_text_box_get_text_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_text_box_scroll(KODI_GUI_CONTROL_HANDLE handle, + unsigned int position) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_text_box_scroll(KODI_GUI_CONTROL_HANDLE handle, unsigned int position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_scroll_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_scroll_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_controls_text_box_scroll_v1(PtrValue(handle), position)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_text_box_h, funcParent_kodi_gui_controls_text_box_scroll_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_text_box_h; + auto_gen_group.kodi_gui_controls_text_box_scroll_v1(auto_gen_group.thisClassHdl, handle, + position); +} + +ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_auto_scrolling(KODI_GUI_CONTROL_HANDLE handle, + int delay, + int time, + int repeat) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_controls_text_box_set_auto_scrolling( KODI_GUI_CONTROL_HANDLE handle, int delay, int time, int repeat) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_controls_text_box_set_auto_scrolling_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_controls_text_box_set_auto_scrolling_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_controls_text_box_set_auto_scrolling_v1( + PtrValue(handle), delay, time, repeat)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_controls_text_box_h, + funcParent_kodi_gui_controls_text_box_set_auto_scrolling_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_controls_text_box_h; + auto_gen_group.kodi_gui_controls_text_box_set_auto_scrolling_v1(auto_gen_group.thisClassHdl, + handle, delay, time, repeat); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/text_box.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/text_box.h new file mode 100644 index 0000000000000..f3c903fce4421 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/controls/text_box.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/controls/text_box.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_controls_text_box_h; +struct directFuncToKodi_gui_controls_text_box_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_controls_text_box_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_controls_text_box_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_controls_text_box_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/CMakeLists.txt new file mode 100644 index 0000000000000..72a59708dbd6c --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/CMakeLists.txt @@ -0,0 +1,32 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + context_menu.cpp + extended_progress.cpp + filebrowser.cpp + keyboard.cpp + numeric.cpp + ok.cpp + progress.cpp + select.cpp + text_viewer.cpp + yes_no.cpp +) + +set(HEADERS + context_menu.h + extended_progress.h + filebrowser.h + keyboard.h + numeric.h + ok.h + progress.h + select.h + text_viewer.h + yes_no.h +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_api_gui_dialogs) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/context_menu.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/context_menu.cpp new file mode 100644 index 0000000000000..55650e9386f31 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/context_menu.cpp @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "context_menu.h" + +#include +#include + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_context_menu_h::InitDirect( + directFuncToAddon_gui_dialogs_context_menu_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT int kodi_gui_dialogs_context_menu_open(const char* heading, + const char* entries[], + size_t size) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_dialogs_context_menu_open(const char* heading, const char* entries[], size_t size) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple, size_t> msgParent__IN_kodi_gui_dialogs_context_menu_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_context_menu_open_v1; /* Autogenerated */ + + if (heading == nullptr || entries == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + std::vector cpp_entries; + cpp_entries.reserve(size); + for (size_t i = 0; i < size; ++i) + { + cpp_entries.emplace_back(entries[i] != nullptr ? entries[i] : ""); + } + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_dialogs_context_menu_open_v1(heading, cpp_entries, size)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_context_menu_h, funcParent_kodi_gui_dialogs_context_menu_open_v1, + in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_context_menu_open_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_context_menu_h; + return auto_gen_group.kodi_gui_dialogs_context_menu_open_v1(auto_gen_group.thisClassHdl, heading, + entries, size); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/context_menu.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/context_menu.h new file mode 100644 index 0000000000000..31bef254257e9 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/context_menu.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/dialogs/context_menu.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_context_menu_h; +struct directFuncToKodi_gui_dialogs_context_menu_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_dialogs_context_menu_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_context_menu_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_gui_dialogs_context_menu_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/extended_progress.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/extended_progress.cpp new file mode 100644 index 0000000000000..fbbda969e19a2 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/extended_progress.cpp @@ -0,0 +1,381 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "extended_progress.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_extended_progress_h::InitDirect( + directFuncToAddon_gui_dialogs_extended_progress_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT KODI_GUI_HANDLE kodi_gui_dialogs_extended_progress_new_dialog(const char* title) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_HANDLE kodi_gui_dialogs_extended_progress_new_dialog(const char* title) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_new_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_new_dialog_v1; /* Autogenerated */ + + if (title == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_extended_progress_new_dialog_v1(title)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_new_dialog_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_extended_progress_new_dialog_v1 t = + ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + return auto_gen_group.kodi_gui_dialogs_extended_progress_new_dialog_v1( + auto_gen_group.thisClassHdl, title); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_delete_dialog(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_delete_dialog(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_delete_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_delete_dialog_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_extended_progress_delete_dialog_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_delete_dialog_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + auto_gen_group.kodi_gui_dialogs_extended_progress_delete_dialog_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT char* kodi_gui_dialogs_extended_progress_get_title(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_dialogs_extended_progress_get_title(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_get_title_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_get_title_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_dialogs_extended_progress_get_title_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_get_title_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_extended_progress_get_title_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + return auto_gen_group.kodi_gui_dialogs_extended_progress_get_title_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_title(KODI_GUI_HANDLE handle, + const char* title) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_title(KODI_GUI_HANDLE handle, const char* title) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_set_title_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_set_title_v1; /* Autogenerated */ + + if (handle == nullptr || title == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_extended_progress_set_title_v1(PtrValue(handle), title)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_set_title_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + auto_gen_group.kodi_gui_dialogs_extended_progress_set_title_v1(auto_gen_group.thisClassHdl, + handle, title); +} + +ATTR_DLL_EXPORT char* kodi_gui_dialogs_extended_progress_get_text(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_dialogs_extended_progress_get_text(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_get_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_get_text_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_dialogs_extended_progress_get_text_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_get_text_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_extended_progress_get_text_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + return auto_gen_group.kodi_gui_dialogs_extended_progress_get_text_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_text(KODI_GUI_HANDLE handle, + const char* text) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_text(KODI_GUI_HANDLE handle, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_set_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_set_text_v1; /* Autogenerated */ + + if (handle == nullptr || text == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_extended_progress_set_text_v1(PtrValue(handle), text)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_set_text_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + auto_gen_group.kodi_gui_dialogs_extended_progress_set_text_v1(auto_gen_group.thisClassHdl, handle, + text); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_extended_progress_is_finished(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_extended_progress_is_finished(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_is_finished_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_is_finished_v1; /* Autogenerated */ + + if (handle == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_extended_progress_is_finished_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_is_finished_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_extended_progress_is_finished_v1 t = + ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + return auto_gen_group.kodi_gui_dialogs_extended_progress_is_finished_v1( + auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_mark_finished(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_mark_finished(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_mark_finished_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_mark_finished_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_extended_progress_mark_finished_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_mark_finished_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + auto_gen_group.kodi_gui_dialogs_extended_progress_mark_finished_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT float kodi_gui_dialogs_extended_progress_get_percentage(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT float kodi_gui_dialogs_extended_progress_get_percentage(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_get_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_get_percentage_v1; /* Autogenerated */ + + if (handle == nullptr) + return 0.0f; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_extended_progress_get_percentage_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_get_percentage_v1, in, out)) + return 0.0f; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_extended_progress_get_percentage_v1 t = + ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + return auto_gen_group.kodi_gui_dialogs_extended_progress_get_percentage_v1( + auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_percentage(KODI_GUI_HANDLE handle, + float percentage) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_percentage(KODI_GUI_HANDLE handle, float percentage) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_set_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_set_percentage_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_extended_progress_set_percentage_v1( + PtrValue(handle), percentage)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_set_percentage_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + auto_gen_group.kodi_gui_dialogs_extended_progress_set_percentage_v1(auto_gen_group.thisClassHdl, + handle, percentage); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_progress(KODI_GUI_HANDLE handle, + int currentItem, + int itemCount) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_extended_progress_set_progress(KODI_GUI_HANDLE handle, int currentItem, int itemCount) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_extended_progress_set_progress_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_extended_progress_set_progress_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_extended_progress_set_progress_v1( + PtrValue(handle), currentItem, itemCount)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_extended_progress_h, + funcParent_kodi_gui_dialogs_extended_progress_set_progress_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_extended_progress_h; + auto_gen_group.kodi_gui_dialogs_extended_progress_set_progress_v1(auto_gen_group.thisClassHdl, + handle, currentItem, itemCount); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/extended_progress.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/extended_progress.h new file mode 100644 index 0000000000000..e4c12337d7f4e --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/extended_progress.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/dialogs/extended_progress.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_extended_progress_h; +struct directFuncToKodi_gui_dialogs_extended_progress_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_dialogs_extended_progress_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_extended_progress_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect( + KODI::ADDONS::INTERFACE::directFuncToAddon_gui_dialogs_extended_progress_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/filebrowser.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/filebrowser.cpp new file mode 100644 index 0000000000000..b2af6cae61142 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/filebrowser.cpp @@ -0,0 +1,372 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "filebrowser.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_filebrowser_h::InitDirect( + directFuncToAddon_gui_dialogs_filebrowser_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_directory( + const char* shares, const char* heading, const char* path_in, char** path_out, bool write_only) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_directory(const char* shares, const char* heading, const char* path_in, char** path_out, bool write_only) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_directory_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_directory_v1; /* Autogenerated */ + + if (shares == nullptr || heading == nullptr || path_in == nullptr || path_out == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_directory_v1( + shares, heading, path_in, write_only)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_filebrowser_h, + funcParent_kodi_gui_dialogs_file_browser_show_and_get_directory_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_directory_v1 t = + ident.get().as(); + + *path_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_filebrowser_h; + return auto_gen_group.kodi_gui_dialogs_file_browser_show_and_get_directory_v1( + auto_gen_group.thisClassHdl, shares, heading, path_in, path_out, write_only); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file(const char* shares, + const char* mask, + const char* heading, + const char* path_in, + char** path_out, + bool use_thumbs, + bool use_file_directories) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file(const char* shares, const char* mask, const char* heading, const char* path_in, char** path_out, bool use_thumbs, bool use_file_directories) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_v1; /* Autogenerated */ + + if (shares == nullptr || mask == nullptr || heading == nullptr || path_in == nullptr || + path_out == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_v1( + shares, mask, heading, path_in, use_thumbs, use_file_directories)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_filebrowser_h, + funcParent_kodi_gui_dialogs_file_browser_show_and_get_file_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_v1 t = + ident.get().as(); + + *path_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_filebrowser_h; + return auto_gen_group.kodi_gui_dialogs_file_browser_show_and_get_file_v1( + auto_gen_group.thisClassHdl, shares, mask, heading, path_in, path_out, use_thumbs, + use_file_directories); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file_from_dir( + const char* directory, + const char* mask, + const char* heading, + const char* path_in, + char** path_out, + bool use_thumbs, + bool use_file_directories, + bool single_list) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file_from_dir( const char* directory, const char* mask, const char* heading, const char* path_in, char** path_out, bool use_thumbs, bool use_file_directories, bool single_list) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1; /* Autogenerated */ + + if (directory == nullptr || mask == nullptr || heading == nullptr || path_in == nullptr || + path_out == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1( + directory, mask, heading, path_in, use_thumbs, use_file_directories, single_list)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_filebrowser_h, + funcParent_kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1 t = + ident.get().as(); + + *path_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_filebrowser_h; + return auto_gen_group.kodi_gui_dialogs_file_browser_show_and_get_file_from_dir_v1( + auto_gen_group.thisClassHdl, directory, mask, heading, path_in, path_out, use_thumbs, + use_file_directories, single_list); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file_list(const char* shares, + const char* mask, + const char* heading, + char*** file_list, + size_t* entries, + bool use_thumbs, + bool use_file_directories) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_file_list( const char* shares, const char* mask, const char* heading, char*** file_list, size_t* entries, bool use_thumbs, bool use_file_directories) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_list_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_list_v1; /* Autogenerated */ + + if (shares == nullptr || mask == nullptr || heading == nullptr || file_list == nullptr || + entries == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_file_list_v1( + shares, mask, heading, *entries, use_thumbs, use_file_directories)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_filebrowser_h, + funcParent_kodi_gui_dialogs_file_browser_show_and_get_file_list_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_file_list_v1 t = + ident.get().as(); + + const std::vector& cpp_file_list = std::get<1>(t); + *entries = std::get<2>(t); + assert(cpp_file_list.size() == *entries); + if (!cpp_file_list.empty()) + { + *file_list = static_cast(malloc(*entries * sizeof(char*))); + for (size_t i = 0; i < *entries; ++i) + (*file_list)[i] = strdup(cpp_file_list[i].c_str()); + } + else + { + *file_list = nullptr; + } + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_filebrowser_h; + return auto_gen_group.kodi_gui_dialogs_file_browser_show_and_get_file_list_v1( + auto_gen_group.thisClassHdl, shares, mask, heading, file_list, entries, use_thumbs, + use_file_directories); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_source(const char* path_in, + char** path_out, + bool allow_network_shares, + const char* additional_share, + const char* type) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_source( const char* path_in, char** path_out, bool allow_network_shares, const char* additional_share, const char* type) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_source_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_source_v1; /* Autogenerated */ + + if (path_in == nullptr || path_out == nullptr || additional_share == nullptr || type == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_source_v1( + path_in, allow_network_shares, additional_share, type)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_filebrowser_h, + funcParent_kodi_gui_dialogs_file_browser_show_and_get_source_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_source_v1 t = + ident.get().as(); + + *path_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_filebrowser_h; + return auto_gen_group.kodi_gui_dialogs_file_browser_show_and_get_source_v1( + auto_gen_group.thisClassHdl, path_in, path_out, allow_network_shares, additional_share, type); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_image(const char* shares, + const char* heading, + const char* path_in, + char** path_out) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_image(const char* shares, const char* heading, const char* path_in, char** path_out) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_image_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_image_v1; /* Autogenerated */ + + if (shares == nullptr || heading == nullptr || path_in == nullptr || path_out == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_image_v1( + shares, heading, path_in)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_filebrowser_h, + funcParent_kodi_gui_dialogs_file_browser_show_and_get_image_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_image_v1 t = + ident.get().as(); + + *path_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_filebrowser_h; + return auto_gen_group.kodi_gui_dialogs_file_browser_show_and_get_image_v1( + auto_gen_group.thisClassHdl, shares, heading, path_in, path_out); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_image_list(const char* shares, + const char* heading, + char*** file_list, + size_t* entries) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_file_browser_show_and_get_image_list(const char* shares, const char* heading, char*** file_list, size_t* entries) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_image_list_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple, size_t> msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_image_list_v1; /* Autogenerated */ + + if (shares == nullptr || heading == nullptr || file_list == nullptr || entries == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_file_browser_show_and_get_image_list_v1( + shares, heading, *entries)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_filebrowser_h, + funcParent_kodi_gui_dialogs_file_browser_show_and_get_image_list_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_file_browser_show_and_get_image_list_v1 t = + ident.get().as(); + + const std::vector& cpp_file_list = std::get<1>(t); + *entries = std::get<2>(t); + assert(cpp_file_list.size() == *entries); + if (!cpp_file_list.empty()) + { + *file_list = static_cast(malloc(*entries * sizeof(char*))); + for (size_t i = 0; i < *entries; ++i) + (*file_list)[i] = strdup(cpp_file_list[i].c_str()); + } + else + { + *file_list = nullptr; + } + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_filebrowser_h; + return auto_gen_group.kodi_gui_dialogs_file_browser_show_and_get_image_list_v1( + auto_gen_group.thisClassHdl, shares, heading, file_list, entries); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_file_browser_clear_file_list(char*** file_list, + size_t entries) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_file_browser_clear_file_list(char*** file_list, size_t entries) __INTRODUCED_IN_KODI(1); + // Tuple in: /* NOTE: msgParent__IN_kodi_gui_dialogs_file_browser_clear_file_list - Override active to use inside dev-kit library only */ + // Tuple out: /* NOTE: msgParent_OUT_kodi_gui_dialogs_file_browser_clear_file_list - Override active to use inside dev-kit library only */ + + /*---AUTO_GEN_PARSE---*/ + + if (*file_list) + { + for (size_t i = 0; i < entries; ++i) + free((*file_list)[i]); + free(*file_list); + *file_list = nullptr; + } + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/filebrowser.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/filebrowser.h new file mode 100644 index 0000000000000..aa0cc46f670bc --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/filebrowser.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/dialogs/filebrowser.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_filebrowser_h; +struct directFuncToKodi_gui_dialogs_filebrowser_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_dialogs_filebrowser_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_filebrowser_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_dialogs_filebrowser_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/keyboard.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/keyboard.cpp new file mode 100644 index 0000000000000..40dda10f297f3 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/keyboard.cpp @@ -0,0 +1,414 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "keyboard.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_keyboard_h::InitDirect( + directFuncToAddon_gui_dialogs_keyboard_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_input_with_head( + const char* text_in, + char** text_out, + const char* heading, + bool allow_empty_result, + bool hidden_input, + unsigned int auto_close_ms) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_input_with_head( const char* text_in, char** text_out, const char* heading, bool allow_empty_result, bool hidden_input, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1; /* Autogenerated */ + + if (text_in == nullptr || text_out == nullptr || heading == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1( + text_in, heading, allow_empty_result, hidden_input, auto_close_ms)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_keyboard_h, + funcParent_kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1 t = + ident.get().as(); + + *text_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_keyboard_h; + return auto_gen_group.kodi_gui_dialogs_keyboard_show_and_get_input_with_head_v1( + auto_gen_group.thisClassHdl, text_in, text_out, heading, allow_empty_result, hidden_input, + auto_close_ms); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_input(const char* text_in, + char** text_out, + bool allow_empty_result, + unsigned int auto_close_ms) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_input(const char* text_in, char** text_out, bool allow_empty_result, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_input_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_input_v1; /* Autogenerated */ + + if (text_in == nullptr || text_out == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_input_v1( + text_in, allow_empty_result, auto_close_ms)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_keyboard_h, + funcParent_kodi_gui_dialogs_keyboard_show_and_get_input_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_input_v1 t = ident.get().as(); + + *text_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_keyboard_h; + return auto_gen_group.kodi_gui_dialogs_keyboard_show_and_get_input_v1( + auto_gen_group.thisClassHdl, text_in, text_out, allow_empty_result, auto_close_ms); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head( + const char* password_in, + char** password_out, + const char* heading, + bool allow_empty_result, + unsigned int auto_close_ms) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head( const char* password_in, char** password_out, const char* heading, bool allow_empty_result, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1; /* Autogenerated */ + + if (password_in == nullptr || password_out == nullptr || heading == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1( + password_in, heading, allow_empty_result, auto_close_ms)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_keyboard_h, + funcParent_kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1 t = + ident.get().as(); + + *password_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_keyboard_h; + return auto_gen_group.kodi_gui_dialogs_keyboard_show_and_get_new_password_with_head_v1( + auto_gen_group.thisClassHdl, password_in, password_out, heading, allow_empty_result, + auto_close_ms); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_new_password(const char* password_in, + char** password_out, + unsigned int auto_close_ms) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_new_password( const char* password_in, char** password_out, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_new_password_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_new_password_v1; /* Autogenerated */ + + if (password_in == nullptr || password_out == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_new_password_v1( + password_in, auto_close_ms)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_keyboard_h, + funcParent_kodi_gui_dialogs_keyboard_show_and_get_new_password_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_new_password_v1 t = + ident.get().as(); + + *password_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_keyboard_h; + return auto_gen_group.kodi_gui_dialogs_keyboard_show_and_get_new_password_v1( + auto_gen_group.thisClassHdl, password_in, password_out, auto_close_ms); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head( + char** password_out, const char* heading, bool allow_empty_result, unsigned int auto_close_ms) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head( char** password_out, const char* heading, bool allow_empty_result, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1; /* Autogenerated */ + + if (password_out == nullptr || heading == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1( + heading, allow_empty_result, auto_close_ms)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_keyboard_h, + funcParent_kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1, in, + out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1 t = + ident.get().as(); + + *password_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_keyboard_h; + return auto_gen_group.kodi_gui_dialogs_keyboard_show_and_verify_new_password_with_head_v1( + auto_gen_group.thisClassHdl, password_out, heading, allow_empty_result, auto_close_ms); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_verify_new_password( + char** password_out, unsigned int auto_close_ms) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_verify_new_password( char** password_out, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1; /* Autogenerated */ + + if (password_out == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1(auto_close_ms)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_keyboard_h, + funcParent_kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1 t = + ident.get().as(); + + *password_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_keyboard_h; + return auto_gen_group.kodi_gui_dialogs_keyboard_show_and_verify_new_password_v1( + auto_gen_group.thisClassHdl, password_out, auto_close_ms); +} + +ATTR_DLL_EXPORT int kodi_gui_dialogs_keyboard_show_and_verify_password(const char* password_in, + char** password_out, + const char* heading, + int retries, + unsigned int auto_close_ms) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_dialogs_keyboard_show_and_verify_password(const char* password_in, char** password_out, const char* heading, int retries, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_password_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_password_v1; /* Autogenerated */ + + if (password_in == nullptr || password_out == nullptr || heading == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_keyboard_show_and_verify_password_v1( + password_in, heading, retries, auto_close_ms)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_keyboard_h, + funcParent_kodi_gui_dialogs_keyboard_show_and_verify_password_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_verify_password_v1 t = + ident.get().as(); + + *password_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_keyboard_h; + return auto_gen_group.kodi_gui_dialogs_keyboard_show_and_verify_password_v1( + auto_gen_group.thisClassHdl, password_in, password_out, heading, retries, auto_close_ms); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_filter(const char* text_in, + char** text_out, + bool searching, + unsigned int auto_close_ms) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_show_and_get_filter(const char* text_in, char** text_out, bool searching, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_filter_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_filter_v1; /* Autogenerated */ + + if (text_in == nullptr || text_out == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_keyboard_show_and_get_filter_v1( + text_in, searching, auto_close_ms)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_keyboard_h, + funcParent_kodi_gui_dialogs_keyboard_show_and_get_filter_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_keyboard_show_and_get_filter_v1 t = + ident.get().as(); + + *text_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_keyboard_h; + return auto_gen_group.kodi_gui_dialogs_keyboard_show_and_get_filter_v1( + auto_gen_group.thisClassHdl, text_in, text_out, searching, auto_close_ms); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_send_text_to_active_keyboard(const char* text, + bool close_keyboard) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_send_text_to_active_keyboard(const char* text, bool close_keyboard) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1; /* Autogenerated */ + + if (text == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1( + text, close_keyboard)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_keyboard_h, + funcParent_kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1 t = + ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_keyboard_h; + return auto_gen_group.kodi_gui_dialogs_keyboard_send_text_to_active_keyboard_v1( + auto_gen_group.thisClassHdl, text, close_keyboard); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_is_keyboard_activated() +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_keyboard_is_keyboard_activated() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_keyboard_is_keyboard_activated_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_keyboard_is_keyboard_activated_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_gui_dialogs_keyboard_h, + funcParent_kodi_gui_dialogs_keyboard_is_keyboard_activated_v1, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_keyboard_is_keyboard_activated_v1 t = + ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_keyboard_h; + return auto_gen_group.kodi_gui_dialogs_keyboard_is_keyboard_activated_v1( + auto_gen_group.thisClassHdl); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/keyboard.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/keyboard.h new file mode 100644 index 0000000000000..e22c5857da5e9 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/keyboard.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/dialogs/keyboard.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_keyboard_h; +struct directFuncToKodi_gui_dialogs_keyboard_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_dialogs_keyboard_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_keyboard_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_dialogs_keyboard_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/numeric.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/numeric.cpp new file mode 100644 index 0000000000000..eae4183da7ea2 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/numeric.cpp @@ -0,0 +1,329 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "numeric.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_numeric_h::InitDirect( + directFuncToAddon_gui_dialogs_numeric_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_verify_new_password(char** password) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_verify_new_password(char** password) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_new_password_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_new_password_v1; /* Autogenerated */ + + if (password == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_gui_dialogs_numeric_h, + funcParent_kodi_gui_dialogs_numeric_show_and_verify_new_password_v1, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_new_password_v1 t = + ident.get().as(); + + *password = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_numeric_h; + return auto_gen_group.kodi_gui_dialogs_numeric_show_and_verify_new_password_v1( + auto_gen_group.thisClassHdl, password); +} + +ATTR_DLL_EXPORT int kodi_gui_dialogs_numeric_show_and_verify_password(const char* password, + const char* heading, + int retries) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_dialogs_numeric_show_and_verify_password(const char* password, const char* heading, int retries) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_password_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_password_v1; /* Autogenerated */ + + if (password == nullptr || heading == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_password_v1( + password, heading, retries)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_numeric_h, + funcParent_kodi_gui_dialogs_numeric_show_and_verify_password_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_password_v1 t = + ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_numeric_h; + return auto_gen_group.kodi_gui_dialogs_numeric_show_and_verify_password_v1( + auto_gen_group.thisClassHdl, password, heading, retries); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_verify_input(const char* verify_in, + char** verify_out, + const char* heading, + bool verify_input) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_verify_input(const char* verify_in, char** verify_out, const char* heading, bool verify_input) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_input_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_input_v1; /* Autogenerated */ + + if (verify_in == nullptr || verify_out == nullptr || heading == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_numeric_show_and_verify_input_v1( + verify_in, heading, verify_input)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_numeric_h, + funcParent_kodi_gui_dialogs_numeric_show_and_verify_input_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_numeric_show_and_verify_input_v1 t = + ident.get().as(); + + *verify_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_numeric_h; + return auto_gen_group.kodi_gui_dialogs_numeric_show_and_verify_input_v1( + auto_gen_group.thisClassHdl, verify_in, verify_out, heading, verify_input); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_time(struct tm* time, + const char* heading) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_time(struct tm* time, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_time_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_time_v1; /* Autogenerated */ + + if (time == nullptr || heading == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_time_v1(time, heading)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_numeric_h, + funcParent_kodi_gui_dialogs_numeric_show_and_get_time_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_time_v1 t = ident.get().as(); + + std::get<1>(t).SetCStructure(time); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_numeric_h; + return auto_gen_group.kodi_gui_dialogs_numeric_show_and_get_time_v1(auto_gen_group.thisClassHdl, + time, heading); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_date(struct tm* date, + const char* heading) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_date(struct tm* date, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_date_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_date_v1; /* Autogenerated */ + + if (date == nullptr || heading == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_date_v1(date, heading)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_numeric_h, + funcParent_kodi_gui_dialogs_numeric_show_and_get_date_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_date_v1 t = ident.get().as(); + + std::get<1>(t).SetCStructure(date); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_numeric_h; + return auto_gen_group.kodi_gui_dialogs_numeric_show_and_get_date_v1(auto_gen_group.thisClassHdl, + date, heading); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_ip_address(const char* ip_address_in, + char** ip_address_out, + const char* heading) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_ip_address(const char* ip_address_in, char** ip_address_out, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_ip_address_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_ip_address_v1; /* Autogenerated */ + + if (ip_address_in == nullptr || ip_address_out == nullptr || heading == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_ip_address_v1( + ip_address_in, heading)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_numeric_h, + funcParent_kodi_gui_dialogs_numeric_show_and_get_ip_address_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_ip_address_v1 t = + ident.get().as(); + + *ip_address_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_numeric_h; + return auto_gen_group.kodi_gui_dialogs_numeric_show_and_get_ip_address_v1( + auto_gen_group.thisClassHdl, ip_address_in, ip_address_out, heading); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_number(const char* number_in, + char** number_out, + const char* heading, + unsigned int auto_close_ms) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_number(const char* number_in, char** number_out, const char* heading, unsigned int auto_close_ms) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_number_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_number_v1; /* Autogenerated */ + + if (number_in == nullptr || number_out == nullptr || heading == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_number_v1( + number_in, heading, auto_close_ms)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_numeric_h, + funcParent_kodi_gui_dialogs_numeric_show_and_get_number_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_number_v1 t = ident.get().as(); + + *number_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_numeric_h; + return auto_gen_group.kodi_gui_dialogs_numeric_show_and_get_number_v1( + auto_gen_group.thisClassHdl, number_in, number_out, heading, auto_close_ms); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_seconds(const char* time_in, + char** time_out, + const char* heading) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_numeric_show_and_get_seconds(const char* time_in, char** time_out, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_seconds_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_seconds_v1; /* Autogenerated */ + + if (time_in == nullptr || time_out == nullptr || heading == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_dialogs_numeric_show_and_get_seconds_v1(time_in, heading)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_numeric_h, + funcParent_kodi_gui_dialogs_numeric_show_and_get_seconds_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_numeric_show_and_get_seconds_v1 t = + ident.get().as(); + + *time_out = strdup(std::get<1>(t).c_str()); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_numeric_h; + return auto_gen_group.kodi_gui_dialogs_numeric_show_and_get_seconds_v1( + auto_gen_group.thisClassHdl, time_in, time_out, heading); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/numeric.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/numeric.h new file mode 100644 index 0000000000000..cdf5fe3c258e8 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/numeric.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/dialogs/numeric.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_numeric_h; +struct directFuncToKodi_gui_dialogs_numeric_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_dialogs_numeric_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_numeric_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_dialogs_numeric_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/ok.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/ok.cpp new file mode 100644 index 0000000000000..48cddc275d4ad --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/ok.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "ok.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_ok_h::InitDirect(directFuncToAddon_gui_dialogs_ok_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_dialogs_ok_show_and_get_input_single_text(const char* heading, + const char* text) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_ok_show_and_get_input_single_text(const char* heading, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_ok_show_and_get_input_single_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_ok_show_and_get_input_single_text_v1; /* Autogenerated */ + + if (heading == nullptr || text == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_ok_show_and_get_input_single_text_v1(heading, text)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_ok_h, + funcParent_kodi_gui_dialogs_ok_show_and_get_input_single_text_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_ok_h; + auto_gen_group.kodi_gui_dialogs_ok_show_and_get_input_single_text_v1(auto_gen_group.thisClassHdl, + heading, text); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_ok_show_and_get_input_line_text(const char* heading, + const char* line0, + const char* line1, + const char* line2) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_ok_show_and_get_input_line_text(const char* heading, const char* line0, const char* line1, const char* line2) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_ok_show_and_get_input_line_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_ok_show_and_get_input_line_text_v1; /* Autogenerated */ + + if (heading == nullptr || line0 == nullptr || line1 == nullptr || line2 == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_ok_show_and_get_input_line_text_v1( + heading, line0, line1, line2)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_ok_h, funcParent_kodi_gui_dialogs_ok_show_and_get_input_line_text_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_ok_h; + auto_gen_group.kodi_gui_dialogs_ok_show_and_get_input_line_text_v1(auto_gen_group.thisClassHdl, + heading, line0, line1, line2); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/ok.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/ok.h new file mode 100644 index 0000000000000..2044996b59bca --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/ok.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/dialogs/ok.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_ok_h; +struct directFuncToKodi_gui_dialogs_ok_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_dialogs_ok_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_ok_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_dialogs_ok_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/progress.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/progress.cpp new file mode 100644 index 0000000000000..47bf90f123954 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/progress.cpp @@ -0,0 +1,412 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "progress.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_progress_h::InitDirect( + directFuncToAddon_gui_dialogs_progress_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT KODI_GUI_HANDLE kodi_gui_dialogs_progress_new_dialog() +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_HANDLE kodi_gui_dialogs_progress_new_dialog() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_new_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_new_dialog_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_new_dialog_v1, + out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_progress_new_dialog_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + return auto_gen_group.kodi_gui_dialogs_progress_new_dialog_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_delete_dialog(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_delete_dialog(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_delete_dialog_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_delete_dialog_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_progress_delete_dialog_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_delete_dialog_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + auto_gen_group.kodi_gui_dialogs_progress_delete_dialog_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_open(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_open(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_open_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_progress_open_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_open_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + auto_gen_group.kodi_gui_dialogs_progress_open_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_heading(KODI_GUI_HANDLE handle, + const char* heading) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_heading(KODI_GUI_HANDLE handle, const char* heading) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_heading_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_heading_v1; /* Autogenerated */ + + if (handle == nullptr || heading == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_progress_set_heading_v1(PtrValue(handle), heading)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_set_heading_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + auto_gen_group.kodi_gui_dialogs_progress_set_heading_v1(auto_gen_group.thisClassHdl, handle, + heading); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_line(KODI_GUI_HANDLE handle, + unsigned int line_no, + const char* line) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_line(KODI_GUI_HANDLE handle, unsigned int line_no, const char* line) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_line_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_line_v1; /* Autogenerated */ + + if (handle == nullptr || line == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_progress_set_line_v1(PtrValue(handle), line_no, line)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_set_line_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + auto_gen_group.kodi_gui_dialogs_progress_set_line_v1(auto_gen_group.thisClassHdl, handle, line_no, + line); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_can_cancel(KODI_GUI_HANDLE handle, + bool can_cancel) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_can_cancel(KODI_GUI_HANDLE handle, bool can_cancel) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_can_cancel_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_can_cancel_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_progress_set_can_cancel_v1(PtrValue(handle), + can_cancel)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_set_can_cancel_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + auto_gen_group.kodi_gui_dialogs_progress_set_can_cancel_v1(auto_gen_group.thisClassHdl, handle, + can_cancel); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_progress_is_canceled(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_progress_is_canceled(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_is_canceled_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_is_canceled_v1; /* Autogenerated */ + + if (handle == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_progress_is_canceled_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_is_canceled_v1, + in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_progress_is_canceled_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + return auto_gen_group.kodi_gui_dialogs_progress_is_canceled_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_percentage(KODI_GUI_HANDLE handle, + int percentage) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_percentage(KODI_GUI_HANDLE handle, int percentage) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_percentage_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_progress_set_percentage_v1(PtrValue(handle), + percentage)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_set_percentage_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + auto_gen_group.kodi_gui_dialogs_progress_set_percentage_v1(auto_gen_group.thisClassHdl, handle, + percentage); +} + +ATTR_DLL_EXPORT int kodi_gui_dialogs_progress_get_percentage(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_dialogs_progress_get_percentage(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_get_percentage_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_get_percentage_v1; /* Autogenerated */ + + if (handle == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_progress_get_percentage_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, + funcParent_kodi_gui_dialogs_progress_get_percentage_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_progress_get_percentage_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + return auto_gen_group.kodi_gui_dialogs_progress_get_percentage_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_show_progress_bar(KODI_GUI_HANDLE handle, + bool on_off) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_show_progress_bar(KODI_GUI_HANDLE handle, bool on_off) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_show_progress_bar_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_show_progress_bar_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_progress_show_progress_bar_v1(PtrValue(handle), on_off)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_show_progress_bar_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + auto_gen_group.kodi_gui_dialogs_progress_show_progress_bar_v1(auto_gen_group.thisClassHdl, handle, + on_off); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_progress_max(KODI_GUI_HANDLE handle, int max) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_progress_max(KODI_GUI_HANDLE handle, int max) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_progress_max_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_progress_max_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_dialogs_progress_set_progress_max_v1(PtrValue(handle), max)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_set_progress_max_v1, + in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + auto_gen_group.kodi_gui_dialogs_progress_set_progress_max_v1(auto_gen_group.thisClassHdl, handle, + max); +} + +ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_progress_advance(KODI_GUI_HANDLE handle, + int n_steps) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_progress_set_progress_advance(KODI_GUI_HANDLE handle, int n_steps) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_set_progress_advance_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_set_progress_advance_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_progress_set_progress_advance_v1( + PtrValue(handle), n_steps)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, + funcParent_kodi_gui_dialogs_progress_set_progress_advance_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + auto_gen_group.kodi_gui_dialogs_progress_set_progress_advance_v1(auto_gen_group.thisClassHdl, + handle, n_steps); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_progress_abort(KODI_GUI_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_progress_abort(KODI_GUI_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_progress_abort_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_progress_abort_v1; /* Autogenerated */ + + if (handle == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_progress_abort_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_progress_h, funcParent_kodi_gui_dialogs_progress_abort_v1, in, + out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_progress_abort_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_progress_h; + return auto_gen_group.kodi_gui_dialogs_progress_abort_v1(auto_gen_group.thisClassHdl, handle); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/progress.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/progress.h new file mode 100644 index 0000000000000..d0b5611b3c6e3 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/progress.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/dialogs/progress.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_progress_h; +struct directFuncToKodi_gui_dialogs_progress_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_dialogs_progress_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_progress_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_dialogs_progress_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/select.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/select.cpp new file mode 100644 index 0000000000000..d255d18e1381d --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/select.cpp @@ -0,0 +1,145 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "select.h" + +#include +#include + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_select_h::InitDirect(directFuncToAddon_gui_dialogs_select_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT int kodi_gui_dialogs_select_open( + const char* heading, const char* entries[], size_t size, int selected, unsigned int autoclose) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_dialogs_select_open(const char* heading, const char* entries[], size_t size, int selected, unsigned int autoclose) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple, size_t, int, unsigned int> msgParent__IN_kodi_gui_dialogs_select_open_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_select_open_v1; /* Autogenerated */ + + if (heading == nullptr || entries == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + std::vector cpp_entries; + cpp_entries.reserve(size); + for (size_t i = 0; i < size; ++i) + { + cpp_entries.emplace_back(entries[i] != nullptr ? entries[i] : ""); + } + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_select_open_v1(heading, cpp_entries, size, + selected, autoclose)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_select_h, funcParent_kodi_gui_dialogs_select_open_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_select_open_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_select_h; + return auto_gen_group.kodi_gui_dialogs_select_open_v1(auto_gen_group.thisClassHdl, heading, + entries, size, selected, autoclose); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_select_open_multi_select(const char* heading, + const char* entryIDs[], + const char* entryNames[], + uint8_t entriesSelected[], + size_t size, + unsigned int autoclose) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_select_open_multi_select(const char* heading, const char* entryIDs[], const char* entryNames[], uint8_t entriesSelected[], size_t size, unsigned int autoclose) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple, std::vector, std::vector, size_t, unsigned int> msgParent__IN_kodi_gui_dialogs_select_open_multi_select_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple> msgParent_OUT_kodi_gui_dialogs_select_open_multi_select_v1; /* Autogenerated */ + + if (heading == nullptr || entryIDs == nullptr || entryNames == nullptr || + entriesSelected == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + std::vector cpp_entryIDs; + cpp_entryIDs.reserve(size); + for (size_t i = 0; i < size; ++i) + { + cpp_entryIDs.emplace_back(entryIDs[i] != nullptr ? entryIDs[i] : ""); + } + std::vector cpp_entryNames; + cpp_entryNames.reserve(size); + for (size_t i = 0; i < size; ++i) + { + cpp_entryNames.emplace_back(entryNames[i] != nullptr ? entryNames[i] : ""); + } + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_select_open_multi_select_v1( + heading, cpp_entryIDs, cpp_entryNames, + std::vector(entriesSelected, entriesSelected + size), size, + autoclose)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_select_h, funcParent_kodi_gui_dialogs_select_open_multi_select_v1, + in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_select_open_multi_select_v1 t = ident.get().as(); + + std::memcpy(entriesSelected, std::get<1>(t).data(), sizeof(uint8_t) * size); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_select_h; + return auto_gen_group.kodi_gui_dialogs_select_open_multi_select_v1( + auto_gen_group.thisClassHdl, heading, entryIDs, entryNames, entriesSelected, size, autoclose); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/select.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/select.h new file mode 100644 index 0000000000000..97dcc3f1281db --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/select.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/dialogs/select.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_select_h; +struct directFuncToKodi_gui_dialogs_select_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_dialogs_select_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_select_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_dialogs_select_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/text_viewer.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/text_viewer.cpp new file mode 100644 index 0000000000000..b241b9a3689ca --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/text_viewer.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "text_viewer.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_text_viewer_h::InitDirect( + directFuncToAddon_gui_dialogs_text_viewer_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_dialogs_text_viewer_show(const char* heading, const char* text) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_dialogs_text_viewer_show(const char* heading, const char* text) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_text_viewer_show_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_text_viewer_show_v1; /* Autogenerated */ + + if (heading == nullptr || text == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_text_viewer_show_v1(heading, text)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_text_viewer_h, funcParent_kodi_gui_dialogs_text_viewer_show_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_text_viewer_h; + auto_gen_group.kodi_gui_dialogs_text_viewer_show_v1(auto_gen_group.thisClassHdl, heading, text); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/text_viewer.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/text_viewer.h new file mode 100644 index 0000000000000..6ea6a1660dde1 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/text_viewer.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/dialogs/text_viewer.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_text_viewer_h; +struct directFuncToKodi_gui_dialogs_text_viewer_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_dialogs_text_viewer_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_text_viewer_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_dialogs_text_viewer_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/yes_no.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/yes_no.cpp new file mode 100644 index 0000000000000..287fa2536bf79 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/yes_no.cpp @@ -0,0 +1,171 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "yes_no.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_dialogs_yes_no_h::InitDirect(directFuncToAddon_gui_dialogs_yes_no_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_single_text(const char* heading, + const char* text, + bool* canceled, + const char* noLabel, + const char* yesLabel) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_single_text(const char* heading, const char* text, bool* canceled, const char* noLabel, const char* yesLabel) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1; /* Autogenerated */ + + if (heading == nullptr || text == nullptr || canceled == nullptr || noLabel == nullptr || + yesLabel == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1( + heading, text, *canceled, noLabel, yesLabel)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_yes_no_h, + funcParent_kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1 t = + ident.get().as(); + + *canceled = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_yes_no_h; + return auto_gen_group.kodi_gui_dialogs_yesno_show_and_get_input_single_text_v1( + auto_gen_group.thisClassHdl, heading, text, canceled, noLabel, yesLabel); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_line_text(const char* heading, + const char* line0, + const char* line1, + const char* line2, + const char* noLabel, + const char* yesLabel) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_line_text(const char* heading, const char* line0, const char* line1, const char* line2, const char* noLabel, const char* yesLabel) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1; /* Autogenerated */ + + if (heading == nullptr || line0 == nullptr || line1 == nullptr || line2 == nullptr || + noLabel == nullptr || yesLabel == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1( + heading, line0, line1, line2, noLabel, yesLabel)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_yes_no_h, + funcParent_kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1 t = + ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_yes_no_h; + return auto_gen_group.kodi_gui_dialogs_yesno_show_and_get_input_line_text_v1( + auto_gen_group.thisClassHdl, heading, line0, line1, line2, noLabel, yesLabel); +} + +ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_line_button_text( + const char* heading, + const char* line0, + const char* line1, + const char* line2, + bool* canceled, + const char* noLabel, + const char* yesLabel) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_dialogs_yesno_show_and_get_input_line_button_text( const char* heading, const char* line0, const char* line1, const char* line2, bool* canceled, const char* noLabel, const char* yesLabel) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1; /* Autogenerated */ + + if (heading == nullptr || line0 == nullptr || line1 == nullptr || line2 == nullptr || + canceled == nullptr || noLabel == nullptr || yesLabel == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1( + heading, line0, line1, line2, *canceled, noLabel, yesLabel)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_dialogs_yes_no_h, + funcParent_kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1 t = + ident.get().as(); + + *canceled = std::get<1>(t); + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_dialogs_yes_no_h; + return auto_gen_group.kodi_gui_dialogs_yesno_show_and_get_input_line_button_text_v1( + auto_gen_group.thisClassHdl, heading, line0, line1, line2, canceled, noLabel, yesLabel); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/yes_no.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/yes_no.h new file mode 100644 index 0000000000000..4bc05a5576718 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/dialogs/yes_no.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/dialogs/yes_no.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_dialogs_yes_no_h; +struct directFuncToKodi_gui_dialogs_yes_no_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_dialogs_yes_no_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_dialogs_yes_no_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_dialogs_yes_no_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/general.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/general.cpp new file mode 100644 index 0000000000000..dfebf26f307a2 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/general.cpp @@ -0,0 +1,233 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "general.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_general_h::InitDirect(directFuncToAddon_gui_general_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT void kodi_gui_lock() +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_lock() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_lock_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_lock_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage(funcGroup_gui_general_h, + funcParent_kodi_gui_lock_v1); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_general_h; + auto_gen_group.kodi_gui_lock_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT void kodi_gui_unlock() +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_unlock() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_unlock_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_unlock_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage(funcGroup_gui_general_h, + funcParent_kodi_gui_unlock_v1); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_general_h; + auto_gen_group.kodi_gui_unlock_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT int kodi_gui_get_screen_height() +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_get_screen_height() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_screen_height_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_screen_height_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_gui_general_h, funcParent_kodi_gui_get_screen_height_v1, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_get_screen_height_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_general_h; + return auto_gen_group.kodi_gui_get_screen_height_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT int kodi_gui_get_screen_width() +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_get_screen_width() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_screen_width_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_screen_width_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_gui_general_h, funcParent_kodi_gui_get_screen_width_v1, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_get_screen_width_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_general_h; + return auto_gen_group.kodi_gui_get_screen_width_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT float kodi_gui_get_video_resolution() +{ + // Original API call: ATTR_DLL_EXPORT float kodi_gui_get_video_resolution() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_video_resolution_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_video_resolution_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_gui_general_h, funcParent_kodi_gui_get_video_resolution_v1, out)) + return 0.0f; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_get_video_resolution_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_general_h; + return auto_gen_group.kodi_gui_get_video_resolution_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT int kodi_gui_get_current_window_dialog_id() +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_get_current_window_dialog_id() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_current_window_dialog_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_current_window_dialog_id_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_gui_general_h, funcParent_kodi_gui_get_current_window_dialog_id_v1, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_get_current_window_dialog_id_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_general_h; + return auto_gen_group.kodi_gui_get_current_window_dialog_id_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT int kodi_gui_get_current_window_id() +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_get_current_window_id() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_current_window_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_current_window_id_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_gui_general_h, funcParent_kodi_gui_get_current_window_id_v1, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_get_current_window_id_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_general_h; + return auto_gen_group.kodi_gui_get_current_window_id_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT ADDON_HARDWARE_CONTEXT kodi_gui_get_hw_context() +{ + // Original API call: ATTR_DLL_EXPORT ADDON_HARDWARE_CONTEXT kodi_gui_get_hw_context() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_get_hw_context_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_get_hw_context_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_gui_general_h, funcParent_kodi_gui_get_hw_context_v1, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_get_hw_context_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_general_h; + return auto_gen_group.kodi_gui_get_hw_context_v1(auto_gen_group.thisClassHdl); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/general.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/general.h new file mode 100644 index 0000000000000..97ae12cc39d60 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/general.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/general.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_general_h; +struct directFuncToKodi_gui_general_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_general_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_general_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_general_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/list_item.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/list_item.cpp new file mode 100644 index 0000000000000..d14d6333b37d3 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/list_item.cpp @@ -0,0 +1,432 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "list_item.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_list_item_h::InitDirect(directFuncToAddon_gui_list_item_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT KODI_GUI_LISTITEM_HANDLE kodi_gui_listitem_create(const char* label, + const char* label2, + const char* path) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_LISTITEM_HANDLE kodi_gui_listitem_create(const char* label, const char* label2, const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_create_v1; /* Autogenerated */ + + if (label == nullptr || label2 == nullptr || path == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_create_v1(label, label2, path)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_create_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_listitem_create_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + return auto_gen_group.kodi_gui_listitem_create_v1(auto_gen_group.thisClassHdl, label, label2, + path); +} + +ATTR_DLL_EXPORT void kodi_gui_listitem_destroy(KODI_GUI_LISTITEM_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_destroy(KODI_GUI_LISTITEM_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_destroy_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_destroy_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_destroy_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_destroy_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + auto_gen_group.kodi_gui_listitem_destroy_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT char* kodi_gui_listitem_get_label(KODI_GUI_LISTITEM_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_listitem_get_label(KODI_GUI_LISTITEM_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_get_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_get_label_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_get_label_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_get_label_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_listitem_get_label_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + return auto_gen_group.kodi_gui_listitem_get_label_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_listitem_set_label(KODI_GUI_LISTITEM_HANDLE handle, const char* label) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_set_label(KODI_GUI_LISTITEM_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_set_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_set_label_v1; /* Autogenerated */ + + if (handle == nullptr || label == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_set_label_v1(PtrValue(handle), label)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_set_label_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + auto_gen_group.kodi_gui_listitem_set_label_v1(auto_gen_group.thisClassHdl, handle, label); +} + +ATTR_DLL_EXPORT char* kodi_gui_listitem_get_label2(KODI_GUI_LISTITEM_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_listitem_get_label2(KODI_GUI_LISTITEM_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_get_label2_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_get_label2_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_get_label2_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_get_label2_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_listitem_get_label2_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + return auto_gen_group.kodi_gui_listitem_get_label2_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_listitem_set_label2(KODI_GUI_LISTITEM_HANDLE handle, + const char* label) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_set_label2(KODI_GUI_LISTITEM_HANDLE handle, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_set_label2_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_set_label2_v1; /* Autogenerated */ + + if (handle == nullptr || label == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_set_label2_v1(PtrValue(handle), label)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_set_label2_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + auto_gen_group.kodi_gui_listitem_set_label2_v1(auto_gen_group.thisClassHdl, handle, label); +} + +ATTR_DLL_EXPORT char* kodi_gui_listitem_get_art(KODI_GUI_LISTITEM_HANDLE handle, const char* type) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_listitem_get_art(KODI_GUI_LISTITEM_HANDLE handle, const char* type) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_get_art_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_get_art_v1; /* Autogenerated */ + + if (handle == nullptr || type == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_get_art_v1(PtrValue(handle), type)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_get_art_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_listitem_get_art_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + return auto_gen_group.kodi_gui_listitem_get_art_v1(auto_gen_group.thisClassHdl, handle, type); +} + +ATTR_DLL_EXPORT void kodi_gui_listitem_set_art(KODI_GUI_LISTITEM_HANDLE handle, + const char* type, + const char* image) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_set_art(KODI_GUI_LISTITEM_HANDLE handle, const char* type, const char* image) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_set_art_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_set_art_v1; /* Autogenerated */ + + if (handle == nullptr || type == nullptr || image == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_set_art_v1(PtrValue(handle), type, image)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_set_art_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + auto_gen_group.kodi_gui_listitem_set_art_v1(auto_gen_group.thisClassHdl, handle, type, image); +} + +ATTR_DLL_EXPORT char* kodi_gui_listitem_get_path(KODI_GUI_LISTITEM_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_listitem_get_path(KODI_GUI_LISTITEM_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_get_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_get_path_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_get_path_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_get_path_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_listitem_get_path_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + return auto_gen_group.kodi_gui_listitem_get_path_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_listitem_set_path(KODI_GUI_LISTITEM_HANDLE handle, const char* path) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_set_path(KODI_GUI_LISTITEM_HANDLE handle, const char* path) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_set_path_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_set_path_v1; /* Autogenerated */ + + if (handle == nullptr || path == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_set_path_v1(PtrValue(handle), path)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_set_path_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + auto_gen_group.kodi_gui_listitem_set_path_v1(auto_gen_group.thisClassHdl, handle, path); +} + +ATTR_DLL_EXPORT char* kodi_gui_listitem_get_property(KODI_GUI_LISTITEM_HANDLE handle, + const char* key) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_listitem_get_property(KODI_GUI_LISTITEM_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_get_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_get_property_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_get_property_v1(PtrValue(handle), key)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_get_property_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_listitem_get_property_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + return auto_gen_group.kodi_gui_listitem_get_property_v1(auto_gen_group.thisClassHdl, handle, key); +} + +ATTR_DLL_EXPORT void kodi_gui_listitem_set_property(KODI_GUI_LISTITEM_HANDLE handle, + const char* key, + const char* value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_set_property(KODI_GUI_LISTITEM_HANDLE handle, const char* key, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_set_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_set_property_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr || value == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_listitem_set_property_v1(PtrValue(handle), key, value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_set_property_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + auto_gen_group.kodi_gui_listitem_set_property_v1(auto_gen_group.thisClassHdl, handle, key, value); +} + +ATTR_DLL_EXPORT void kodi_gui_listitem_select(KODI_GUI_LISTITEM_HANDLE handle, bool select) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_listitem_select(KODI_GUI_LISTITEM_HANDLE handle, bool select) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_select_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_select_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_select_v1(PtrValue(handle), select)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_select_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + auto_gen_group.kodi_gui_listitem_select_v1(auto_gen_group.thisClassHdl, handle, select); +} + +ATTR_DLL_EXPORT bool kodi_gui_listitem_is_selected(KODI_GUI_LISTITEM_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_listitem_is_selected(KODI_GUI_LISTITEM_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_listitem_is_selected_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_listitem_is_selected_v1; /* Autogenerated */ + + if (handle == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_listitem_is_selected_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_list_item_h, funcParent_kodi_gui_listitem_is_selected_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_listitem_is_selected_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_list_item_h; + return auto_gen_group.kodi_gui_listitem_is_selected_v1(auto_gen_group.thisClassHdl, handle); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/list_item.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/list_item.h new file mode 100644 index 0000000000000..c7e6688fd569d --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/list_item.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/list_item.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_list_item_h; +struct directFuncToKodi_gui_list_item_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_list_item_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_list_item_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_list_item_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/window.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/window.cpp new file mode 100644 index 0000000000000..7f6f821f72011 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/window.cpp @@ -0,0 +1,1340 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "window.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_gui_window_h::InitDirect(directFuncToAddon_gui_window_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT KODI_GUI_WINDOW_HANDLE kodi_gui_window_create(KODI_HANDLE kodiBase, + const char* xml_filename, + const char* default_skin, + bool as_dialog, + bool is_media) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_WINDOW_HANDLE kodi_gui_window_create(KODI_HANDLE kodiBase, const char* xml_filename, const char* default_skin, bool as_dialog, bool is_media) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_create_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_create_v1; /* Autogenerated */ + + if (kodiBase == nullptr || xml_filename == nullptr || default_skin == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_create_v1(PtrValue(kodiBase), xml_filename, + default_skin, as_dialog, is_media)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_create_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_create_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_create_v1(auto_gen_group.thisClassHdl, kodiBase, + xml_filename, default_skin, as_dialog, is_media); +} + +ATTR_DLL_EXPORT void kodi_gui_window_destroy(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_destroy(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_destroy_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_destroy_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_destroy_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_destroy_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_destroy_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT bool kodi_gui_window_show(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_window_show(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_show_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_show_v1; /* Autogenerated */ + + if (handle == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_show_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_show_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_show_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_show_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT bool kodi_gui_window_close(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_window_close(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_close_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_close_v1; /* Autogenerated */ + + if (handle == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_close_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_close_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_close_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_close_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT bool kodi_gui_window_do_modal(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_window_do_modal(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_do_modal_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_do_modal_v1; /* Autogenerated */ + + if (handle == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_do_modal_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_do_modal_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_do_modal_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_do_modal_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT bool kodi_gui_window_set_focus_id(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_window_set_focus_id(KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_focus_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_focus_id_v1; /* Autogenerated */ + + if (handle == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_set_focus_id_v1(PtrValue(handle), control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_focus_id_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_set_focus_id_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_set_focus_id_v1(auto_gen_group.thisClassHdl, handle, + control_id); +} + +ATTR_DLL_EXPORT int kodi_gui_window_get_focus_id(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_window_get_focus_id(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_focus_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_focus_id_v1; /* Autogenerated */ + + if (handle == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_focus_id_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_focus_id_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_focus_id_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_focus_id_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_window_set_control_label(KODI_GUI_WINDOW_HANDLE handle, + int control_id, + const char* label) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_control_label(KODI_GUI_WINDOW_HANDLE handle, int control_id, const char* label) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_control_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_control_label_v1; /* Autogenerated */ + + if (handle == nullptr || label == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_set_control_label_v1(PtrValue(handle), + control_id, label)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_control_label_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_set_control_label_v1(auto_gen_group.thisClassHdl, handle, + control_id, label); +} + +ATTR_DLL_EXPORT void kodi_gui_window_set_control_visible(KODI_GUI_WINDOW_HANDLE handle, + int control_id, + bool visible) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_control_visible(KODI_GUI_WINDOW_HANDLE handle, int control_id, bool visible) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_control_visible_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_control_visible_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_set_control_visible_v1(PtrValue(handle), + control_id, visible)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_control_visible_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_set_control_visible_v1(auto_gen_group.thisClassHdl, handle, + control_id, visible); +} + +ATTR_DLL_EXPORT void kodi_gui_window_set_control_selected(KODI_GUI_WINDOW_HANDLE handle, + int control_id, + bool selected) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_control_selected(KODI_GUI_WINDOW_HANDLE handle, int control_id, bool selected) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_control_selected_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_control_selected_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_set_control_selected_v1(PtrValue(handle), + control_id, selected)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_control_selected_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_set_control_selected_v1(auto_gen_group.thisClassHdl, handle, + control_id, selected); +} + +ATTR_DLL_EXPORT void kodi_gui_window_set_property(KODI_GUI_WINDOW_HANDLE handle, + const char* key, + const char* value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_property(KODI_GUI_WINDOW_HANDLE handle, const char* key, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_property_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr || value == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_set_property_v1(PtrValue(handle), key, value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_property_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_set_property_v1(auto_gen_group.thisClassHdl, handle, key, value); +} + +ATTR_DLL_EXPORT void kodi_gui_window_set_property_int(KODI_GUI_WINDOW_HANDLE handle, + const char* key, + int value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_property_int(KODI_GUI_WINDOW_HANDLE handle, const char* key, int value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_property_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_property_int_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_window_set_property_int_v1(PtrValue(handle), key, value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_property_int_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_set_property_int_v1(auto_gen_group.thisClassHdl, handle, key, + value); +} + +ATTR_DLL_EXPORT void kodi_gui_window_set_property_bool(KODI_GUI_WINDOW_HANDLE handle, + const char* key, + bool value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_property_bool(KODI_GUI_WINDOW_HANDLE handle, const char* key, bool value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_property_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_property_bool_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_window_set_property_bool_v1(PtrValue(handle), key, value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_property_bool_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_set_property_bool_v1(auto_gen_group.thisClassHdl, handle, key, + value); +} + +ATTR_DLL_EXPORT void kodi_gui_window_set_property_double(KODI_GUI_WINDOW_HANDLE handle, + const char* key, + double value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_property_double(KODI_GUI_WINDOW_HANDLE handle, const char* key, double value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_property_double_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_property_double_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_window_set_property_double_v1(PtrValue(handle), key, value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_property_double_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_set_property_double_v1(auto_gen_group.thisClassHdl, handle, key, + value); +} + +ATTR_DLL_EXPORT char* kodi_gui_window_get_property(KODI_GUI_WINDOW_HANDLE handle, const char* key) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_gui_window_get_property(KODI_GUI_WINDOW_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_property_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_property_v1(PtrValue(handle), key)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_property_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_property_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_property_v1(auto_gen_group.thisClassHdl, handle, key); +} + +ATTR_DLL_EXPORT int kodi_gui_window_get_property_int(KODI_GUI_WINDOW_HANDLE handle, const char* key) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_window_get_property_int(KODI_GUI_WINDOW_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_property_int_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_property_int_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_property_int_v1(PtrValue(handle), key)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_property_int_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_property_int_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_property_int_v1(auto_gen_group.thisClassHdl, handle, + key); +} + +ATTR_DLL_EXPORT bool kodi_gui_window_get_property_bool(KODI_GUI_WINDOW_HANDLE handle, + const char* key) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_gui_window_get_property_bool(KODI_GUI_WINDOW_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_property_bool_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_property_bool_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_property_bool_v1(PtrValue(handle), key)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_property_bool_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_property_bool_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_property_bool_v1(auto_gen_group.thisClassHdl, handle, + key); +} + +ATTR_DLL_EXPORT double kodi_gui_window_get_property_double(KODI_GUI_WINDOW_HANDLE handle, + const char* key) +{ + // Original API call: ATTR_DLL_EXPORT double kodi_gui_window_get_property_double(KODI_GUI_WINDOW_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_property_double_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_property_double_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr) + return 0.0; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_property_double_v1(PtrValue(handle), key)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_property_double_v1, in, out)) + return 0.0; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_property_double_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_property_double_v1(auto_gen_group.thisClassHdl, handle, + key); +} + +ATTR_DLL_EXPORT void kodi_gui_window_clear_properties(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_clear_properties(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_clear_properties_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_clear_properties_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_clear_properties_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_clear_properties_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_clear_properties_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_window_clear_property(KODI_GUI_WINDOW_HANDLE handle, const char* key) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_clear_property(KODI_GUI_WINDOW_HANDLE handle, const char* key) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_clear_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_clear_property_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_clear_property_v1(PtrValue(handle), key)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_clear_property_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_clear_property_v1(auto_gen_group.thisClassHdl, handle, key); +} + +ATTR_DLL_EXPORT void kodi_gui_window_clear_item_list(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_clear_item_list(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_clear_item_list_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_clear_item_list_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_clear_item_list_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_clear_item_list_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_clear_item_list_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_window_add_list_item(KODI_GUI_WINDOW_HANDLE handle, + KODI_GUI_LISTITEM_HANDLE item, + int list_position) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_add_list_item(KODI_GUI_WINDOW_HANDLE handle, KODI_GUI_LISTITEM_HANDLE item, int list_position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_add_list_item_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_add_list_item_v1; /* Autogenerated */ + + if (handle == nullptr || item == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_add_list_item_v1( + PtrValue(handle), PtrValue(item), list_position)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_add_list_item_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_add_list_item_v1(auto_gen_group.thisClassHdl, handle, item, + list_position); +} + +ATTR_DLL_EXPORT void kodi_gui_window_remove_list_item_from_position(KODI_GUI_WINDOW_HANDLE handle, + int list_position) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_remove_list_item_from_position(KODI_GUI_WINDOW_HANDLE handle, int list_position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_remove_list_item_from_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_remove_list_item_from_position_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_remove_list_item_from_position_v1( + PtrValue(handle), list_position)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_remove_list_item_from_position_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_remove_list_item_from_position_v1(auto_gen_group.thisClassHdl, + handle, list_position); +} + +ATTR_DLL_EXPORT void kodi_gui_window_remove_list_item(KODI_GUI_WINDOW_HANDLE handle, + KODI_GUI_LISTITEM_HANDLE item) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_remove_list_item(KODI_GUI_WINDOW_HANDLE handle, KODI_GUI_LISTITEM_HANDLE item) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_remove_list_item_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_remove_list_item_v1; /* Autogenerated */ + + if (handle == nullptr || item == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_window_remove_list_item_v1(PtrValue(handle), PtrValue(item))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_remove_list_item_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_remove_list_item_v1(auto_gen_group.thisClassHdl, handle, item); +} + +ATTR_DLL_EXPORT KODI_GUI_LISTITEM_HANDLE +kodi_gui_window_get_list_item(KODI_GUI_WINDOW_HANDLE handle, int list_position) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_LISTITEM_HANDLE kodi_gui_window_get_list_item( KODI_GUI_WINDOW_HANDLE handle, int list_position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_list_item_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_list_item_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_window_get_list_item_v1(PtrValue(handle), list_position)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_list_item_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_list_item_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_list_item_v1(auto_gen_group.thisClassHdl, handle, + list_position); +} + +ATTR_DLL_EXPORT void kodi_gui_window_set_current_list_position(KODI_GUI_WINDOW_HANDLE handle, + int list_position) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_current_list_position(KODI_GUI_WINDOW_HANDLE handle, int list_position) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_current_list_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_current_list_position_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_set_current_list_position_v1(PtrValue(handle), + list_position)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_current_list_position_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_set_current_list_position_v1(auto_gen_group.thisClassHdl, handle, + list_position); +} + +ATTR_DLL_EXPORT int kodi_gui_window_get_current_list_position(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_window_get_current_list_position(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_current_list_position_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_current_list_position_v1; /* Autogenerated */ + + if (handle == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_current_list_position_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_current_list_position_v1, in, + out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_current_list_position_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_current_list_position_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT int kodi_gui_window_get_list_size(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_window_get_list_size(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_list_size_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_list_size_v1; /* Autogenerated */ + + if (handle == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_list_size_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_list_size_v1, in, out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_list_size_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_list_size_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT void kodi_gui_window_set_container_property(KODI_GUI_WINDOW_HANDLE handle, + const char* key, + const char* value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_container_property(KODI_GUI_WINDOW_HANDLE handle, const char* key, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_container_property_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_container_property_v1; /* Autogenerated */ + + if (handle == nullptr || key == nullptr || value == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack( + in, msgParent__IN_kodi_gui_window_set_container_property_v1(PtrValue(handle), key, value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_container_property_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_set_container_property_v1(auto_gen_group.thisClassHdl, handle, key, + value); +} + +ATTR_DLL_EXPORT void kodi_gui_window_set_container_content(KODI_GUI_WINDOW_HANDLE handle, + const char* value) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_set_container_content(KODI_GUI_WINDOW_HANDLE handle, const char* value) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_set_container_content_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_set_container_content_v1; /* Autogenerated */ + + if (handle == nullptr || value == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, + msgParent__IN_kodi_gui_window_set_container_content_v1(PtrValue(handle), value)); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_set_container_content_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_set_container_content_v1(auto_gen_group.thisClassHdl, handle, + value); +} + +ATTR_DLL_EXPORT int kodi_gui_window_get_current_container_id(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT int kodi_gui_window_get_current_container_id(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_current_container_id_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_current_container_id_v1; /* Autogenerated */ + + if (handle == nullptr) + return -1; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_current_container_id_v1(PtrValue(handle))); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_current_container_id_v1, in, + out)) + return -1; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_current_container_id_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_current_container_id_v1(auto_gen_group.thisClassHdl, + handle); +} + +ATTR_DLL_EXPORT void kodi_gui_window_mark_dirty_region(KODI_GUI_WINDOW_HANDLE handle) +{ + // Original API call: ATTR_DLL_EXPORT void kodi_gui_window_mark_dirty_region(KODI_GUI_WINDOW_HANDLE handle) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_mark_dirty_region_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_mark_dirty_region_v1; /* Autogenerated */ + + if (handle == nullptr) + return; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::pack(in, msgParent__IN_kodi_gui_window_mark_dirty_region_v1(PtrValue(handle))); + AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_mark_dirty_region_v1, in); + return; + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + auto_gen_group.kodi_gui_window_mark_dirty_region_v1(auto_gen_group.thisClassHdl, handle); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_button(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_button( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_button_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_button_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_window_get_control_button_v1(PtrValue(handle), control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_button_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_button_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_button_v1(auto_gen_group.thisClassHdl, handle, + control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_edit(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_edit( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_edit_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_edit_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_window_get_control_edit_v1(PtrValue(handle), control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_edit_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_edit_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_edit_v1(auto_gen_group.thisClassHdl, handle, + control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_fade_label(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_fade_label( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_fade_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_fade_label_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_window_get_control_fade_label_v1(PtrValue(handle), control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_fade_label_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_fade_label_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_fade_label_v1(auto_gen_group.thisClassHdl, + handle, control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_image(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_image( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_image_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_image_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_window_get_control_image_v1(PtrValue(handle), control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_image_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_image_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_image_v1(auto_gen_group.thisClassHdl, handle, + control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_label(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_label( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_label_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_label_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_window_get_control_label_v1(PtrValue(handle), control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_label_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_label_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_label_v1(auto_gen_group.thisClassHdl, handle, + control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_progress(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_progress( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_progress_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_progress_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_window_get_control_progress_v1(PtrValue(handle), control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_progress_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_progress_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_progress_v1(auto_gen_group.thisClassHdl, handle, + control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_radio_button(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_radio_button( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_radio_button_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_radio_button_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_control_radio_button_v1(PtrValue(handle), + control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_radio_button_v1, in, + out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_radio_button_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_radio_button_v1(auto_gen_group.thisClassHdl, + handle, control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_render_addon(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_render_addon( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_render_addon_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_render_addon_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_control_render_addon_v1(PtrValue(handle), + control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_render_addon_v1, in, + out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_render_addon_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_render_addon_v1(auto_gen_group.thisClassHdl, + handle, control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_settings_slider(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_settings_slider( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_settings_slider_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_settings_slider_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_gui_window_get_control_settings_slider_v1(PtrValue(handle), + control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_settings_slider_v1, in, + out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_settings_slider_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_settings_slider_v1(auto_gen_group.thisClassHdl, + handle, control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_slider(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_slider( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_slider_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_slider_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_window_get_control_slider_v1(PtrValue(handle), control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_slider_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_slider_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_slider_v1(auto_gen_group.thisClassHdl, handle, + control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_spin(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_spin( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_spin_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_spin_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, + msgParent__IN_kodi_gui_window_get_control_spin_v1(PtrValue(handle), control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_spin_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_spin_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_spin_v1(auto_gen_group.thisClassHdl, handle, + control_id); +} + +ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE +kodi_gui_window_get_control_text_box(KODI_GUI_WINDOW_HANDLE handle, int control_id) +{ + // Original API call: ATTR_DLL_EXPORT KODI_GUI_CONTROL_HANDLE kodi_gui_window_get_control_text_box( KODI_GUI_WINDOW_HANDLE handle, int control_id) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_gui_window_get_control_text_box_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_gui_window_get_control_text_box_v1; /* Autogenerated */ + + if (handle == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack( + in, msgParent__IN_kodi_gui_window_get_control_text_box_v1(PtrValue(handle), control_id)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_gui_window_h, funcParent_kodi_gui_window_get_control_text_box_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_gui_window_get_control_text_box_v1 t = ident.get().as(); + + return reinterpret_cast(std::get<0>(t)); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.gui_window_h; + return auto_gen_group.kodi_gui_window_get_control_text_box_v1(auto_gen_group.thisClassHdl, handle, + control_id); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/gui/window.h b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/window.h new file mode 100644 index 0000000000000..739e0a3e0ad86 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/gui/window.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/gui/window.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_gui_window_h; +struct directFuncToKodi_gui_window_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_gui_window_h : public IMsgHdl +{ +public: + CHdl_kodi_gui_window_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_gui_window_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/monitor.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/monitor.cpp new file mode 100644 index 0000000000000..657b1cdf6325a --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/monitor.cpp @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "monitor.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_monitor_h::InitDirect(directFuncToAddon_monitor_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT bool kodi_monitor_wait_for_abort(double timeout) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_monitor_wait_for_abort(double timeout) __INTRODUCED_IN_KODI(1); + // Tuple in: /* NOTE: msgParent__IN_kodi_monitor_wait_for_abort - Override active to use inside dev-kit library only */ + // Tuple out: /* NOTE: msgParent_OUT_kodi_monitor_wait_for_abort - Override active to use inside dev-kit library only */ + + /*---AUTO_GEN_PARSE---*/ + + std::mutex mtx; + std::unique_lock lck(mtx); + AddonIfc::g_ifc->m_cv.wait_for(lck, std::chrono::duration(timeout)); + return AddonIfc::g_ifc->killCalled; + + /*---AUTO_GEN_PARSE---*/ +} + +ATTR_DLL_EXPORT bool kodi_monitor_abort_requested() +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_monitor_abort_requested() __INTRODUCED_IN_KODI(1); + // Tuple in: /* NOTE: msgParent__IN_kodi_monitor_abort_requested - Override active to use inside dev-kit library only */ + // Tuple out: /* NOTE: msgParent_OUT_kodi_monitor_abort_requested - Override active to use inside dev-kit library only */ + + /*---AUTO_GEN_PARSE---*/ + + return AddonIfc::g_ifc->killCalled; + + /*---AUTO_GEN_PARSE---*/ +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/monitor.h b/xbmc/addons/kodi-dev-kit/src/addon/api/monitor.h new file mode 100644 index 0000000000000..f7c5519559059 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/monitor.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/monitor.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_monitor_h; +struct directFuncToKodi_monitor_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_monitor_h : public IMsgHdl +{ +public: + CHdl_kodi_monitor_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_monitor_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/network.cpp b/xbmc/addons/kodi-dev-kit/src/addon/api/network.cpp new file mode 100644 index 0000000000000..0088a17ef3bc2 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/network.cpp @@ -0,0 +1,270 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#include "network.h" + +// Shared API +#include "src/shared/Instances.h" + +// Lib code +#include "core/addon_control.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +using namespace KODI::ADDONS::INTERFACE; +using namespace KODI_ADDON::INTERNAL; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +void CHdl_kodi_network_h::InitDirect(directFuncToAddon_network_h* ifcToAddon) +{ + ifcToAddon->thisClassHdl = this; +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +/* NOTE: unused (no functions from Kodi to addon here) */ + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + +ATTR_DLL_EXPORT bool kodi_network_wake_on_lan(const char* mac) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_network_wake_on_lan(const char* mac) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_wake_on_lan_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_wake_on_lan_v1; /* Autogenerated */ + + if (mac == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_network_wake_on_lan_v1(mac)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_network_h, funcParent_kodi_network_wake_on_lan_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_network_wake_on_lan_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.network_h; + return auto_gen_group.kodi_network_wake_on_lan_v1(auto_gen_group.thisClassHdl, mac); +} + +ATTR_DLL_EXPORT char* kodi_network_get_ip_address() +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_network_get_ip_address() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_get_ip_address_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_get_ip_address_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_network_h, funcParent_kodi_network_get_ip_address_v1, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_network_get_ip_address_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.network_h; + return auto_gen_group.kodi_network_get_ip_address_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT char* kodi_network_dns_lookup(const char* url, bool* ret) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_network_dns_lookup(const char* url, bool* ret) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_dns_lookup_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_dns_lookup_v1; /* Autogenerated */ + + if (url == nullptr || ret == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_network_dns_lookup_v1(url, *ret)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_network_h, funcParent_kodi_network_dns_lookup_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_network_dns_lookup_v1 t = ident.get().as(); + + *ret = std::get<1>(t); + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.network_h; + return auto_gen_group.kodi_network_dns_lookup_v1(auto_gen_group.thisClassHdl, url, ret); +} + +ATTR_DLL_EXPORT char* kodi_network_url_encode(const char* url) +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_network_url_encode(const char* url) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_url_encode_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_url_encode_v1; /* Autogenerated */ + + if (url == nullptr) + return nullptr; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_network_url_encode_v1(url)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_network_h, funcParent_kodi_network_url_encode_v1, in, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_network_url_encode_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.network_h; + return auto_gen_group.kodi_network_url_encode_v1(auto_gen_group.thisClassHdl, url); +} + +ATTR_DLL_EXPORT char* kodi_network_get_hostname() +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_network_get_hostname() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_get_hostname_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_get_hostname_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_network_h, funcParent_kodi_network_get_hostname_v1, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_network_get_hostname_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.network_h; + return auto_gen_group.kodi_network_get_hostname_v1(auto_gen_group.thisClassHdl); +} + +ATTR_DLL_EXPORT bool kodi_network_is_local_host(const char* hostname) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_network_is_local_host(const char* hostname) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_is_local_host_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_is_local_host_v1; /* Autogenerated */ + + if (hostname == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_network_is_local_host_v1(hostname)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_network_h, funcParent_kodi_network_is_local_host_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_network_is_local_host_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.network_h; + return auto_gen_group.kodi_network_is_local_host_v1(auto_gen_group.thisClassHdl, hostname); +} + +ATTR_DLL_EXPORT bool kodi_network_is_host_on_lan(const char* hostname, bool offLineCheck) +{ + // Original API call: ATTR_DLL_EXPORT bool kodi_network_is_host_on_lan(const char* hostname, bool offLineCheck) __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_is_host_on_lan_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_is_host_on_lan_v1; /* Autogenerated */ + + if (hostname == nullptr) + return false; + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_network_is_host_on_lan_v1(hostname, offLineCheck)); + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessage( + funcGroup_network_h, funcParent_kodi_network_is_host_on_lan_v1, in, out)) + return false; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_network_is_host_on_lan_v1 t = ident.get().as(); + + return std::get<0>(t); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.network_h; + return auto_gen_group.kodi_network_is_host_on_lan_v1(auto_gen_group.thisClassHdl, hostname, + offLineCheck); +} + +ATTR_DLL_EXPORT char* kodi_network_get_user_agent() +{ + // Original API call: ATTR_DLL_EXPORT char* kodi_network_get_user_agent() __INTRODUCED_IN_KODI(1); + // Tuple in: typedef std::tuple msgParent__IN_kodi_network_get_user_agent_v1; /* Autogenerated */ + // Tuple out: typedef std::tuple msgParent_OUT_kodi_network_get_user_agent_v1; /* Autogenerated */ + +#ifndef KODI_INHIBIT_SHARED + if (!AddonIfc::g_ifc->direct_used) + { + msgpack::sbuffer out; + if (!AddonIfc::g_ifc->control->GetThreadIfc()->SendMessageOnlyGetReturn( + funcGroup_network_h, funcParent_kodi_network_get_user_agent_v1, out)) + return nullptr; + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_network_get_user_agent_v1 t = ident.get().as(); + + return strdup(std::get<0>(t).c_str()); + } +#endif /* !KODI_INHIBIT_SHARED */ + + const auto& auto_gen_group = AddonIfc::g_ifc->direct->to_kodi.network_h; + return auto_gen_group.kodi_network_get_user_agent_v1(auto_gen_group.thisClassHdl); +} + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/api/network.h b/xbmc/addons/kodi-dev-kit/src/addon/api/network.h new file mode 100644 index 0000000000000..4d1b30b0f1232 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/api/network.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +/* File autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator/code_generator.py */ + +#pragma once + +#include "core/IMsgHdl.h" +#include "src/shared/api/network.h" + +/* Code below becomes on auto generation reused, hand edited parts should included here */ +/*---AUTO_GEN_PARSE---*/ +/*---AUTO_GEN_PARSE---*/ + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +struct directFuncToAddon_network_h; +struct directFuncToKodi_network_h; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class ATTR_DLL_LOCAL CHdl_kodi_network_h : public IMsgHdl +{ +public: + CHdl_kodi_network_h(AddonIfc* ifc) : IMsgHdl(ifc) {} + + void InitDirect(KODI::ADDONS::INTERFACE::directFuncToAddon_network_h* ifcToAddon); + + /* Code below becomes on auto generation reused, hand edited parts should included here */ + /*---AUTO_GEN_PARSE---*/ + /*---AUTO_GEN_PARSE---*/ +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/core/CMakeLists.txt new file mode 100644 index 0000000000000..7d4e5ff44aace --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/CMakeLists.txt @@ -0,0 +1,24 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + addon_control.cpp + addon_offscreen_render_base_linux.cpp + addon_offscreen_render_control.cpp + addon_offscreen_render_control_linux.cpp + addon_thread_control.cpp +) + +set(HEADERS + IMsgHdl.h + addon_control.h + addon_offscreen_render_base.h + addon_offscreen_render_base_linux.h + addon_offscreen_render_control.h + addon_offscreen_render_control_linux.h + addon_thread_control.h +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_core) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/IMsgHdl.h b/xbmc/addons/kodi-dev-kit/src/addon/core/IMsgHdl.h new file mode 100644 index 0000000000000..4944f8767f1d5 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/IMsgHdl.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "../../../src/shared/SharedGroups.h" +#include "../../../src/shared/api/addon_base.h" + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +struct AddonIfc; + +class ATTR_DLL_LOCAL IMsgHdl +{ +public: + IMsgHdl(AddonIfc* ifc) : m_ifc(ifc) {} + virtual ~IMsgHdl() = default; + + virtual bool HandleMessage(int funcGroup, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) + { + return false; + } + +protected: + AddonIfc* m_ifc; +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_control.cpp b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_control.cpp new file mode 100644 index 0000000000000..af93215d2345c --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_control.cpp @@ -0,0 +1,242 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "addon_control.h" + +#include "../../../include/kodi/tools/StringUtils.h" +#include "../../../src/shared/api/processor.h" + +/*---AUTO_GEN_PARSE---*/ +/* Code below autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator.py */ +#include "api/addon-instance/audiodecoder.h" +#include "api/addon-instance/audioencoder.h" +#include "api/addon-instance/game.h" +#include "api/addon-instance/imagedecoder.h" +#include "api/addon-instance/inputstream.h" +#include "api/addon-instance/peripheral.h" +#include "api/addon-instance/pvr.h" +#include "api/addon-instance/screensaver.h" +#include "api/addon-instance/vfs.h" +#include "api/addon-instance/videocodec.h" +#include "api/addon-instance/visualization.h" +#include "api/addon-instance/web.h" +#include "api/addon_base.h" +#include "api/gui/window.h" +/*---AUTO_GEN_PARSE---*/ + +#if defined(TARGET_LINUX) +#include "addon_offscreen_render_base_linux.h" +#else +#error Not supported OS target! +#endif + +using namespace KODI::ADDONS::INTERFACE; +using kodi::tools::StringUtils; +using KODI_ADDON::INTERNAL::AddonIfc; +using KODI_ADDON::INTERNAL::CAddonControl; +using KODI_ADDON::INTERNAL::CAddonThreadIfc; + +AddonIfc* AddonIfc::g_ifc = nullptr; + +CAddonControl::CAddonControl(AddonIfc* ifc) + : m_ifc(ifc), + m_mainThreadId(std::this_thread::get_id()), + m_mainThread(std::make_shared(0, this, ifc->viaMainThread)) +{ + /*---AUTO_GEN_PARSE---*/ + /* Code below autogenerated, see xbmc/addons/kodi-dev-kit/tools/code-generator.py */ + CHdl_kodi_addon_base_h* addon_base_h = new CHdl_kodi_addon_base_h(m_ifc); + m_handlers[funcGroup_addon_base_h] = addon_base_h; + CHdl_kodi_addoninstance_audiodecoder_h* addoninstance_audiodecoder_h = + new CHdl_kodi_addoninstance_audiodecoder_h(m_ifc); + m_handlers[funcGroup_addoninstance_audiodecoder_h] = addoninstance_audiodecoder_h; + CHdl_kodi_addoninstance_audioencoder_h* addoninstance_audioencoder_h = + new CHdl_kodi_addoninstance_audioencoder_h(m_ifc); + m_handlers[funcGroup_addoninstance_audioencoder_h] = addoninstance_audioencoder_h; + CHdl_kodi_addoninstance_game_h* addoninstance_game_h = new CHdl_kodi_addoninstance_game_h(m_ifc); + m_handlers[funcGroup_addoninstance_game_h] = addoninstance_game_h; + CHdl_kodi_addoninstance_imagedecoder_h* addoninstance_imagedecoder_h = + new CHdl_kodi_addoninstance_imagedecoder_h(m_ifc); + m_handlers[funcGroup_addoninstance_imagedecoder_h] = addoninstance_imagedecoder_h; + CHdl_kodi_addoninstance_inputstream_h* addoninstance_inputstream_h = + new CHdl_kodi_addoninstance_inputstream_h(m_ifc); + m_handlers[funcGroup_addoninstance_inputstream_h] = addoninstance_inputstream_h; + CHdl_kodi_addoninstance_peripheral_h* addoninstance_peripheral_h = + new CHdl_kodi_addoninstance_peripheral_h(m_ifc); + m_handlers[funcGroup_addoninstance_peripheral_h] = addoninstance_peripheral_h; + CHdl_kodi_addoninstance_pvr_h* addoninstance_pvr_h = new CHdl_kodi_addoninstance_pvr_h(m_ifc); + m_handlers[funcGroup_addoninstance_pvr_h] = addoninstance_pvr_h; + CHdl_kodi_addoninstance_screensaver_h* addoninstance_screensaver_h = + new CHdl_kodi_addoninstance_screensaver_h(m_ifc); + m_handlers[funcGroup_addoninstance_screensaver_h] = addoninstance_screensaver_h; + CHdl_kodi_addoninstance_vfs_h* addoninstance_vfs_h = new CHdl_kodi_addoninstance_vfs_h(m_ifc); + m_handlers[funcGroup_addoninstance_vfs_h] = addoninstance_vfs_h; + CHdl_kodi_addoninstance_videocodec_h* addoninstance_videocodec_h = + new CHdl_kodi_addoninstance_videocodec_h(m_ifc); + m_handlers[funcGroup_addoninstance_videocodec_h] = addoninstance_videocodec_h; + CHdl_kodi_addoninstance_visualization_h* addoninstance_visualization_h = + new CHdl_kodi_addoninstance_visualization_h(m_ifc); + m_handlers[funcGroup_addoninstance_visualization_h] = addoninstance_visualization_h; + CHdl_kodi_addoninstance_web_h* addoninstance_web_h = new CHdl_kodi_addoninstance_web_h(m_ifc); + m_handlers[funcGroup_addoninstance_web_h] = addoninstance_web_h; + CHdl_kodi_gui_window_h* gui_window_h = new CHdl_kodi_gui_window_h(m_ifc); + m_handlers[funcGroup_gui_window_h] = gui_window_h; + + if (m_ifc->direct != nullptr) + { + addon_base_h->InitDirect(&m_ifc->direct->to_addon.addon_base_h); + addoninstance_audiodecoder_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_audiodecoder_h); + addoninstance_audioencoder_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_audioencoder_h); + addoninstance_game_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_game_h); + addoninstance_imagedecoder_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_imagedecoder_h); + addoninstance_inputstream_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_inputstream_h); + addoninstance_peripheral_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_peripheral_h); + addoninstance_pvr_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_pvr_h); + addoninstance_screensaver_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_screensaver_h); + addoninstance_vfs_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_vfs_h); + addoninstance_videocodec_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_videocodec_h); + addoninstance_visualization_h->InitDirect( + &m_ifc->direct->to_addon.addoninstance_visualization_h); + addoninstance_web_h->InitDirect(&m_ifc->direct->to_addon.addoninstance_web_h); + gui_window_h->InitDirect(&m_ifc->direct->to_addon.gui_window_h); + } + /*---AUTO_GEN_PARSE---*/ + + if (m_ifc->direct != nullptr) + { + m_ifc->direct->to_addon.processor_h.thisClassHdl = this; + m_ifc->direct->to_addon.processor_h.kodi_kill_child = kodi_kill_child; + } +} + +CAddonControl::~CAddonControl() +{ + for (auto& handler : m_handlers) + { + delete handler; + } +} + +bool CAddonControl::Create() +{ + m_stackTrace.load_here(32); + + if (!m_mainThread->Create()) + return false; + + return true; +} + +std::shared_ptr CAddonControl::GetThreadIfc() +{ + const std::thread::id threadId = std::this_thread::get_id(); + + if (m_mainThreadId == threadId) + { + return m_mainThread; + } + + std::unique_lock lock(m_mutex); + + auto it = std::find_if(m_runningSubThreads.begin(), m_runningSubThreads.end(), + [](std::shared_ptr entry) { return !entry->Active(); }); + if (it == m_runningSubThreads.end()) + { + msgpack::sbuffer in; + msgpack::sbuffer out; + msgpack::pack(in, msgParent__IN_kodi_processor_CreateForNewThread(m_mainThread->GetID())); + m_mainThread->SendMessage(funcGroup_Main, kodi_processor_CreateForNewThread, in, out); + msgpack::unpacked ident = msgpack::unpack(out.data(), out.size()); + msgParent_OUT_kodi_processor_CreateForNewThread t = ident.get().as(); + const std::string identifier = std::get<0>(t); + + auto newIfc = std::make_shared(std::get<1>(t), this, false); + if (!newIfc->Create()) + { + return nullptr; + } + m_runningSubThreads.emplace(newIfc); + return newIfc; + } + + return *it; +} + +bool CAddonControl::ProcessOutside() +{ + return GetThreadIfc()->ProcessOutside(); +} + +bool CAddonControl::FuncCall(int group, + int func, + const msgpack::unpacked& in, + msgpack::sbuffer& out) +{ + if (group == funcGroup_Main) + { + switch (func) + { + case kodi_processor_KillChild: + { + msgChild__IN_kodi_processor_KillChild t = in.get().as(); + if (m_ifc->identifier != std::get<0>(t)) + { + fprintf(stderr, "FATAL: Addon called with invalid identifier to kill!\n"); + } + + m_ifc->killCalled = true; + m_ifc->m_cv.notify_all(); + // False return here stops the related thread process. + return false; + } + default: + break; + } + + return false; + } + + if (m_handlers[group]) + return m_handlers[group]->HandleMessage(group, func, in, out); + + fprintf(stderr, "FATAL: Addon called with invalid group %i!\n", group); + return false; +} + +void CAddonControl::kodi_kill_child(void* thisClassHdl, const char* uuid) +{ + auto thisClass = reinterpret_cast(thisClassHdl); + if (thisClass == nullptr) + return; + + if (thisClass->m_ifc->identifier != uuid) + { + fprintf(stderr, "FATAL: Addon called with invalid identifier to kill!\n"); + } + + thisClass->m_ifc->killCalled = true; + thisClass->m_ifc->m_cv.notify_all(); + thisClass->m_mainThread->DestroyReceiver(); +} + +std::shared_ptr CAddonControl::GetOffscreenRenderBase() +{ +#if defined(TARGET_LINUX) + if (!m_offsceenRenderBase) + { + m_offsceenRenderBase = std::make_shared(); + if (!m_offsceenRenderBase->Create()) + fprintf(stderr, "FATAL: Failed to create offscreen rendering base class!\n"); + } + + return m_offsceenRenderBase; + +#else + return nullptr; +#endif +} diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_control.h b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_control.h new file mode 100644 index 0000000000000..d05f35f0d5ab8 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_control.h @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "../../../include/kodi/c-api/addon_base.h" +#include "../../shared/DirectData.h" +#include "../../shared/Instances.h" +#define BACKWARD_HAS_DW 1 +#include "../third_party/backward-cpp/backward.hpp" +#include "IMsgHdl.h" +#include "addon_thread_control.h" + +#include +#include +#include +#include +#include +#include +#include + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class CAddonControl; +class IOffsceenRenderBase; + +struct ATTR_DLL_LOCAL AddonIfc +{ + unsigned int api; + std::string identifier; + std::unique_ptr control{nullptr}; + bool viaMainThread{false}; + bool noReceive{false}; + bool killCalled{false}; + KODI::ADDONS::INTERFACE::UnionAddonFunctions functions{}; + std::condition_variable m_cv; + + // Data for case addon used without shared mem, not as independent app and direct to Kodi + KODI::ADDONS::INTERFACE::DirectAddonIfc* direct{nullptr}; + bool direct_used{false}; + + // Handle where contains first instance handle pointer in Kodi for addons where accessed + // by Kodi, e.g. PVR. + // This always set with first used instace pointer in Kodi, but only be used by C++ API and + // if CAddonBase and IAddonInstance in same child. + // On other addons where works itself, e.g. service or video addon, is it unused and 0. + // KODI_ADDON_INSTANCE_INFO* kodiFirstInstance{nullptr}; + + static AddonIfc* g_ifc; +}; + +class ATTR_DLL_LOCAL CAddonControl +{ +public: + CAddonControl(AddonIfc* ifc); + ~CAddonControl(); + + bool Create(); + std::shared_ptr GetThreadIfc(); + bool ProcessOutside(); + bool FuncCall(int group, int func, const msgpack::unpacked& in, msgpack::sbuffer& out); + + const std::string& GetUUID() const { return m_ifc->identifier; } + + std::shared_ptr GetOffscreenRenderBase(); + +private: + AddonIfc* const m_ifc; + + const std::thread::id m_mainThreadId; + const std::shared_ptr m_mainThread; + std::set> m_runningSubThreads; + std::set> m_unusedThreads; + std::array m_handlers{nullptr}; + + std::shared_ptr m_offsceenRenderBase; + + std::mutex m_mutex; + + static void kodi_kill_child(void* thisClassHdl, const char* uuid); + + backward::StackTrace m_stackTrace; + backward::SignalHandling m_signalHandling; +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_base.h b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_base.h new file mode 100644 index 0000000000000..443fc4c3bdbf8 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_base.h @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class IOffsceenRenderBase +{ +public: + IOffsceenRenderBase() = default; + virtual ~IOffsceenRenderBase() = default; + + virtual bool Create() = 0; + virtual void Destroy() = 0; +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_base_linux.cpp b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_base_linux.cpp new file mode 100644 index 0000000000000..14f50195ea54f --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_base_linux.cpp @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "addon_offscreen_render_base_linux.h" +#include + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +bool COffsceenRenderBaseLinux::Create() +{ + if (m_started) + return true; + + m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); + + // initialize the EGL display connection + EGLint major, minor; + eglInitialize(m_eglDisplay, &major, &minor); + + // Set OpenGL rendering API + eglBindAPI(EGL_OPENGL_API); + + EGLint num_config; + const EGLint attribute_list_config[] = { + EGL_SURFACE_TYPE, + EGL_PBUFFER_BIT, + EGL_RENDERABLE_TYPE, + EGL_OPENGL_BIT, + EGL_RED_SIZE, + 1, + EGL_GREEN_SIZE, + 1, + EGL_BLUE_SIZE, + 1, + EGL_ALPHA_SIZE, + 1, + EGL_NONE, + }; + + eglChooseConfig(m_eglDisplay, attribute_list_config, &m_eglConfig, 1, &num_config); + + // create an EGL rendering context + const EGLint attrib_list[] = {EGL_CONTEXT_MAJOR_VERSION_KHR, + 3, + EGL_CONTEXT_MINOR_VERSION_KHR, + 2, + EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, + EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR, + EGL_NONE}; + m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, attrib_list); + + m_started = true; + + return true; +} + +void COffsceenRenderBaseLinux::Destroy() +{ + if (!m_started) + return; + + eglDestroyContext(m_eglDisplay, m_eglContext); + eglTerminate(m_eglDisplay); + + m_eglDisplay = EGL_NO_DISPLAY; + m_eglConfig = EGL_NO_CONFIG_KHR; + m_eglContext = EGL_NO_CONTEXT; + m_started = false; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_base_linux.h b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_base_linux.h new file mode 100644 index 0000000000000..01ba7fe5b7167 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_base_linux.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "addon_offscreen_render_base.h" + +#define EGL_EGLEXT_PROTOTYPES +#include +#include + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class COffsceenRenderBaseLinux : public IOffsceenRenderBase +{ +public: + COffsceenRenderBaseLinux() = default; + + bool Create() override; + void Destroy() override; + + EGLDisplay GetEGLDisplay() { return m_eglDisplay; } + EGLConfig GetEGLConfig() { return m_eglConfig; } + EGLContext GetEGLContext() { return m_eglContext; } + +private: + bool m_started = false; + + EGLDisplay m_eglDisplay = EGL_NO_DISPLAY; + EGLConfig m_eglConfig = EGL_NO_CONFIG_KHR; + EGLContext m_eglContext = EGL_NO_CONTEXT; +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ + + diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control.cpp b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control.cpp new file mode 100644 index 0000000000000..50b2963983e7d --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control.cpp @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "addon_offscreen_render_control.h" +#include "addon_offscreen_render_control_linux.h" + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +IAddonOffscreenRenderControl* GenerateOffscreenControl(KODI::ADDONS::INTERFACE::PtrKodiOffscreen kodiOffsetHdl, + uint64_t renderId, + int x, + int y, + int width, + int height, + ADDON_HARDWARE_CONTEXT context) +{ + CAddonOffscreenRenderControlLinux* control = new CAddonOffscreenRenderControlLinux(kodiOffsetHdl, renderId, x, y, width, height, context); + return control; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control.h b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control.h new file mode 100644 index 0000000000000..768d0d31903ed --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "../../../include/kodi/c-api/addon_base.h" +#include "../../shared/SharedGroups.h" + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class IAddonOffscreenRenderControl +{ +public: + IAddonOffscreenRenderControl(KODI::ADDONS::INTERFACE::PtrKodiOffscreen kodiOffsetHdl, + uint64_t renderId, + int x, + int y, + int width, + int height, + ADDON_HARDWARE_CONTEXT context) + : m_kodiOffsetHdl(kodiOffsetHdl), + m_renderId(renderId), + m_x(x), + m_y(y), + m_width(width), + m_height(height), + m_context(context) + { + + } + virtual ~IAddonOffscreenRenderControl() = default; + + virtual bool Start() = 0; + virtual void Stop() = 0; + virtual void RenderBegin() = 0; + virtual void RenderEnd() = 0; + + const KODI::ADDONS::INTERFACE::PtrKodiOffscreen m_kodiOffsetHdl; + const uint64_t m_renderId; + const int m_x; + const int m_y; + const int m_width; + const int m_height; + const ADDON_HARDWARE_CONTEXT m_context; +}; + +IAddonOffscreenRenderControl* GenerateOffscreenControl(KODI::ADDONS::INTERFACE::PtrKodiOffscreen kodiOffsetHdl, + uint64_t renderId, + int x, + int y, + int width, + int height, + ADDON_HARDWARE_CONTEXT context); + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control_linux.cpp b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control_linux.cpp new file mode 100644 index 0000000000000..eceb435b89a5d --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control_linux.cpp @@ -0,0 +1,211 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "addon_offscreen_render_control_linux.h" + +#include "addon_control.h" +#include "addon_offscreen_render_base_linux.h" +#include "../../../src/shared/OpenGLExtensionCheck.h" +#include "../../../src/shared/socket.h" +#include "../../../include/kodi/tools/StringUtils.h" + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +CAddonOffscreenRenderControlLinux::CAddonOffscreenRenderControlLinux(KODI::ADDONS::INTERFACE::PtrKodiOffscreen kodiOffsetHdl, + uint64_t renderId, + int x, + int y, + int width, + int height, + ADDON_HARDWARE_CONTEXT context) + : IAddonOffscreenRenderControl(kodiOffsetHdl, renderId, x, y, width, height, context), + m_socketServerFile(kodi::tools::StringUtils::Format("/tmp/%s-%04i-renderproc", AddonIfc::g_ifc->identifier.c_str(), renderId)), + m_socketClientFile(kodi::tools::StringUtils::Format("/tmp/%s-%04i-renderview", AddonIfc::g_ifc->identifier.c_str(), renderId)), + m_renderBase(std::dynamic_pointer_cast(AddonIfc::g_ifc->control->GetOffscreenRenderBase())) +{ +} + +bool CAddonOffscreenRenderControlLinux::Start() +{ + using namespace KODI::ADDONS::INTERFACE; + + m_eglDisplay = m_renderBase->GetEGLDisplay(); + m_eglContext = m_renderBase->GetEGLContext(); + + static const EGLint pbufferAttribs[] = { + EGL_WIDTH, 9, + EGL_HEIGHT, 9, + EGL_TEXTURE_TARGET, EGL_TEXTURE_2D, + EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, + EGL_NONE, + }; + + // create an EGL window surface + m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_renderBase->GetEGLConfig(), pbufferAttribs); + + // connect the context to the surface + eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext); + + glGenVertexArrays(1, &m_vertexVAO); + glBindVertexArray(m_vertexVAO); + + if (!CheckExtensionSupported("EGL_KHR_image_base")) + { + kodi_log(ADDON_LOG_ERROR, "Needed EGL extension \"EGL_KHR_image_base\" not available"); + return false; + } + + if (!CheckExtensionSupported("EGL_MESA_image_dma_buf_export")) + { + kodi_log(ADDON_LOG_ERROR, + "Needed EGL extension \"EGL_MESA_image_dma_buf_export\" not available"); + return false; + } + + eglCreateImageKHR = (decltype(eglCreateImageKHR))GetEGLFunc("eglCreateImageKHR"); + eglDestroyImageKHR = (decltype(eglDestroyImageKHR))GetEGLFunc("eglDestroyImageKHR"); + eglExportDMABUFImageQueryMESA = (decltype(eglExportDMABUFImageQueryMESA))GetEGLFunc( + "eglExportDMABUFImageQueryMESA"); + eglExportDMABUFImageMESA = + (decltype(eglExportDMABUFImageMESA))GetEGLFunc("eglExportDMABUFImageMESA"); + + // GL: Create and populate the texture + glGenTextures(1, &m_texture); + glBindTexture(GL_TEXTURE_2D, m_texture); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glPixelStorei(GL_UNPACK_ROW_LENGTH, m_width); + glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); + + static const EGLint attrib[] = {EGL_IMAGE_PRESERVED_KHR, EGL_FALSE, EGL_GL_TEXTURE_LEVEL_KHR, 0, + EGL_NONE}; + + // EGL: Create EGL image from the GL texture + m_eglImage = eglCreateImageKHR(m_eglDisplay, m_eglContext, EGL_GL_TEXTURE_2D_KHR, + reinterpret_cast(m_texture), attrib); + if (m_eglImage == EGL_NO_IMAGE) + { + kodi_log(ADDON_LOG_ERROR, "Failed to get EGL image (ERROR: %i)", eglGetError()); + return false; + } + + // The next line works around an issue in radeonsi driver (fixed in master at the time of writing). If you are + // not having problems with texture rendering until the first texture update you can omit this line + glFinish(); + + EGLBoolean queried = eglExportDMABUFImageQueryMESA( + m_eglDisplay, m_eglImage, &m_textureStorageMetadata.fourcc, + &m_textureStorageMetadata.num_planes, &m_textureStorageMetadata.modifiers); + if (!queried) + { + kodi_log(ADDON_LOG_ERROR, "Failed to export DMABUF image query"); + return false; + } + + EGLBoolean exported = eglExportDMABUFImageMESA(m_eglDisplay, m_eglImage, &m_textureDmaBufFd, + &m_textureStorageMetadata.stride, &m_textureStorageMetadata.offset); + if (!exported) + { + kodi_log(ADDON_LOG_ERROR, "Failed to export DMABUF image"); + return false; + } + + eglDestroyImageKHR(m_eglDisplay, m_eglImage); + + m_textureStorageMetadata.width = m_width; + m_textureStorageMetadata.height = m_height; + + glGenFramebuffers(1, &m_framebuffer); + glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); + //Attach 2D texture to this FBO + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0); + + glGenRenderbuffers(1, &m_renderbuffer); + glBindRenderbuffer(GL_RENDERBUFFER, m_renderbuffer); + glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, m_width, m_height); + + //Attach depth buffer to FBO + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_renderbuffer); + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + glBindTexture(GL_TEXTURE_2D, 0); + + glScissor(0, 0, m_width, m_height); + glViewport(0, 0, m_width, m_height); + + // Unix Domain Socket: Send file descriptor (texture_dmabuf_fd) and texture storage data (texture_storage_metadata) + m_socket = create_socket(m_socketServerFile.c_str()); + std::thread thread = std::thread([&] { + while (m_socket >= 0 && connect_socket(m_socket, m_socketClientFile.c_str()) != 0) + ; + write_fd(m_socket, m_textureDmaBufFd, &m_textureStorageMetadata, + sizeof(m_textureStorageMetadata)); + close(m_socket); + m_socket = -1; + close(m_textureDmaBufFd); + m_textureDmaBufFd = -1; + }); + + thread.detach(); + + return true; +} + +void CAddonOffscreenRenderControlLinux::Stop() +{ + if (m_socket >= 0) + { + int socket = m_socket; + m_socket = -1; + close(socket); + if (m_textureDmaBufFd >= 0) + { + m_textureDmaBufFd = -1; + close(m_textureDmaBufFd); + } + } + + glBindRenderbuffer(GL_RENDERBUFFER, 0); + glDeleteRenderbuffers(1, &m_renderbuffer); + m_renderbuffer = 0; + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + glDeleteFramebuffers(1, &m_framebuffer); + m_framebuffer = 0; + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, 0); + glDeleteTextures(1, &m_texture); + m_texture = 0; + + glDeleteVertexArrays(1, &m_vertexVAO); + m_vertexVAO = 0; +} + +void CAddonOffscreenRenderControlLinux::RenderBegin() +{ + eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext); + glBindVertexArray(m_vertexVAO); + glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); +} + +void CAddonOffscreenRenderControlLinux::RenderEnd() +{ + glFlush(); +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control_linux.h b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control_linux.h new file mode 100644 index 0000000000000..7e9b3735ace39 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_offscreen_render_control_linux.h @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2005-2022 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "addon_offscreen_render_control.h" +#include "../../../src/shared/SharedGL.h" + +#include +#include + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class COffsceenRenderBaseLinux; + +class CAddonOffscreenRenderControlLinux : public IAddonOffscreenRenderControl +{ +public: + CAddonOffscreenRenderControlLinux(KODI::ADDONS::INTERFACE::PtrKodiOffscreen kodiOffsetHdl, + uint64_t renderId, + int x, + int y, + int width, + int height, + ADDON_HARDWARE_CONTEXT context); + virtual ~CAddonOffscreenRenderControlLinux() = default; + + bool Start() override; + void Stop() override; + void RenderBegin() override; + void RenderEnd() override; + +private: + const std::string m_socketServerFile; + const std::string m_socketClientFile; + + PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR = nullptr; + PFNEGLDESTROYIMAGEKHRPROC eglDestroyImageKHR = nullptr; + PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC eglExportDMABUFImageQueryMESA = nullptr; + PFNEGLEXPORTDMABUFIMAGEMESAPROC eglExportDMABUFImageMESA = nullptr; + + EGLSurface m_eglSurface = EGL_NO_SURFACE; + EGLDisplay m_eglDisplay = EGL_NO_DISPLAY; + EGLContext m_eglContext = EGL_NO_CONTEXT; + EGLImageKHR m_eglImage = EGL_NO_IMAGE_KHR; + EGLConfig m_eglConfig = EGL_NO_CONFIG_KHR; + + // EGL (extension: EGL_MESA_image_dma_buf_export): Get file descriptor (texture_dmabuf_fd) for the EGL image and get its + // storage data (texture_storage_metadata - fourcc, stride, offset) + int m_socket = -1; + int m_textureDmaBufFd = -1; + struct texture_storage_metadata_t m_textureStorageMetadata; + + GLuint m_texture = 0; + GLuint m_framebuffer = 0; + GLuint m_renderbuffer = 0; + + GLuint m_vertexVAO = 0; + + std::shared_ptr m_renderBase; +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_thread_control.cpp b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_thread_control.cpp new file mode 100644 index 0000000000000..6e5859259f4dd --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_thread_control.cpp @@ -0,0 +1,119 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "addon_thread_control.h" + +#include "../../../include/kodi/tools/StringUtils.h" +#include "../../shared/ShareProcessReceiver.h" +#include "../../shared/ShareProcessTransmitter.h" +#include "addon_control.h" + +using kodi::tools::StringUtils; +using namespace KODI::ADDONS::INTERFACE; + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +CAddonThreadIfc::CAddonThreadIfc(int64_t identifier, CAddonControl* process, bool processOutside) + : m_mainThread(identifier == 0), + m_identifier(identifier), + m_id(StringUtils::Format("%s-ifc-%05i", process->GetUUID().c_str(), m_identifier)), + m_processOutside(processOutside), + m_process(process) +{ + m_shareProcessReceiver = new CShareProcessReceiver(m_id + "-srvchl", m_mainThread); + m_shareProcessTransmitter = new CShareProcessTransmitter(m_id + "-chlsrv", m_mainThread); + + fprintf(stderr, "DEBUG: Started thread class with id '%s'\n", m_id.c_str()); +} + +CAddonThreadIfc::~CAddonThreadIfc() +{ + Destroy(); + delete m_shareProcessReceiver; + delete m_shareProcessTransmitter; +} + +bool CAddonThreadIfc::Create() +{ + if (!m_shareProcessTransmitter->Create(false)) + { + fprintf(stderr, + "FATAL: Failed to create shared process memory from addon to Kodi (id '%s') (Last " + "error: %s)\n", + m_id.c_str(), m_shareProcessTransmitter->GetLastErrorText().c_str()); + return false; + } + + if (!m_shareProcessReceiver->Create(false, !m_processOutside)) + { + fprintf(stderr, + "FATAL: Failed to create shared process memory from Kodi to addon (id '%s') (Last " + "error: %s)\n", + m_id.c_str(), m_shareProcessReceiver->GetLastErrorText().c_str()); + return false; + } + + m_shareProcessReceiver->RegisterReceiver(std::bind(&CAddonControl::FuncCall, m_process, + std::placeholders::_1, std::placeholders::_2, + std::placeholders::_3, std::placeholders::_4)); + + return true; +} + +void CAddonThreadIfc::Destroy() +{ + m_shareProcessTransmitter->Destroy(); + m_shareProcessReceiver->Destroy(); +} + +void CAddonThreadIfc::DestroyReceiver() +{ + m_shareProcessReceiver->Destroy(); +} + +bool CAddonThreadIfc::SendMessage(int group, int func) +{ + return m_shareProcessTransmitter->SendMessage(group, func); +} + +bool CAddonThreadIfc::SendMessage(int group, int func, const msgpack::sbuffer& in) +{ + return m_shareProcessTransmitter->SendMessage(group, func, in); +} + +bool CAddonThreadIfc::SendMessage(int group, + int func, + const msgpack::sbuffer& in, + msgpack::sbuffer& ret) +{ + return m_shareProcessTransmitter->SendMessage(group, func, in, ret); +} + +bool CAddonThreadIfc::SendMessageOnlyGetReturn(int group, int func, msgpack::sbuffer& ret) +{ + return m_shareProcessTransmitter->SendMessageOnlyGetReturn(group, func, ret); +} + +bool CAddonThreadIfc::ProcessOutside() +{ + if (!m_processOutside) + return false; + + return m_shareProcessReceiver->ProcessOutside(); +} + +bool CAddonThreadIfc::Active() const +{ + return m_shareProcessTransmitter->m_active || m_shareProcessReceiver->m_active; +} + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/core/addon_thread_control.h b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_thread_control.h new file mode 100644 index 0000000000000..fb2e1d264f1f2 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/core/addon_thread_control.h @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2005-2020 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "../../../include/kodi/c-api/addon_base.h" +#include "../../../src/shared/SharedData.h" + +#include +#include +#include + +namespace KODI +{ +namespace ADDONS +{ +namespace INTERFACE +{ + +class CShareProcessReceiver; +class CShareProcessTransmitter; + +} /* namespace INTERFACE */ +} /* namespace ADDONS */ +} /* namespace KODI */ + +namespace KODI_ADDON +{ +namespace INTERNAL +{ + +class CAddonControl; + +class ATTR_DLL_LOCAL CAddonThreadIfc +{ +public: + CAddonThreadIfc(int64_t identifier, CAddonControl* process, bool processOutside); + ~CAddonThreadIfc(); + + bool Create(); + void Destroy(); + void DestroyReceiver(); + + bool SendMessage(int group, int func); + bool SendMessage(int group, int func, const msgpack::sbuffer& in); + bool SendMessage(int group, int func, const msgpack::sbuffer& in, msgpack::sbuffer& ret); + bool SendMessageOnlyGetReturn(int group, int func, msgpack::sbuffer& ret); + + bool ProcessOutside(); + + bool Active() const; + const std::string& GetID() const { return m_id; } + +private: + const bool m_mainThread; + const int64_t m_identifier; + const std::string m_id; + const bool m_processOutside; + CAddonControl* const m_process; + + int64_t m_pid{-1}; + KODI::ADDONS::INTERFACE::CShareProcessReceiver* m_shareProcessReceiver{nullptr}; + KODI::ADDONS::INTERFACE::CShareProcessTransmitter* m_shareProcessTransmitter{nullptr}; +}; + +} /* namespace INTERNAL */ +} /* namespace KODI_ADDON */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/third_party/CMakeLists.txt new file mode 100644 index 0000000000000..9f61e09641281 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/CMakeLists.txt @@ -0,0 +1,12 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES +) + +set(HEADERS +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_third_party) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/BackwardConfig.cmake b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/BackwardConfig.cmake new file mode 100644 index 0000000000000..867dab9c7f80c --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/BackwardConfig.cmake @@ -0,0 +1,266 @@ +# +# BackwardMacros.cmake +# Copyright 2013 Google Inc. All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +############################################################################### +# OPTIONS +############################################################################### + +set(STACK_WALKING_UNWIND TRUE) +set(STACK_WALKING_UNWIND TRUE CACHE BOOL + "Use compiler's unwind API") +set(STACK_WALKING_BACKTRACE FALSE CACHE BOOL + "Use backtrace from (e)glibc for stack walking") +set(STACK_WALKING_LIBUNWIND FALSE CACHE BOOL + "Use libunwind for stack walking") + +set(STACK_DETAILS_AUTO_DETECT TRUE CACHE BOOL + "Auto detect backward's stack details dependencies") + +set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE CACHE BOOL + "Use backtrace from (e)glibc for symbols resolution") +set(STACK_DETAILS_DW FALSE CACHE BOOL + "Use libdw to read debug info") +set(STACK_DETAILS_BFD FALSE CACHE BOOL + "Use libbfd to read debug info") +set(STACK_DETAILS_DWARF FALSE CACHE BOOL + "Use libdwarf/libelf to read debug info") + +if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND NOT DEFINED BACKWARD_TESTS) + # If this is a top level CMake project, we most lixely want the tests + set(BACKWARD_TESTS ON CACHE BOOL "Enable tests") +else() + set(BACKWARD_TESTS OFF CACHE BOOL "Enable tests") +endif() +############################################################################### +# CONFIGS +############################################################################### +include(FindPackageHandleStandardArgs) + +if (STACK_WALKING_LIBUNWIND) + # libunwind works on the macOS without having to add special include + # paths or libraries + if (NOT APPLE) + find_path(LIBUNWIND_INCLUDE_DIR NAMES "libunwind.h") + find_library(LIBUNWIND_LIBRARY unwind) + + if (LIBUNWIND_LIBRARY) + include(CheckSymbolExists) + check_symbol_exists(UNW_INIT_SIGNAL_FRAME libunwind.h HAVE_UNW_INIT_SIGNAL_FRAME) + if (NOT HAVE_UNW_INIT_SIGNAL_FRAME) + message(STATUS "libunwind does not support unwinding from signal handler frames") + endif() + endif() + + set(LIBUNWIND_INCLUDE_DIRS ${LIBUNWIND_INCLUDE_DIR}) + set(LIBDWARF_LIBRARIES ${LIBUNWIND_LIBRARY}) + find_package_handle_standard_args(libunwind DEFAULT_MSG + LIBUNWIND_LIBRARY LIBUNWIND_INCLUDE_DIR) + mark_as_advanced(LIBUNWIND_INCLUDE_DIR LIBUNWIND_LIBRARY) + list(APPEND _BACKWARD_LIBRARIES ${LIBUNWIND_LIBRARY}) + endif() + + # Disable other unwinders if libunwind is found + set(STACK_WALKING_UNWIND FALSE) + set(STACK_WALKING_BACKTRACE FALSE) +endif() + +if (${STACK_DETAILS_AUTO_DETECT}) + if(NOT CMAKE_VERSION VERSION_LESS 3.17) + set(_name_mismatched_arg NAME_MISMATCHED) + endif() + # find libdw + find_path(LIBDW_INCLUDE_DIR NAMES "elfutils/libdw.h" "elfutils/libdwfl.h") + find_library(LIBDW_LIBRARY dw) + # in case it's statically linked, look for all the possible dependencies + find_library(LIBELF_LIBRARY elf) + find_library(LIBPTHREAD_LIBRARY pthread) + find_library(LIBZ_LIBRARY z) + find_library(LIBBZ2_LIBRARY bz2) + find_library(LIBLZMA_LIBRARY lzma) + find_library(LIBZSTD_LIBRARY zstd) + set(LIBDW_INCLUDE_DIRS ${LIBDW_INCLUDE_DIR} ) + set(LIBDW_LIBRARIES ${LIBDW_LIBRARY} + $<$:${LIBELF_LIBRARY}> + $<$:${LIBPTHREAD_LIBRARY}> + $<$:${LIBZ_LIBRARY}> + $<$:${LIBBZ2_LIBRARY}> + $<$:${LIBLZMA_LIBRARY}> + $<$:${LIBZSTD_LIBRARY}>) + find_package_handle_standard_args(libdw ${_name_mismatched_arg} + REQUIRED_VARS LIBDW_LIBRARY LIBDW_INCLUDE_DIR) + mark_as_advanced(LIBDW_INCLUDE_DIR LIBDW_LIBRARY) + + # find libbfd + find_path(LIBBFD_INCLUDE_DIR NAMES "bfd.h") + find_path(LIBDL_INCLUDE_DIR NAMES "dlfcn.h") + find_library(LIBBFD_LIBRARY bfd) + find_library(LIBDL_LIBRARY dl) + set(LIBBFD_INCLUDE_DIRS ${LIBBFD_INCLUDE_DIR} ${LIBDL_INCLUDE_DIR}) + set(LIBBFD_LIBRARIES ${LIBBFD_LIBRARY} ${LIBDL_LIBRARY}) + find_package_handle_standard_args(libbfd ${_name_mismatched_arg} + REQUIRED_VARS LIBBFD_LIBRARY LIBBFD_INCLUDE_DIR + LIBDL_LIBRARY LIBDL_INCLUDE_DIR) + mark_as_advanced(LIBBFD_INCLUDE_DIR LIBBFD_LIBRARY + LIBDL_INCLUDE_DIR LIBDL_LIBRARY) + + # find libdwarf + find_path(LIBDWARF_INCLUDE_DIR NAMES "libdwarf.h" PATH_SUFFIXES libdwarf) + find_path(LIBELF_INCLUDE_DIR NAMES "libelf.h") + find_path(LIBDL_INCLUDE_DIR NAMES "dlfcn.h") + find_library(LIBDWARF_LIBRARY dwarf) + find_library(LIBELF_LIBRARY elf) + find_library(LIBDL_LIBRARY dl) + set(LIBDWARF_INCLUDE_DIRS ${LIBDWARF_INCLUDE_DIR} ${LIBELF_INCLUDE_DIR} ${LIBDL_INCLUDE_DIR}) + set(LIBDWARF_LIBRARIES ${LIBDWARF_LIBRARY} ${LIBELF_LIBRARY} ${LIBDL_LIBRARY}) + find_package_handle_standard_args(libdwarf ${_name_mismatched_arg} + REQUIRED_VARS LIBDWARF_LIBRARY LIBDWARF_INCLUDE_DIR + LIBELF_LIBRARY LIBELF_INCLUDE_DIR + LIBDL_LIBRARY LIBDL_INCLUDE_DIR) + mark_as_advanced(LIBDWARF_INCLUDE_DIR LIBDWARF_LIBRARY + LIBELF_INCLUDE_DIR LIBELF_LIBRARY + LIBDL_INCLUDE_DIR LIBDL_LIBRARY) + + if (LIBDW_FOUND) + LIST(APPEND _BACKWARD_INCLUDE_DIRS ${LIBDW_INCLUDE_DIRS}) + LIST(APPEND _BACKWARD_LIBRARIES ${LIBDW_LIBRARIES}) + set(STACK_DETAILS_DW TRUE) + set(STACK_DETAILS_BFD FALSE) + set(STACK_DETAILS_DWARF FALSE) + set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE) + elseif(LIBBFD_FOUND) + LIST(APPEND _BACKWARD_INCLUDE_DIRS ${LIBBFD_INCLUDE_DIRS}) + LIST(APPEND _BACKWARD_LIBRARIES ${LIBBFD_LIBRARIES}) + + # If we attempt to link against static bfd, make sure to link its dependencies, too + get_filename_component(bfd_lib_ext "${LIBBFD_LIBRARY}" EXT) + if (bfd_lib_ext STREQUAL "${CMAKE_STATIC_LIBRARY_SUFFIX}") + list(APPEND _BACKWARD_LIBRARIES iberty z) + endif() + + set(STACK_DETAILS_DW FALSE) + set(STACK_DETAILS_BFD TRUE) + set(STACK_DETAILS_DWARF FALSE) + set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE) + elseif(LIBDWARF_FOUND) + LIST(APPEND _BACKWARD_INCLUDE_DIRS ${LIBDWARF_INCLUDE_DIRS}) + LIST(APPEND _BACKWARD_LIBRARIES ${LIBDWARF_LIBRARIES}) + + set(STACK_DETAILS_DW FALSE) + set(STACK_DETAILS_BFD FALSE) + set(STACK_DETAILS_DWARF TRUE) + set(STACK_DETAILS_BACKTRACE_SYMBOL FALSE) + else() + set(STACK_DETAILS_DW FALSE) + set(STACK_DETAILS_BFD FALSE) + set(STACK_DETAILS_DWARF FALSE) + set(STACK_DETAILS_BACKTRACE_SYMBOL TRUE) + endif() +else() + if (STACK_DETAILS_DW) + LIST(APPEND _BACKWARD_LIBRARIES dw) + endif() + + if (STACK_DETAILS_BFD) + LIST(APPEND _BACKWARD_LIBRARIES bfd dl) + endif() + + if (STACK_DETAILS_DWARF) + LIST(APPEND _BACKWARD_LIBRARIES dwarf elf) + endif() +endif() + +macro(map_definitions var_prefix define_prefix) + foreach(def ${ARGN}) + if (${${var_prefix}${def}}) + LIST(APPEND _BACKWARD_DEFINITIONS "${define_prefix}${def}=1") + else() + LIST(APPEND _BACKWARD_DEFINITIONS "${define_prefix}${def}=0") + endif() + endforeach() +endmacro() + +if (NOT _BACKWARD_DEFINITIONS) + map_definitions("STACK_WALKING_" "BACKWARD_HAS_" UNWIND LIBUNWIND BACKTRACE) + map_definitions("STACK_DETAILS_" "BACKWARD_HAS_" BACKTRACE_SYMBOL DW BFD DWARF) +endif() + +if(WIN32) + list(APPEND _BACKWARD_LIBRARIES dbghelp psapi) + if(MINGW) + set(MINGW_MSVCR_LIBRARY "msvcr90$<$:d>" CACHE STRING "Mingw MSVC runtime import library") + list(APPEND _BACKWARD_LIBRARIES ${MINGW_MSVCR_LIBRARY}) + endif() +endif() + +set(BACKWARD_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}") + +set(BACKWARD_HAS_EXTERNAL_LIBRARIES FALSE) +set(FIND_PACKAGE_REQUIRED_VARS BACKWARD_INCLUDE_DIR) +if(DEFINED _BACKWARD_LIBRARIES) + set(BACKWARD_HAS_EXTERNAL_LIBRARIES TRUE) + list(APPEND FIND_PACKAGE_REQUIRED_VARS _BACKWARD_LIBRARIES) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Backward + REQUIRED_VARS ${FIND_PACKAGE_REQUIRED_VARS} +) +list(APPEND _BACKWARD_INCLUDE_DIRS ${BACKWARD_INCLUDE_DIR}) + +# add_backward, optional bool argument; if passed and true, backward will be included as a system header +macro(add_backward target) + if ("${ARGN}") + target_include_directories(${target} SYSTEM PRIVATE ${BACKWARD_INCLUDE_DIRS}) + else() + target_include_directories(${target} PRIVATE ${BACKWARD_INCLUDE_DIRS}) + endif() + set_property(TARGET ${target} APPEND PROPERTY COMPILE_DEFINITIONS ${BACKWARD_DEFINITIONS}) + set_property(TARGET ${target} APPEND PROPERTY LINK_LIBRARIES ${BACKWARD_LIBRARIES}) +endmacro() + +set(BACKWARD_INCLUDE_DIRS ${_BACKWARD_INCLUDE_DIRS} CACHE INTERNAL "_BACKWARD_INCLUDE_DIRS") +set(BACKWARD_DEFINITIONS ${_BACKWARD_DEFINITIONS} CACHE INTERNAL "BACKWARD_DEFINITIONS") +set(BACKWARD_LIBRARIES ${_BACKWARD_LIBRARIES} CACHE INTERNAL "BACKWARD_LIBRARIES") +mark_as_advanced(BACKWARD_INCLUDE_DIRS BACKWARD_DEFINITIONS BACKWARD_LIBRARIES) + +# Expand each definition in BACKWARD_DEFINITIONS to its own cmake var and export +# to outer scope +foreach(var ${BACKWARD_DEFINITIONS}) + string(REPLACE "=" ";" var_as_list ${var}) + list(GET var_as_list 0 var_name) + list(GET var_as_list 1 var_value) + set(${var_name} ${var_value}) + mark_as_advanced(${var_name}) +endforeach() + +if (NOT TARGET Backward::Backward) + add_library(Backward::Backward INTERFACE IMPORTED) + set_target_properties(Backward::Backward PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${BACKWARD_INCLUDE_DIRS}" + INTERFACE_COMPILE_DEFINITIONS "${BACKWARD_DEFINITIONS}" + ) + if(BACKWARD_HAS_EXTERNAL_LIBRARIES) + set_target_properties(Backward::Backward PROPERTIES + INTERFACE_LINK_LIBRARIES "${BACKWARD_LIBRARIES}" + ) + endif() +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/CMakeLists.txt new file mode 100644 index 0000000000000..84dd2af077016 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/CMakeLists.txt @@ -0,0 +1,140 @@ +# +# CMakeLists.txt +# Copyright 2013 Google Inc. All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +cmake_minimum_required(VERSION 3.0) +project(backward CXX) + +# Introduce variables: +# * CMAKE_INSTALL_LIBDIR +# * CMAKE_INSTALL_BINDIR +# * CMAKE_INSTALL_INCLUDEDIR +include(GNUInstallDirs) + +include(BackwardConfig.cmake) + +# check if compiler is nvcc or nvcc_wrapper +set(COMPILER_IS_NVCC false) +get_filename_component(COMPILER_NAME ${CMAKE_CXX_COMPILER} NAME) +if (COMPILER_NAME MATCHES "^nvcc") + set(COMPILER_IS_NVCC true) +endif() + +if (DEFINED ENV{OMPI_CXX} OR DEFINED ENV{MPICH_CXX}) + if ( ($ENV{OMPI_CXX} MATCHES "nvcc") OR ($ENV{MPICH_CXX} MATCHES "nvcc") ) + set(COMPILER_IS_NVCC true) + endif() +endif() + +# set CXX standard +set(CMAKE_CXX_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) # Kodi Note: Changed from 11 to 17 +if (${COMPILER_IS_NVCC}) + # GNU CXX extensions are not supported by nvcc + set(CMAKE_CXX_EXTENSIONS OFF) +endif() + +############################################################################### +# COMPILER FLAGS +############################################################################### + +if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_COMPILER_IS_GNUCXX) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra") + if (NOT ${COMPILER_IS_NVCC}) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic-errors") + endif() + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") +endif() + +############################################################################### +# BACKWARD OBJECT +############################################################################### + +add_library(backward_object OBJECT backward.cpp) +target_compile_definitions(backward_object PRIVATE ${BACKWARD_DEFINITIONS}) +target_include_directories(backward_object PRIVATE ${BACKWARD_INCLUDE_DIRS}) +set_target_properties(backward_object PROPERTIES POSITION_INDEPENDENT_CODE ON) +set(BACKWARD_ENABLE $ CACHE STRING + "Link with this object to setup backward automatically") + + +############################################################################### +# BACKWARD LIBRARY (Includes backward.cpp) +############################################################################### +option(BACKWARD_SHARED "Build dynamic backward-cpp shared lib" OFF) + +if(BACKWARD_SHARED) + set(libtype SHARED) +endif() +add_library(backward ${libtype} backward.cpp) +target_compile_definitions(backward PUBLIC ${BACKWARD_DEFINITIONS}) +target_include_directories(backward PUBLIC ${BACKWARD_INCLUDE_DIRS}) + +############################################################################### +# TESTS +############################################################################### + +if(BACKWARD_TESTS) + enable_testing() + + add_library(test_main OBJECT test/_test_main.cpp) + + macro(backward_add_test src) + get_filename_component(name ${src} NAME_WE) + set(test_name "test_${name}") + + add_executable(${test_name} ${src} ${ARGN} $) + + target_link_libraries(${test_name} PRIVATE Backward::Backward) + + add_test(NAME ${name} COMMAND ${test_name}) + endmacro() + + # Tests without backward.cpp + set(TESTS + test + stacktrace + rectrace + select_signals + ) + + foreach(test ${TESTS}) + backward_add_test(test/${test}.cpp) + endforeach() + + # Tests with backward.cpp + set(TESTS + suicide + ) + + foreach(test ${TESTS}) + backward_add_test(test/${test}.cpp ${BACKWARD_ENABLE}) + endforeach() +endif() + +install( + FILES "backward.hpp" + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} +) +install( + FILES "BackwardConfig.cmake" + DESTINATION ${CMAKE_INSTALL_LIBDIR}/backward +) diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/LICENSE.txt b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/LICENSE.txt new file mode 100644 index 0000000000000..269e8abbc0ffc --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/LICENSE.txt @@ -0,0 +1,21 @@ +Copyright 2013 Google Inc. All Rights Reserved. + +The MIT License (MIT) + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/README.md b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/README.md new file mode 100644 index 0000000000000..031716f3da9fe --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/README.md @@ -0,0 +1,442 @@ +Backward-cpp [![badge](https://img.shields.io/badge/conan.io-backward%2F1.3.0-green.svg?logo=data:image/png;base64%2CiVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAMAAAAolt3jAAAA1VBMVEUAAABhlctjlstkl8tlmMtlmMxlmcxmmcxnmsxpnMxpnM1qnc1sn85voM91oM11oc1xotB2oc56pNF6pNJ2ptJ8ptJ8ptN9ptN8p9N5qNJ9p9N9p9R8qtOBqdSAqtOAqtR%2BrNSCrNJ/rdWDrNWCsNWCsNaJs9eLs9iRvNuVvdyVv9yXwd2Zwt6axN6dxt%2Bfx%2BChyeGiyuGjyuCjyuGly%2BGlzOKmzOGozuKoz%2BKqz%2BOq0OOv1OWw1OWw1eWx1eWy1uay1%2Baz1%2Baz1%2Bez2Oe02Oe12ee22ujUGwH3AAAAAXRSTlMAQObYZgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAACxMAAAsTAQCanBgAAAAHdElNRQfgBQkREyOxFIh/AAAAiklEQVQI12NgAAMbOwY4sLZ2NtQ1coVKWNvoc/Eq8XDr2wB5Ig62ekza9vaOqpK2TpoMzOxaFtwqZua2Bm4makIM7OzMAjoaCqYuxooSUqJALjs7o4yVpbowvzSUy87KqSwmxQfnsrPISyFzWeWAXCkpMaBVIC4bmCsOdgiUKwh3JojLgAQ4ZCE0AMm2D29tZwe6AAAAAElFTkSuQmCC)](http://www.conan.io/source/backward/1.3.0/Manu343726/testing) +============ + +Backward is a beautiful stack trace pretty printer for C++. + +If you are bored to see this: + +![default trace](doc/rude.png) + +Backward will spice it up for you: + +![pretty stackstrace](doc/pretty.png) + +There is not much to say. Of course it will be able to display the code +snippets only if the source files are accessible (else see trace #4 in the +example). + +All "Source" lines and code snippet prefixed by a pipe "|" are frames inline +the next frame. +You can see that for the trace #1 in the example, the function +`you_shall_not_pass()` was inlined in the function `...read2::do_test()` by the +compiler. + +## Installation + +#### Install backward.hpp + +Backward is a header only library. So installing Backward is easy, simply drop +a copy of `backward.hpp` along with your other source files in your C++ project. +You can also use a git submodule or really any other way that best fits your +environment, as long as you can include `backward.hpp`. + +#### Install backward.cpp + +If you want Backward to automatically print a stack trace on most common fatal +errors (segfault, abort, un-handled exception...), simply add a copy of +`backward.cpp` to your project, and don't forget to tell your build system. + +The code in `backward.cpp` is trivial anyway, you can simply copy what it's +doing at your convenience. + +Note for [folly](https://github.com/facebook/folly) library users: must define `backward::SignalHandling sh;` after `folly::init(&argc, &argv);`. + +## Configuration & Dependencies + +### Integration with CMake + +If you are using CMake and want to use its configuration abilities to save +you the trouble, you can easily integrate Backward, depending on how you obtained +the library. + +#### As a subdirectory: + +In this case you have a subdirectory containing the whole repository of Backward +(eg.: using git-submodules), in this case you can do: + +``` +add_subdirectory(/path/to/backward-cpp) + +# This will add backward.cpp to your target +add_executable(mytarget mysource.cpp ${BACKWARD_ENABLE}) + +# This will add libraries, definitions and include directories needed by backward +# by setting each property on the target. +add_backward(mytarget) +``` + +#### Modifying CMAKE_MODULE_PATH + +In this case you can have Backward installed as a subdirectory: + +``` +list(APPEND CMAKE_MODULE_PATH /path/to/backward-cpp) +find_package(Backward) + +# This will add libraries, definitions and include directories needed by backward +# through an IMPORTED target. +target_link_libraries(mytarget PUBLIC Backward::Backward) +``` + +Notice that this is equivalent to using the the approach that uses `add_subdirectory()`, +however it uses cmake's [imported target](https://cmake.org/Wiki/CMake/Tutorials/Exporting_and_Importing_Targets) mechanism. + +#### Installation through a regular package manager + +In this case you have obtained Backward through a package manager. + +Packages currently available: +- [conda-forge](https://anaconda.org/conda-forge/backward-cpp) + +``` +find_package(Backward) + +# This will add libraries, definitions and include directories needed by backward +# through an IMPORTED target. +target_link_libraries(mytarget PUBLIC Backward::Backward) +``` +### Libraries to unwind the stack + +On Linux and macOS, backtrace can back-trace or "walk" the stack using the +following libraries: + +#### unwind + +Unwind comes from libgcc, but there is an equivalent inside clang itself. With +unwind, the stacktrace is as accurate as it can possibly be, since this is +used by the C++ runtine in gcc/clang for stack unwinding on exception. + +Normally libgcc is already linked to your program by default. + +#### libunwind from the [libunwind project](https://github.com/libunwind/libunwind) + + apt-get install binutils-dev (or equivalent) + +Libunwind provides, in some cases, a more accurate stacktrace as it knows +to decode signal handler frames and lets us edit the context registers when +unwinding, allowing stack traces over bad function references. + +For best results make sure you are using libunwind 1.3 or later, which added +`unw_init_local2` and support for handling signal frames. + +CMake will warn you when configuring if your libunwind version doesn't support +signal frames. + +On macOS clang provides a libunwind API compatible library as part of its +environment, so no third party libraries are necessary. + +### Compile with debug info + +You need to compile your project with generation of debug symbols enabled, +usually `-g` with clang++ and g++. + +Note that you can use `-g` with any level of optimization, with modern debug +information encoding like DWARF, it only takes space in the binary (it's not +loaded in memory until your debugger or Backward makes use of it, don't worry), +and it doesn't impact the code generation (at least on GNU/Linux x86\_64 for +what I know). + +If you are missing debug information, the stack trace will lack details about +your sources. + +### Libraries to read the debug info + +Backward supports pretty printed stack traces on GNU/Linux, macOS and Windows, +it will compile fine under other platforms but will not do anything. **Pull +requests are welcome :)** + +Also, by default you will get a really basic stack trace, based on the +`backtrace_symbols` API: + +![default trace](doc/nice.png) + +You will need to install some dependencies to get the ultimate stack trace. +Three libraries are currently supported, the only difference is which one is the +easiest for you to install, so pick your poison: + +#### libbfd from the [GNU/binutils](http://www.gnu.org/software/binutils/) + + apt-get install binutils-dev (or equivalent) + +And do not forget to link with the lib: `g++/clang++ -lbfd -ldl ...` + +This library requires dynamic loading. Which is provided by the library `dl`. +Hence why we also link with `-ldl`. + +Then define the following before every inclusion of `backward.hpp` (don't +forget to update `backward.cpp` as well): + + #define BACKWARD_HAS_BFD 1 + +#### libdw from the [elfutils](https://fedorahosted.org/elfutils/) + + apt-get install libdw-dev (or equivalent) + +And do not forget to link with the lib and inform Backward to use it: + + #define BACKWARD_HAS_DW 1 + +Of course you can simply add the define (`-DBACKWARD_HAS_...=1`) and the +linkage details in your build system and even auto-detect which library is +installed, it's up to you. + +#### [libdwarf](https://sourceforge.net/projects/libdwarf/) and [libelf](http://www.mr511.de/software/english.html) + + apt-get install libdwarf-dev (or equivalent) + +And do not forget to link with the lib and inform Backward to use it: + + #define BACKWARD_HAS_DWARF 1 + +There are several alternative implementations of libdwarf and libelf that +are API compatible so it's possible, although it hasn't been tested, to +replace the ones used when developing backward (in bold, below): + +* **_libelf_** by [Michael "Tired" Riepe](http://www.mr511.de/software/english.html) +* **_libdwarf_** by [David Anderson](https://www.prevanders.net/dwarf.html) +* libelf from [elfutils](https://fedorahosted.org/elfutils/) +* libelf and libdwarf from FreeBSD's [ELF Tool Chain](https://sourceforge.net/p/elftoolchain/wiki/Home/) project + + +Of course you can simply add the define (`-DBACKWARD_HAS_...=1`) and the +linkage details in your build system and even auto-detect which library is +installed, it's up to you. + +That's it, you are all set, you should be getting nice stack traces like the +one at the beginning of this document. + +## API + +If you don't want to limit yourself to the defaults offered by `backward.cpp`, +and you want to take some random stack traces for whatever reason and pretty +print them the way you love or you decide to send them all to your buddies over +the Internet, you will appreciate the simplicity of Backward's API. + +### Stacktrace + +The StackTrace class lets you take a "snapshot" of the current stack. +You can use it like this: + +```c++ +using namespace backward; +StackTrace st; st.load_here(32); +Printer p; p.print(st); +``` + +The public methods are: + +```c++ +class StackTrace { public: + // Take a snapshot of the current stack, with at most "trace_cnt_max" + // traces in it. The first trace is the most recent (ie the current + // frame). You can also provide a trace address to load_from() assuming + // the address is a valid stack frame (useful for signal handling traces). + // Both function return size(). + size_t load_here(size_t trace_cnt_max) + size_t load_from(void* address, size_t trace_cnt_max) + + // The number of traces loaded. This can be less than "trace_cnt_max". + size_t size() const + + // A unique id for the thread in which the trace was taken. The value + // 0 means the stack trace comes from the main thread. + size_t thread_id() const + + // Retrieve a trace by index. 0 is the most recent trace, size()-1 is + // the oldest one. + Trace operator[](size_t trace_idx) +}; +``` + +### TraceResolver + +The `TraceResolver` does the heavy lifting, and intends to transform a simple +`Trace` from its address into a fully detailed `ResolvedTrace` with the +filename of the source, line numbers, inlined functions and so on. + +You can use it like this: + +```c++ +using namespace backward; +StackTrace st; st.load_here(32); + +TraceResolver tr; tr.load_stacktrace(st); +for (size_t i = 0; i < st.size(); ++i) { + ResolvedTrace trace = tr.resolve(st[i]); + std::cout << "#" << i + << " " << trace.object_filename + << " " << trace.object_function + << " [" << trace.addr << "]" + << std::endl; +} +``` + +The public methods are: + +```c++ +class TraceResolver { public: + // Pre-load whatever is necessary from the stack trace. + template + void load_stacktrace(ST&) + + // Resolve a trace. It takes a ResolvedTrace, because a `Trace` is + // implicitly convertible to it. + ResolvedTrace resolve(ResolvedTrace t) +}; +``` + +### SnippetFactory + +The SnippetFactory is a simple helper class to automatically load and cache +source files in order to extract code snippets. + +```c++ +class SnippetFactory { public: + // A snippet is a list of line numbers and line contents. + typedef std::vector > lines_t; + + // Return a snippet starting at line_start with up to context_size lines. + lines_t get_snippet(const std::string& filename, + size_t line_start, size_t context_size) + + // Return a combined snippet from two different locations and combine them. + // context_size / 2 lines will be extracted from each location. + lines_t get_combined_snippet( + const std::string& filename_a, size_t line_a, + const std::string& filename_b, size_t line_b, + size_t context_size) + + // Tries to return a unified snippet if the two locations from the same + // file are close enough to fit inside one context_size, else returns + // the equivalent of get_combined_snippet(). + lines_t get_coalesced_snippet(const std::string& filename, + size_t line_a, size_t line_b, size_t context_size) +``` + +### Printer + +A simpler way to pretty print a stack trace to the terminal. It will +automatically resolve the traces for you: + +```c++ +using namespace backward; +StackTrace st; st.load_here(32); +Printer p; +p.object = true; +p.color_mode = ColorMode::always; +p.address = true; +p.print(st, stderr); +``` + +You can set a few options: + +```c++ +class Printer { public: + // Print a little snippet of code if possible. + bool snippet = true; + + // Colorize the trace + // - ColorMode::automatic: Activate colors if possible. For example, when using a TTY on linux. + // - ColorMode::always: Always use colors. + // - ColorMode::never: Never use colors. + bool color_mode = ColorMode::automatic; + + // Add the addresses of every source location to the trace. + bool address = false; + + // Even if there is a source location, also prints the object + // from where the trace came from. + bool object = false; + + // Resolve and print a stack trace to the given C FILE* object. + // On linux, if the FILE* object is attached to a TTY, + // color will be used if color_mode is set to automatic. + template + FILE* print(StackTrace& st, FILE* fp = stderr); + + // Resolve and print a stack trace to the given std::ostream object. + // Color will only be used if color_mode is set to always. + template + std::ostream& print(ST& st, std::ostream& os); +``` + + +### SignalHandling + +A simple helper class that registers for you the most common signals and other +callbacks to segfault, hardware exception, un-handled exception etc. + +`backward.cpp` simply uses it like that: + +```c++ +backward::SignalHandling sh; +``` + +Creating the object registers all the different signals and hooks. Destroying +this object doesn't do anything. It exposes only one method: + +```c++ +bool loaded() const // true if loaded with success +``` + +### Trace object + +To keep the memory footprint of a loaded `StackTrace` on the low-side, there a +hierarchy of trace object, from a minimal `Trace `to a `ResolvedTrace`. + +#### Simple trace + +```c++ +struct Trace { + void* addr; // address of the trace + size_t idx; // its index (0 == most recent) +}; +``` + +#### Resolved trace + +A `ResolvedTrace` should contains a maximum of details about the location of +the trace in the source code. Note that not all fields might be set. + +```c++ +struct ResolvedTrace: public Trace { + + struct SourceLoc { + std::string function; + std::string filename; + size_t line; + size_t col; + }; + + // In which binary object this trace is located. + std::string object_filename; + + // The function in the object that contains the trace. This is not the same + // as source.function which can be an function inlined in object_function. + std::string object_function; + + // The source location of this trace. It is possible for filename to be + // empty and for line/col to be invalid (value 0) if this information + // couldn't be deduced, for example if there is no debug information in the + // binary object. + SourceLoc source; + + // An optional list of "inliners". All of these sources locations where + // inlined in the source location of the trace (the attribute right above). + // This is especially useful when you compile with optimizations turned on. + typedef std::vector source_locs_t; + source_locs_t inliners; +}; +``` + +## Contact and copyright + +François-Xavier Bourlet + +Copyright 2013-2017 Google Inc. All Rights Reserved. +MIT License. + +### Disclaimer + +Although this project is owned by Google Inc. this is not a Google supported or +affiliated project. diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/backward.cpp b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/backward.cpp new file mode 100644 index 0000000000000..110441cba92c2 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/backward.cpp @@ -0,0 +1,42 @@ +// Pick your poison. +// +// On GNU/Linux, you have few choices to get the most out of your stack trace. +// +// By default you get: +// - object filename +// - function name +// +// In order to add: +// - source filename +// - line and column numbers +// - source code snippet (assuming the file is accessible) + +// Install one of the following libraries then uncomment one of the macro (or +// better, add the detection of the lib and the macro definition in your build +// system) + +// - apt-get install libdw-dev ... +// - g++/clang++ -ldw ... +// #define BACKWARD_HAS_DW 1 + +// - apt-get install binutils-dev ... +// - g++/clang++ -lbfd ... +// #define BACKWARD_HAS_BFD 1 + +// - apt-get install libdwarf-dev ... +// - g++/clang++ -ldwarf ... +// #define BACKWARD_HAS_DWARF 1 + +// Regardless of the library you choose to read the debug information, +// for potentially more detailed stack traces you can use libunwind +// - apt-get install libunwind-dev +// - g++/clang++ -lunwind +// #define BACKWARD_HAS_LIBUNWIND 1 + +#include "backward.hpp" + +namespace backward { + +backward::SignalHandling sh; + +} // namespace backward diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/backward.hpp b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/backward.hpp new file mode 100644 index 0000000000000..19d5ba31c4b36 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/backward.hpp @@ -0,0 +1,4471 @@ +/* + * backward.hpp + * Copyright 2013 Google Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef H_6B9572DA_A64B_49E6_B234_051480991C89 +#define H_6B9572DA_A64B_49E6_B234_051480991C89 + +#ifndef __cplusplus +#error "It's not going to compile without a C++ compiler..." +#endif + +#if defined(BACKWARD_CXX11) +#elif defined(BACKWARD_CXX98) +#else +#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800) +#define BACKWARD_CXX11 +#define BACKWARD_ATLEAST_CXX11 +#define BACKWARD_ATLEAST_CXX98 +#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) +#define BACKWARD_ATLEAST_CXX17 +#endif +#else +#define BACKWARD_CXX98 +#define BACKWARD_ATLEAST_CXX98 +#endif +#endif + +// You can define one of the following (or leave it to the auto-detection): +// +// #define BACKWARD_SYSTEM_LINUX +// - specialization for linux +// +// #define BACKWARD_SYSTEM_DARWIN +// - specialization for Mac OS X 10.5 and later. +// +// #define BACKWARD_SYSTEM_WINDOWS +// - specialization for Windows (Clang 9 and MSVC2017) +// +// #define BACKWARD_SYSTEM_UNKNOWN +// - placebo implementation, does nothing. +// +#if defined(BACKWARD_SYSTEM_LINUX) +#elif defined(BACKWARD_SYSTEM_DARWIN) +#elif defined(BACKWARD_SYSTEM_UNKNOWN) +#elif defined(BACKWARD_SYSTEM_WINDOWS) +#else +#if defined(__linux) || defined(__linux__) +#define BACKWARD_SYSTEM_LINUX +#elif defined(__APPLE__) +#define BACKWARD_SYSTEM_DARWIN +#elif defined(_WIN32) +#define BACKWARD_SYSTEM_WINDOWS +#else +#define BACKWARD_SYSTEM_UNKNOWN +#endif +#endif + +#define NOINLINE __attribute__((noinline)) + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(BACKWARD_SYSTEM_LINUX) + +// On linux, backtrace can back-trace or "walk" the stack using the following +// libraries: +// +// #define BACKWARD_HAS_UNWIND 1 +// - unwind comes from libgcc, but I saw an equivalent inside clang itself. +// - with unwind, the stacktrace is as accurate as it can possibly be, since +// this is used by the C++ runtine in gcc/clang for stack unwinding on +// exception. +// - normally libgcc is already linked to your program by default. +// +// #define BACKWARD_HAS_LIBUNWIND 1 +// - libunwind provides, in some cases, a more accurate stacktrace as it knows +// to decode signal handler frames and lets us edit the context registers when +// unwinding, allowing stack traces over bad function references. +// +// #define BACKWARD_HAS_BACKTRACE == 1 +// - backtrace seems to be a little bit more portable than libunwind, but on +// linux, it uses unwind anyway, but abstract away a tiny information that is +// sadly really important in order to get perfectly accurate stack traces. +// - backtrace is part of the (e)glib library. +// +// The default is: +// #define BACKWARD_HAS_UNWIND == 1 +// +// Note that only one of the define should be set to 1 at a time. +// +#if BACKWARD_HAS_UNWIND == 1 +#elif BACKWARD_HAS_LIBUNWIND == 1 +#elif BACKWARD_HAS_BACKTRACE == 1 +#else +#undef BACKWARD_HAS_UNWIND +#define BACKWARD_HAS_UNWIND 1 +#undef BACKWARD_HAS_LIBUNWIND +#define BACKWARD_HAS_LIBUNWIND 0 +#undef BACKWARD_HAS_BACKTRACE +#define BACKWARD_HAS_BACKTRACE 0 +#endif + +// On linux, backward can extract detailed information about a stack trace +// using one of the following libraries: +// +// #define BACKWARD_HAS_DW 1 +// - libdw gives you the most juicy details out of your stack traces: +// - object filename +// - function name +// - source filename +// - line and column numbers +// - source code snippet (assuming the file is accessible) +// - variable names (if not optimized out) +// - variable values (not supported by backward-cpp) +// - You need to link with the lib "dw": +// - apt-get install libdw-dev +// - g++/clang++ -ldw ... +// +// #define BACKWARD_HAS_BFD 1 +// - With libbfd, you get a fair amount of details: +// - object filename +// - function name +// - source filename +// - line numbers +// - source code snippet (assuming the file is accessible) +// - You need to link with the lib "bfd": +// - apt-get install binutils-dev +// - g++/clang++ -lbfd ... +// +// #define BACKWARD_HAS_DWARF 1 +// - libdwarf gives you the most juicy details out of your stack traces: +// - object filename +// - function name +// - source filename +// - line and column numbers +// - source code snippet (assuming the file is accessible) +// - variable names (if not optimized out) +// - variable values (not supported by backward-cpp) +// - You need to link with the lib "dwarf": +// - apt-get install libdwarf-dev +// - g++/clang++ -ldwarf ... +// +// #define BACKWARD_HAS_BACKTRACE_SYMBOL 1 +// - backtrace provides minimal details for a stack trace: +// - object filename +// - function name +// - backtrace is part of the (e)glib library. +// +// The default is: +// #define BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +// +// Note that only one of the define should be set to 1 at a time. +// +#if BACKWARD_HAS_DW == 1 +#elif BACKWARD_HAS_BFD == 1 +#elif BACKWARD_HAS_DWARF == 1 +#elif BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +#else +#undef BACKWARD_HAS_DW +#define BACKWARD_HAS_DW 0 +#undef BACKWARD_HAS_BFD +#define BACKWARD_HAS_BFD 0 +#undef BACKWARD_HAS_DWARF +#define BACKWARD_HAS_DWARF 0 +#undef BACKWARD_HAS_BACKTRACE_SYMBOL +#define BACKWARD_HAS_BACKTRACE_SYMBOL 1 +#endif + +#include +#include +#ifdef __ANDROID__ +// Old Android API levels define _Unwind_Ptr in both link.h and +// unwind.h Rename the one in link.h as we are not going to be using +// it +#define _Unwind_Ptr _Unwind_Ptr_Custom +#include +#undef _Unwind_Ptr +#else +#include +#endif +#if defined(__ppc__) || defined(__powerpc) || defined(__powerpc__) || \ + defined(__POWERPC__) +// Linux kernel header required for the struct pt_regs definition +// to access the NIP (Next Instruction Pointer) register value +#include +#endif +#include +#include +#include +#include + +#if BACKWARD_HAS_BFD == 1 +// NOTE: defining PACKAGE{,_VERSION} is required before including +// bfd.h on some platforms, see also: +// https://sourceware.org/bugzilla/show_bug.cgi?id=14243 +#ifndef PACKAGE +#define PACKAGE +#endif +#ifndef PACKAGE_VERSION +#define PACKAGE_VERSION +#endif +#include +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#include +#undef _GNU_SOURCE +#else +#include +#endif +#endif + +#if BACKWARD_HAS_DW == 1 +#include +#include +#include +#endif + +#if BACKWARD_HAS_DWARF == 1 +#include +#include +#include +#include +#include +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#include +#undef _GNU_SOURCE +#else +#include +#endif +#endif + +#if (BACKWARD_HAS_BACKTRACE == 1) || (BACKWARD_HAS_BACKTRACE_SYMBOL == 1) +// then we shall rely on backtrace +#include +#endif + +#endif // defined(BACKWARD_SYSTEM_LINUX) + +#if defined(BACKWARD_SYSTEM_DARWIN) +// On Darwin, backtrace can back-trace or "walk" the stack using the following +// libraries: +// +// #define BACKWARD_HAS_UNWIND 1 +// - unwind comes from libgcc, but I saw an equivalent inside clang itself. +// - with unwind, the stacktrace is as accurate as it can possibly be, since +// this is used by the C++ runtine in gcc/clang for stack unwinding on +// exception. +// - normally libgcc is already linked to your program by default. +// +// #define BACKWARD_HAS_LIBUNWIND 1 +// - libunwind comes from clang, which implements an API compatible version. +// - libunwind provides, in some cases, a more accurate stacktrace as it knows +// to decode signal handler frames and lets us edit the context registers when +// unwinding, allowing stack traces over bad function references. +// +// #define BACKWARD_HAS_BACKTRACE == 1 +// - backtrace is available by default, though it does not produce as much +// information as another library might. +// +// The default is: +// #define BACKWARD_HAS_UNWIND == 1 +// +// Note that only one of the define should be set to 1 at a time. +// +#if BACKWARD_HAS_UNWIND == 1 +#elif BACKWARD_HAS_BACKTRACE == 1 +#elif BACKWARD_HAS_LIBUNWIND == 1 +#else +#undef BACKWARD_HAS_UNWIND +#define BACKWARD_HAS_UNWIND 1 +#undef BACKWARD_HAS_BACKTRACE +#define BACKWARD_HAS_BACKTRACE 0 +#undef BACKWARD_HAS_LIBUNWIND +#define BACKWARD_HAS_LIBUNWIND 0 +#endif + +// On Darwin, backward can extract detailed information about a stack trace +// using one of the following libraries: +// +// #define BACKWARD_HAS_BACKTRACE_SYMBOL 1 +// - backtrace provides minimal details for a stack trace: +// - object filename +// - function name +// +// The default is: +// #define BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +// +#if BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +#else +#undef BACKWARD_HAS_BACKTRACE_SYMBOL +#define BACKWARD_HAS_BACKTRACE_SYMBOL 1 +#endif + +#include +#include +#include +#include +#include +#include + +#if (BACKWARD_HAS_BACKTRACE == 1) || (BACKWARD_HAS_BACKTRACE_SYMBOL == 1) +#include +#endif +#endif // defined(BACKWARD_SYSTEM_DARWIN) + +#if defined(BACKWARD_SYSTEM_WINDOWS) + +#include +#include +#include + +#include +typedef SSIZE_T ssize_t; + +#ifndef NOMINMAX +#define NOMINMAX +#endif +#include +#include + +#include +#include + +#ifndef __clang__ +#undef NOINLINE +#define NOINLINE __declspec(noinline) +#endif + +#ifdef _MSC_VER +#pragma comment(lib, "psapi.lib") +#pragma comment(lib, "dbghelp.lib") +#endif + +// Comment / packing is from stackoverflow: +// https://stackoverflow.com/questions/6205981/windows-c-stack-trace-from-a-running-app/28276227#28276227 +// Some versions of imagehlp.dll lack the proper packing directives themselves +// so we need to do it. +#pragma pack(push, before_imagehlp, 8) +#include +#pragma pack(pop, before_imagehlp) + +// TODO maybe these should be undefined somewhere else? +#undef BACKWARD_HAS_UNWIND +#undef BACKWARD_HAS_BACKTRACE +#if BACKWARD_HAS_PDB_SYMBOL == 1 +#else +#undef BACKWARD_HAS_PDB_SYMBOL +#define BACKWARD_HAS_PDB_SYMBOL 1 +#endif + +#endif + +#if BACKWARD_HAS_UNWIND == 1 + +#include +// while gcc's unwind.h defines something like that: +// extern _Unwind_Ptr _Unwind_GetIP (struct _Unwind_Context *); +// extern _Unwind_Ptr _Unwind_GetIPInfo (struct _Unwind_Context *, int *); +// +// clang's unwind.h defines something like this: +// uintptr_t _Unwind_GetIP(struct _Unwind_Context* __context); +// +// Even if the _Unwind_GetIPInfo can be linked to, it is not declared, worse we +// cannot just redeclare it because clang's unwind.h doesn't define _Unwind_Ptr +// anyway. +// +// Luckily we can play on the fact that the guard macros have a different name: +#ifdef __CLANG_UNWIND_H +// In fact, this function still comes from libgcc (on my different linux boxes, +// clang links against libgcc). +#include +extern "C" uintptr_t _Unwind_GetIPInfo(_Unwind_Context *, int *); +#endif + +#endif // BACKWARD_HAS_UNWIND == 1 + +#if BACKWARD_HAS_LIBUNWIND == 1 +#define UNW_LOCAL_ONLY +#include +#endif // BACKWARD_HAS_LIBUNWIND == 1 + +#ifdef BACKWARD_ATLEAST_CXX11 +#include +#include // for std::swap +namespace backward { +namespace details { +template struct hashtable { + typedef std::unordered_map type; +}; +using std::move; +} // namespace details +} // namespace backward +#else // NOT BACKWARD_ATLEAST_CXX11 +#define nullptr NULL +#define override +#include +namespace backward { +namespace details { +template struct hashtable { + typedef std::map type; +}; +template const T &move(const T &v) { return v; } +template T &move(T &v) { return v; } +} // namespace details +} // namespace backward +#endif // BACKWARD_ATLEAST_CXX11 + +namespace backward { +namespace details { +#if defined(BACKWARD_SYSTEM_WINDOWS) +const char kBackwardPathDelimiter[] = ";"; +#else +const char kBackwardPathDelimiter[] = ":"; +#endif +} // namespace details +} // namespace backward + +namespace backward { + +namespace system_tag { +struct linux_tag; // seems that I cannot call that "linux" because the name +// is already defined... so I am adding _tag everywhere. +struct darwin_tag; +struct windows_tag; +struct unknown_tag; + +#if defined(BACKWARD_SYSTEM_LINUX) +typedef linux_tag current_tag; +#elif defined(BACKWARD_SYSTEM_DARWIN) +typedef darwin_tag current_tag; +#elif defined(BACKWARD_SYSTEM_WINDOWS) +typedef windows_tag current_tag; +#elif defined(BACKWARD_SYSTEM_UNKNOWN) +typedef unknown_tag current_tag; +#else +#error "May I please get my system defines?" +#endif +} // namespace system_tag + +namespace trace_resolver_tag { +#if defined(BACKWARD_SYSTEM_LINUX) +struct libdw; +struct libbfd; +struct libdwarf; +struct backtrace_symbol; + +#if BACKWARD_HAS_DW == 1 +typedef libdw current; +#elif BACKWARD_HAS_BFD == 1 +typedef libbfd current; +#elif BACKWARD_HAS_DWARF == 1 +typedef libdwarf current; +#elif BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +typedef backtrace_symbol current; +#else +#error "You shall not pass, until you know what you want." +#endif +#elif defined(BACKWARD_SYSTEM_DARWIN) +struct backtrace_symbol; + +#if BACKWARD_HAS_BACKTRACE_SYMBOL == 1 +typedef backtrace_symbol current; +#else +#error "You shall not pass, until you know what you want." +#endif +#elif defined(BACKWARD_SYSTEM_WINDOWS) +struct pdb_symbol; +#if BACKWARD_HAS_PDB_SYMBOL == 1 +typedef pdb_symbol current; +#else +#error "You shall not pass, until you know what you want." +#endif +#endif +} // namespace trace_resolver_tag + +namespace details { + +template struct rm_ptr { typedef T type; }; + +template struct rm_ptr { typedef T type; }; + +template struct rm_ptr { typedef const T type; }; + +template struct deleter { + template void operator()(U &ptr) const { (*F)(ptr); } +}; + +template struct default_delete { + void operator()(T &ptr) const { delete ptr; } +}; + +template > +class handle { + struct dummy; + T _val; + bool _empty; + +#ifdef BACKWARD_ATLEAST_CXX11 + handle(const handle &) = delete; + handle &operator=(const handle &) = delete; +#endif + +public: + ~handle() { + if (!_empty) { + Deleter()(_val); + } + } + + explicit handle() : _val(), _empty(true) {} + explicit handle(T val) : _val(val), _empty(false) { + if (!_val) + _empty = true; + } + +#ifdef BACKWARD_ATLEAST_CXX11 + handle(handle &&from) : _empty(true) { swap(from); } + handle &operator=(handle &&from) { + swap(from); + return *this; + } +#else + explicit handle(const handle &from) : _empty(true) { + // some sort of poor man's move semantic. + swap(const_cast(from)); + } + handle &operator=(const handle &from) { + // some sort of poor man's move semantic. + swap(const_cast(from)); + return *this; + } +#endif + + void reset(T new_val) { + handle tmp(new_val); + swap(tmp); + } + + void update(T new_val) { + _val = new_val; + _empty = !static_cast(new_val); + } + + operator const dummy *() const { + if (_empty) { + return nullptr; + } + return reinterpret_cast(_val); + } + T get() { return _val; } + T release() { + _empty = true; + return _val; + } + void swap(handle &b) { + using std::swap; + swap(b._val, _val); // can throw, we are safe here. + swap(b._empty, _empty); // should not throw: if you cannot swap two + // bools without throwing... It's a lost cause anyway! + } + + T &operator->() { return _val; } + const T &operator->() const { return _val; } + + typedef typename rm_ptr::type &ref_t; + typedef const typename rm_ptr::type &const_ref_t; + ref_t operator*() { return *_val; } + const_ref_t operator*() const { return *_val; } + ref_t operator[](size_t idx) { return _val[idx]; } + + // Watch out, we've got a badass over here + T *operator&() { + _empty = false; + return &_val; + } +}; + +// Default demangler implementation (do nothing). +template struct demangler_impl { + static std::string demangle(const char *funcname) { return funcname; } +}; + +#if defined(BACKWARD_SYSTEM_LINUX) || defined(BACKWARD_SYSTEM_DARWIN) + +template <> struct demangler_impl { + demangler_impl() : _demangle_buffer_length(0) {} + + std::string demangle(const char *funcname) { + using namespace details; + char *result = abi::__cxa_demangle(funcname, _demangle_buffer.get(), + &_demangle_buffer_length, nullptr); + if (result) { + _demangle_buffer.update(result); + return result; + } + return funcname; + } + +private: + details::handle _demangle_buffer; + size_t _demangle_buffer_length; +}; + +#endif // BACKWARD_SYSTEM_LINUX || BACKWARD_SYSTEM_DARWIN + +struct demangler : public demangler_impl {}; + +// Split a string on the platform's PATH delimiter. Example: if delimiter +// is ":" then: +// "" --> [] +// ":" --> ["",""] +// "::" --> ["","",""] +// "/a/b/c" --> ["/a/b/c"] +// "/a/b/c:/d/e/f" --> ["/a/b/c","/d/e/f"] +// etc. +inline std::vector split_source_prefixes(const std::string &s) { + std::vector out; + size_t last = 0; + size_t next = 0; + size_t delimiter_size = sizeof(kBackwardPathDelimiter) - 1; + while ((next = s.find(kBackwardPathDelimiter, last)) != std::string::npos) { + out.push_back(s.substr(last, next - last)); + last = next + delimiter_size; + } + if (last <= s.length()) { + out.push_back(s.substr(last)); + } + return out; +} + +} // namespace details + +/*************** A TRACE ***************/ + +struct Trace { + void *addr; + size_t idx; + + Trace() : addr(nullptr), idx(0) {} + + explicit Trace(void *_addr, size_t _idx) : addr(_addr), idx(_idx) {} +}; + +struct ResolvedTrace : public Trace { + + struct SourceLoc { + std::string function; + std::string filename; + unsigned line; + unsigned col; + + SourceLoc() : line(0), col(0) {} + + bool operator==(const SourceLoc &b) const { + return function == b.function && filename == b.filename && + line == b.line && col == b.col; + } + + bool operator!=(const SourceLoc &b) const { return !(*this == b); } + }; + + // In which binary object this trace is located. + std::string object_filename; + + // The function in the object that contain the trace. This is not the same + // as source.function which can be an function inlined in object_function. + std::string object_function; + + // The source location of this trace. It is possible for filename to be + // empty and for line/col to be invalid (value 0) if this information + // couldn't be deduced, for example if there is no debug information in the + // binary object. + SourceLoc source; + + // An optionals list of "inliners". All the successive sources location + // from where the source location of the trace (the attribute right above) + // is inlined. It is especially useful when you compiled with optimization. + typedef std::vector source_locs_t; + source_locs_t inliners; + + ResolvedTrace() : Trace() {} + ResolvedTrace(const Trace &mini_trace) : Trace(mini_trace) {} +}; + +/*************** STACK TRACE ***************/ + +// default implemention. +template class StackTraceImpl { +public: + size_t size() const { return 0; } + Trace operator[](size_t) const { return Trace(); } + size_t load_here(size_t = 0) { return 0; } + size_t load_from(void *, size_t = 0, void * = nullptr, void * = nullptr) { + return 0; + } + size_t thread_id() const { return 0; } + void skip_n_firsts(size_t) {} +}; + +class StackTraceImplBase { +public: + StackTraceImplBase() + : _thread_id(0), _skip(0), _context(nullptr), _error_addr(nullptr) {} + + size_t thread_id() const { return _thread_id; } + + void skip_n_firsts(size_t n) { _skip = n; } + +protected: + void load_thread_info() { +#ifdef BACKWARD_SYSTEM_LINUX +#ifndef __ANDROID__ + _thread_id = static_cast(syscall(SYS_gettid)); +#else + _thread_id = static_cast(gettid()); +#endif + if (_thread_id == static_cast(getpid())) { + // If the thread is the main one, let's hide that. + // I like to keep little secret sometimes. + _thread_id = 0; + } +#elif defined(BACKWARD_SYSTEM_DARWIN) + _thread_id = reinterpret_cast(pthread_self()); + if (pthread_main_np() == 1) { + // If the thread is the main one, let's hide that. + _thread_id = 0; + } +#endif + } + + void set_context(void *context) { _context = context; } + void *context() const { return _context; } + + void set_error_addr(void *error_addr) { _error_addr = error_addr; } + void *error_addr() const { return _error_addr; } + + size_t skip_n_firsts() const { return _skip; } + +private: + size_t _thread_id; + size_t _skip; + void *_context; + void *_error_addr; +}; + +class StackTraceImplHolder : public StackTraceImplBase { +public: + size_t size() const { + return (_stacktrace.size() >= skip_n_firsts()) + ? _stacktrace.size() - skip_n_firsts() + : 0; + } + Trace operator[](size_t idx) const { + if (idx >= size()) { + return Trace(); + } + return Trace(_stacktrace[idx + skip_n_firsts()], idx); + } + void *const *begin() const { + if (size()) { + return &_stacktrace[skip_n_firsts()]; + } + return nullptr; + } + +protected: + std::vector _stacktrace; +}; + +#if BACKWARD_HAS_UNWIND == 1 + +namespace details { + +template class Unwinder { +public: + size_t operator()(F &f, size_t depth) { + _f = &f; + _index = -1; + _depth = depth; + _Unwind_Backtrace(&this->backtrace_trampoline, this); + return static_cast(_index); + } + +private: + F *_f; + ssize_t _index; + size_t _depth; + + static _Unwind_Reason_Code backtrace_trampoline(_Unwind_Context *ctx, + void *self) { + return (static_cast(self))->backtrace(ctx); + } + + _Unwind_Reason_Code backtrace(_Unwind_Context *ctx) { + if (_index >= 0 && static_cast(_index) >= _depth) + return _URC_END_OF_STACK; + + int ip_before_instruction = 0; + uintptr_t ip = _Unwind_GetIPInfo(ctx, &ip_before_instruction); + + if (!ip_before_instruction) { + // calculating 0-1 for unsigned, looks like a possible bug to sanitiziers, + // so let's do it explicitly: + if (ip == 0) { + ip = std::numeric_limits::max(); // set it to 0xffff... (as + // from casting 0-1) + } else { + ip -= 1; // else just normally decrement it (no overflow/underflow will + // happen) + } + } + + if (_index >= 0) { // ignore first frame. + (*_f)(static_cast(_index), reinterpret_cast(ip)); + } + _index += 1; + return _URC_NO_REASON; + } +}; + +template size_t unwind(F f, size_t depth) { + Unwinder unwinder; + return unwinder(f, depth); +} + +} // namespace details + +template <> +class StackTraceImpl : public StackTraceImplHolder { +public: + NOINLINE + size_t load_here(size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + load_thread_info(); + set_context(context); + set_error_addr(error_addr); + if (depth == 0) { + return 0; + } + _stacktrace.resize(depth); + size_t trace_cnt = details::unwind(callback(*this), depth); + _stacktrace.resize(trace_cnt); + skip_n_firsts(0); + return size(); + } + size_t load_from(void *addr, size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + load_here(depth + 8, context, error_addr); + + for (size_t i = 0; i < _stacktrace.size(); ++i) { + if (_stacktrace[i] == addr) { + skip_n_firsts(i); + break; + } + } + + _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth)); + return size(); + } + +private: + struct callback { + StackTraceImpl &self; + callback(StackTraceImpl &_self) : self(_self) {} + + void operator()(size_t idx, void *addr) { self._stacktrace[idx] = addr; } + }; +}; + +#elif BACKWARD_HAS_LIBUNWIND == 1 + +template <> +class StackTraceImpl : public StackTraceImplHolder { +public: + __attribute__((noinline)) size_t load_here(size_t depth = 32, + void *_context = nullptr, + void *_error_addr = nullptr) { + set_context(_context); + set_error_addr(_error_addr); + load_thread_info(); + if (depth == 0) { + return 0; + } + _stacktrace.resize(depth + 1); + + int result = 0; + + unw_context_t ctx; + size_t index = 0; + + // Add the tail call. If the Instruction Pointer is the crash address it + // means we got a bad function pointer dereference, so we "unwind" the + // bad pointer manually by using the return address pointed to by the + // Stack Pointer as the Instruction Pointer and letting libunwind do + // the rest + + if (context()) { + ucontext_t *uctx = reinterpret_cast(context()); +#ifdef REG_RIP // x86_64 + if (uctx->uc_mcontext.gregs[REG_RIP] == + reinterpret_cast(error_addr())) { + uctx->uc_mcontext.gregs[REG_RIP] = + *reinterpret_cast(uctx->uc_mcontext.gregs[REG_RSP]); + } + _stacktrace[index] = + reinterpret_cast(uctx->uc_mcontext.gregs[REG_RIP]); + ++index; + ctx = *reinterpret_cast(uctx); +#elif defined(REG_EIP) // x86_32 + if (uctx->uc_mcontext.gregs[REG_EIP] == + reinterpret_cast(error_addr())) { + uctx->uc_mcontext.gregs[REG_EIP] = + *reinterpret_cast(uctx->uc_mcontext.gregs[REG_ESP]); + } + _stacktrace[index] = + reinterpret_cast(uctx->uc_mcontext.gregs[REG_EIP]); + ++index; + ctx = *reinterpret_cast(uctx); +#elif defined(__arm__) + // libunwind uses its own context type for ARM unwinding. + // Copy the registers from the signal handler's context so we can + // unwind + unw_getcontext(&ctx); + ctx.regs[UNW_ARM_R0] = uctx->uc_mcontext.arm_r0; + ctx.regs[UNW_ARM_R1] = uctx->uc_mcontext.arm_r1; + ctx.regs[UNW_ARM_R2] = uctx->uc_mcontext.arm_r2; + ctx.regs[UNW_ARM_R3] = uctx->uc_mcontext.arm_r3; + ctx.regs[UNW_ARM_R4] = uctx->uc_mcontext.arm_r4; + ctx.regs[UNW_ARM_R5] = uctx->uc_mcontext.arm_r5; + ctx.regs[UNW_ARM_R6] = uctx->uc_mcontext.arm_r6; + ctx.regs[UNW_ARM_R7] = uctx->uc_mcontext.arm_r7; + ctx.regs[UNW_ARM_R8] = uctx->uc_mcontext.arm_r8; + ctx.regs[UNW_ARM_R9] = uctx->uc_mcontext.arm_r9; + ctx.regs[UNW_ARM_R10] = uctx->uc_mcontext.arm_r10; + ctx.regs[UNW_ARM_R11] = uctx->uc_mcontext.arm_fp; + ctx.regs[UNW_ARM_R12] = uctx->uc_mcontext.arm_ip; + ctx.regs[UNW_ARM_R13] = uctx->uc_mcontext.arm_sp; + ctx.regs[UNW_ARM_R14] = uctx->uc_mcontext.arm_lr; + ctx.regs[UNW_ARM_R15] = uctx->uc_mcontext.arm_pc; + + // If we have crashed in the PC use the LR instead, as this was + // a bad function dereference + if (reinterpret_cast(error_addr()) == + uctx->uc_mcontext.arm_pc) { + ctx.regs[UNW_ARM_R15] = + uctx->uc_mcontext.arm_lr - sizeof(unsigned long); + } + _stacktrace[index] = reinterpret_cast(ctx.regs[UNW_ARM_R15]); + ++index; +#elif defined(__APPLE__) && defined(__x86_64__) + unw_getcontext(&ctx); + // OS X's implementation of libunwind uses its own context object + // so we need to convert the passed context to libunwind's format + // (information about the data layout taken from unw_getcontext.s + // in Apple's libunwind source + ctx.data[0] = uctx->uc_mcontext->__ss.__rax; + ctx.data[1] = uctx->uc_mcontext->__ss.__rbx; + ctx.data[2] = uctx->uc_mcontext->__ss.__rcx; + ctx.data[3] = uctx->uc_mcontext->__ss.__rdx; + ctx.data[4] = uctx->uc_mcontext->__ss.__rdi; + ctx.data[5] = uctx->uc_mcontext->__ss.__rsi; + ctx.data[6] = uctx->uc_mcontext->__ss.__rbp; + ctx.data[7] = uctx->uc_mcontext->__ss.__rsp; + ctx.data[8] = uctx->uc_mcontext->__ss.__r8; + ctx.data[9] = uctx->uc_mcontext->__ss.__r9; + ctx.data[10] = uctx->uc_mcontext->__ss.__r10; + ctx.data[11] = uctx->uc_mcontext->__ss.__r11; + ctx.data[12] = uctx->uc_mcontext->__ss.__r12; + ctx.data[13] = uctx->uc_mcontext->__ss.__r13; + ctx.data[14] = uctx->uc_mcontext->__ss.__r14; + ctx.data[15] = uctx->uc_mcontext->__ss.__r15; + ctx.data[16] = uctx->uc_mcontext->__ss.__rip; + + // If the IP is the same as the crash address we have a bad function + // dereference The caller's address is pointed to by %rsp, so we + // dereference that value and set it to be the next frame's IP. + if (uctx->uc_mcontext->__ss.__rip == + reinterpret_cast<__uint64_t>(error_addr())) { + ctx.data[16] = + *reinterpret_cast<__uint64_t *>(uctx->uc_mcontext->__ss.__rsp); + } + _stacktrace[index] = reinterpret_cast(ctx.data[16]); + ++index; +#elif defined(__APPLE__) + unw_getcontext(&ctx) + // TODO: Convert the ucontext_t to libunwind's unw_context_t like + // we do in 64 bits + if (ctx.uc_mcontext->__ss.__eip == + reinterpret_cast(error_addr())) { + ctx.uc_mcontext->__ss.__eip = ctx.uc_mcontext->__ss.__esp; + } + _stacktrace[index] = + reinterpret_cast(ctx.uc_mcontext->__ss.__eip); + ++index; +#endif + } + + unw_cursor_t cursor; + if (context()) { +#if defined(UNW_INIT_SIGNAL_FRAME) + result = unw_init_local2(&cursor, &ctx, UNW_INIT_SIGNAL_FRAME); +#else + result = unw_init_local(&cursor, &ctx); +#endif + } else { + unw_getcontext(&ctx); + ; + result = unw_init_local(&cursor, &ctx); + } + + if (result != 0) + return 1; + + unw_word_t ip = 0; + + while (index <= depth && unw_step(&cursor) > 0) { + result = unw_get_reg(&cursor, UNW_REG_IP, &ip); + if (result == 0) { + _stacktrace[index] = reinterpret_cast(--ip); + ++index; + } + } + --index; + + _stacktrace.resize(index + 1); + skip_n_firsts(0); + return size(); + } + + size_t load_from(void *addr, size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + load_here(depth + 8, context, error_addr); + + for (size_t i = 0; i < _stacktrace.size(); ++i) { + if (_stacktrace[i] == addr) { + skip_n_firsts(i); + _stacktrace[i] = (void *)((uintptr_t)_stacktrace[i]); + break; + } + } + + _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth)); + return size(); + } +}; + +#elif defined(BACKWARD_HAS_BACKTRACE) + +template <> +class StackTraceImpl : public StackTraceImplHolder { +public: + NOINLINE + size_t load_here(size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + set_context(context); + set_error_addr(error_addr); + load_thread_info(); + if (depth == 0) { + return 0; + } + _stacktrace.resize(depth + 1); + size_t trace_cnt = backtrace(&_stacktrace[0], _stacktrace.size()); + _stacktrace.resize(trace_cnt); + skip_n_firsts(1); + return size(); + } + + size_t load_from(void *addr, size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + load_here(depth + 8, context, error_addr); + + for (size_t i = 0; i < _stacktrace.size(); ++i) { + if (_stacktrace[i] == addr) { + skip_n_firsts(i); + _stacktrace[i] = (void *)((uintptr_t)_stacktrace[i] + 1); + break; + } + } + + _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth)); + return size(); + } +}; + +#elif defined(BACKWARD_SYSTEM_WINDOWS) + +template <> +class StackTraceImpl : public StackTraceImplHolder { +public: + // We have to load the machine type from the image info + // So we first initialize the resolver, and it tells us this info + void set_machine_type(DWORD machine_type) { machine_type_ = machine_type; } + void set_context(CONTEXT *ctx) { ctx_ = ctx; } + void set_thread_handle(HANDLE handle) { thd_ = handle; } + + NOINLINE + size_t load_here(size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + set_context(static_cast(context)); + set_error_addr(error_addr); + CONTEXT localCtx; // used when no context is provided + + if (depth == 0) { + return 0; + } + + if (!ctx_) { + ctx_ = &localCtx; + RtlCaptureContext(ctx_); + } + + if (!thd_) { + thd_ = GetCurrentThread(); + } + + HANDLE process = GetCurrentProcess(); + + STACKFRAME64 s; + memset(&s, 0, sizeof(STACKFRAME64)); + + // TODO: 32 bit context capture + s.AddrStack.Mode = AddrModeFlat; + s.AddrFrame.Mode = AddrModeFlat; + s.AddrPC.Mode = AddrModeFlat; +#ifdef _M_X64 + s.AddrPC.Offset = ctx_->Rip; + s.AddrStack.Offset = ctx_->Rsp; + s.AddrFrame.Offset = ctx_->Rbp; +#else + s.AddrPC.Offset = ctx_->Eip; + s.AddrStack.Offset = ctx_->Esp; + s.AddrFrame.Offset = ctx_->Ebp; +#endif + + if (!machine_type_) { +#ifdef _M_X64 + machine_type_ = IMAGE_FILE_MACHINE_AMD64; +#else + machine_type_ = IMAGE_FILE_MACHINE_I386; +#endif + } + + for (;;) { + // NOTE: this only works if PDBs are already loaded! + SetLastError(0); + if (!StackWalk64(machine_type_, process, thd_, &s, ctx_, NULL, + SymFunctionTableAccess64, SymGetModuleBase64, NULL)) + break; + + if (s.AddrReturn.Offset == 0) + break; + + _stacktrace.push_back(reinterpret_cast(s.AddrPC.Offset)); + + if (size() >= depth) + break; + } + + return size(); + } + + size_t load_from(void *addr, size_t depth = 32, void *context = nullptr, + void *error_addr = nullptr) { + load_here(depth + 8, context, error_addr); + + for (size_t i = 0; i < _stacktrace.size(); ++i) { + if (_stacktrace[i] == addr) { + skip_n_firsts(i); + break; + } + } + + _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth)); + return size(); + } + +private: + DWORD machine_type_ = 0; + HANDLE thd_ = 0; + CONTEXT *ctx_ = nullptr; +}; + +#endif + +class StackTrace : public StackTraceImpl {}; + +/*************** TRACE RESOLVER ***************/ + +class TraceResolverImplBase { +public: + virtual ~TraceResolverImplBase() {} + + virtual void load_addresses(void *const*addresses, int address_count) { + (void)addresses; + (void)address_count; + } + + template void load_stacktrace(ST &st) { + load_addresses(st.begin(), static_cast(st.size())); + } + + virtual ResolvedTrace resolve(ResolvedTrace t) { return t; } + +protected: + std::string demangle(const char *funcname) { + return _demangler.demangle(funcname); + } + +private: + details::demangler _demangler; +}; + +template class TraceResolverImpl; + +#ifdef BACKWARD_SYSTEM_UNKNOWN + +template <> class TraceResolverImpl + : public TraceResolverImplBase {}; + +#endif + +#ifdef BACKWARD_SYSTEM_LINUX + +class TraceResolverLinuxBase : public TraceResolverImplBase { +public: + TraceResolverLinuxBase() + : argv0_(get_argv0()), exec_path_(read_symlink("/proc/self/exe")) {} + std::string resolve_exec_path(Dl_info &symbol_info) const { + // mutates symbol_info.dli_fname to be filename to open and returns filename + // to display + if (symbol_info.dli_fname == argv0_) { + // dladdr returns argv[0] in dli_fname for symbols contained in + // the main executable, which is not a valid path if the + // executable was found by a search of the PATH environment + // variable; In that case, we actually open /proc/self/exe, which + // is always the actual executable (even if it was deleted/replaced!) + // but display the path that /proc/self/exe links to. + // However, this right away reduces probability of successful symbol + // resolution, because libbfd may try to find *.debug files in the + // same dir, in case symbols are stripped. As a result, it may try + // to find a file /proc/self/.debug, which obviously does + // not exist. /proc/self/exe is a last resort. First load attempt + // should go for the original executable file path. + symbol_info.dli_fname = "/proc/self/exe"; + return exec_path_; + } else { + return symbol_info.dli_fname; + } + } + +private: + std::string argv0_; + std::string exec_path_; + + static std::string get_argv0() { + std::string argv0; + std::ifstream ifs("/proc/self/cmdline"); + std::getline(ifs, argv0, '\0'); + return argv0; + } + + static std::string read_symlink(std::string const &symlink_path) { + std::string path; + path.resize(100); + + while (true) { + ssize_t len = + ::readlink(symlink_path.c_str(), &*path.begin(), path.size()); + if (len < 0) { + return ""; + } + if (static_cast(len) == path.size()) { + path.resize(path.size() * 2); + } else { + path.resize(static_cast(len)); + break; + } + } + + return path; + } +}; + +template class TraceResolverLinuxImpl; + +#if BACKWARD_HAS_BACKTRACE_SYMBOL == 1 + +template <> +class TraceResolverLinuxImpl + : public TraceResolverLinuxBase { +public: + void load_addresses(void *const*addresses, int address_count) override { + if (address_count == 0) { + return; + } + _symbols.reset(backtrace_symbols(addresses, address_count)); + } + + ResolvedTrace resolve(ResolvedTrace trace) override { + char *filename = _symbols[trace.idx]; + char *funcname = filename; + while (*funcname && *funcname != '(') { + funcname += 1; + } + trace.object_filename.assign(filename, + funcname); // ok even if funcname is the ending + // \0 (then we assign entire string) + + if (*funcname) { // if it's not end of string (e.g. from last frame ip==0) + funcname += 1; + char *funcname_end = funcname; + while (*funcname_end && *funcname_end != ')' && *funcname_end != '+') { + funcname_end += 1; + } + *funcname_end = '\0'; + trace.object_function = this->demangle(funcname); + trace.source.function = trace.object_function; // we cannot do better. + } + return trace; + } + +private: + details::handle _symbols; +}; + +#endif // BACKWARD_HAS_BACKTRACE_SYMBOL == 1 + +#if BACKWARD_HAS_BFD == 1 + +template <> +class TraceResolverLinuxImpl + : public TraceResolverLinuxBase { +public: + TraceResolverLinuxImpl() : _bfd_loaded(false) {} + + ResolvedTrace resolve(ResolvedTrace trace) override { + Dl_info symbol_info; + + // trace.addr is a virtual address in memory pointing to some code. + // Let's try to find from which loaded object it comes from. + // The loaded object can be yourself btw. + if (!dladdr(trace.addr, &symbol_info)) { + return trace; // dat broken trace... + } + + // Now we get in symbol_info: + // .dli_fname: + // pathname of the shared object that contains the address. + // .dli_fbase: + // where the object is loaded in memory. + // .dli_sname: + // the name of the nearest symbol to trace.addr, we expect a + // function name. + // .dli_saddr: + // the exact address corresponding to .dli_sname. + + if (symbol_info.dli_sname) { + trace.object_function = demangle(symbol_info.dli_sname); + } + + if (!symbol_info.dli_fname) { + return trace; + } + + trace.object_filename = resolve_exec_path(symbol_info); + bfd_fileobject *fobj; + // Before rushing to resolution need to ensure the executable + // file still can be used. For that compare inode numbers of + // what is stored by the executable's file path, and in the + // dli_fname, which not necessarily equals to the executable. + // It can be a shared library, or /proc/self/exe, and in the + // latter case has drawbacks. See the exec path resolution for + // details. In short - the dli object should be used only as + // the last resort. + // If inode numbers are equal, it is known dli_fname and the + // executable file are the same. This is guaranteed by Linux, + // because if the executable file is changed/deleted, it will + // be done in a new inode. The old file will be preserved in + // /proc/self/exe, and may even have inode 0. The latter can + // happen if the inode was actually reused, and the file was + // kept only in the main memory. + // + struct stat obj_stat; + struct stat dli_stat; + if (stat(trace.object_filename.c_str(), &obj_stat) == 0 && + stat(symbol_info.dli_fname, &dli_stat) == 0 && + obj_stat.st_ino == dli_stat.st_ino) { + // The executable file, and the shared object containing the + // address are the same file. Safe to use the original path. + // this is preferable. Libbfd will search for stripped debug + // symbols in the same directory. + fobj = load_object_with_bfd(trace.object_filename); + } else{ + // The original object file was *deleted*! The only hope is + // that the debug symbols are either inside the shared + // object file, or are in the same directory, and this is + // not /proc/self/exe. + fobj = nullptr; + } + if (fobj == nullptr || !fobj->handle) { + fobj = load_object_with_bfd(symbol_info.dli_fname); + if (!fobj->handle) { + return trace; + } + } + + find_sym_result *details_selected; // to be filled. + + // trace.addr is the next instruction to be executed after returning + // from the nested stack frame. In C++ this usually relate to the next + // statement right after the function call that leaded to a new stack + // frame. This is not usually what you want to see when printing out a + // stacktrace... + find_sym_result details_call_site = + find_symbol_details(fobj, trace.addr, symbol_info.dli_fbase); + details_selected = &details_call_site; + +#if BACKWARD_HAS_UNWIND == 0 + // ...this is why we also try to resolve the symbol that is right + // before the return address. If we are lucky enough, we will get the + // line of the function that was called. But if the code is optimized, + // we might get something absolutely not related since the compiler + // can reschedule the return address with inline functions and + // tail-call optimisation (among other things that I don't even know + // or cannot even dream about with my tiny limited brain). + find_sym_result details_adjusted_call_site = find_symbol_details( + fobj, (void *)(uintptr_t(trace.addr) - 1), symbol_info.dli_fbase); + + // In debug mode, we should always get the right thing(TM). + if (details_call_site.found && details_adjusted_call_site.found) { + // Ok, we assume that details_adjusted_call_site is a better estimation. + details_selected = &details_adjusted_call_site; + trace.addr = (void *)(uintptr_t(trace.addr) - 1); + } + + if (details_selected == &details_call_site && details_call_site.found) { + // we have to re-resolve the symbol in order to reset some + // internal state in BFD... so we can call backtrace_inliners + // thereafter... + details_call_site = + find_symbol_details(fobj, trace.addr, symbol_info.dli_fbase); + } +#endif // BACKWARD_HAS_UNWIND + + if (details_selected->found) { + if (details_selected->filename) { + trace.source.filename = details_selected->filename; + } + trace.source.line = details_selected->line; + + if (details_selected->funcname) { + // this time we get the name of the function where the code is + // located, instead of the function were the address is + // located. In short, if the code was inlined, we get the + // function correspoding to the code. Else we already got in + // trace.function. + trace.source.function = demangle(details_selected->funcname); + + if (!symbol_info.dli_sname) { + // for the case dladdr failed to find the symbol name of + // the function, we might as well try to put something + // here. + trace.object_function = trace.source.function; + } + } + + // Maybe the source of the trace got inlined inside the function + // (trace.source.function). Let's see if we can get all the inlined + // calls along the way up to the initial call site. + trace.inliners = backtrace_inliners(fobj, *details_selected); + +#if 0 + if (trace.inliners.size() == 0) { + // Maybe the trace was not inlined... or maybe it was and we + // are lacking the debug information. Let's try to make the + // world better and see if we can get the line number of the + // function (trace.source.function) now. + // + // We will get the location of where the function start (to be + // exact: the first instruction that really start the + // function), not where the name of the function is defined. + // This can be quite far away from the name of the function + // btw. + // + // If the source of the function is the same as the source of + // the trace, we cannot say if the trace was really inlined or + // not. However, if the filename of the source is different + // between the function and the trace... we can declare it as + // an inliner. This is not 100% accurate, but better than + // nothing. + + if (symbol_info.dli_saddr) { + find_sym_result details = find_symbol_details(fobj, + symbol_info.dli_saddr, + symbol_info.dli_fbase); + + if (details.found) { + ResolvedTrace::SourceLoc diy_inliner; + diy_inliner.line = details.line; + if (details.filename) { + diy_inliner.filename = details.filename; + } + if (details.funcname) { + diy_inliner.function = demangle(details.funcname); + } else { + diy_inliner.function = trace.source.function; + } + if (diy_inliner != trace.source) { + trace.inliners.push_back(diy_inliner); + } + } + } + } +#endif + } + + return trace; + } + +private: + bool _bfd_loaded; + + typedef details::handle > + bfd_handle_t; + + typedef details::handle bfd_symtab_t; + + struct bfd_fileobject { + bfd_handle_t handle; + bfd_vma base_addr; + bfd_symtab_t symtab; + bfd_symtab_t dynamic_symtab; + }; + + typedef details::hashtable::type fobj_bfd_map_t; + fobj_bfd_map_t _fobj_bfd_map; + + bfd_fileobject *load_object_with_bfd(const std::string &filename_object) { + using namespace details; + + if (!_bfd_loaded) { + using namespace details; + bfd_init(); + _bfd_loaded = true; + } + + fobj_bfd_map_t::iterator it = _fobj_bfd_map.find(filename_object); + if (it != _fobj_bfd_map.end()) { + return &it->second; + } + + // this new object is empty for now. + bfd_fileobject *r = &_fobj_bfd_map[filename_object]; + + // we do the work temporary in this one; + bfd_handle_t bfd_handle; + + int fd = open(filename_object.c_str(), O_RDONLY); + bfd_handle.reset(bfd_fdopenr(filename_object.c_str(), "default", fd)); + if (!bfd_handle) { + close(fd); + return r; + } + + if (!bfd_check_format(bfd_handle.get(), bfd_object)) { + return r; // not an object? You lose. + } + + if ((bfd_get_file_flags(bfd_handle.get()) & HAS_SYMS) == 0) { + return r; // that's what happen when you forget to compile in debug. + } + + ssize_t symtab_storage_size = bfd_get_symtab_upper_bound(bfd_handle.get()); + + ssize_t dyn_symtab_storage_size = + bfd_get_dynamic_symtab_upper_bound(bfd_handle.get()); + + if (symtab_storage_size <= 0 && dyn_symtab_storage_size <= 0) { + return r; // weird, is the file is corrupted? + } + + bfd_symtab_t symtab, dynamic_symtab; + ssize_t symcount = 0, dyn_symcount = 0; + + if (symtab_storage_size > 0) { + symtab.reset(static_cast( + malloc(static_cast(symtab_storage_size)))); + symcount = bfd_canonicalize_symtab(bfd_handle.get(), symtab.get()); + } + + if (dyn_symtab_storage_size > 0) { + dynamic_symtab.reset(static_cast( + malloc(static_cast(dyn_symtab_storage_size)))); + dyn_symcount = bfd_canonicalize_dynamic_symtab(bfd_handle.get(), + dynamic_symtab.get()); + } + + if (symcount <= 0 && dyn_symcount <= 0) { + return r; // damned, that's a stripped file that you got there! + } + + r->handle = move(bfd_handle); + r->symtab = move(symtab); + r->dynamic_symtab = move(dynamic_symtab); + return r; + } + + struct find_sym_result { + bool found; + const char *filename; + const char *funcname; + unsigned int line; + }; + + struct find_sym_context { + TraceResolverLinuxImpl *self; + bfd_fileobject *fobj; + void *addr; + void *base_addr; + find_sym_result result; + }; + + find_sym_result find_symbol_details(bfd_fileobject *fobj, void *addr, + void *base_addr) { + find_sym_context context; + context.self = this; + context.fobj = fobj; + context.addr = addr; + context.base_addr = base_addr; + context.result.found = false; + bfd_map_over_sections(fobj->handle.get(), &find_in_section_trampoline, + static_cast(&context)); + return context.result; + } + + static void find_in_section_trampoline(bfd *, asection *section, void *data) { + find_sym_context *context = static_cast(data); + context->self->find_in_section( + reinterpret_cast(context->addr), + reinterpret_cast(context->base_addr), context->fobj, section, + context->result); + } + + void find_in_section(bfd_vma addr, bfd_vma base_addr, bfd_fileobject *fobj, + asection *section, find_sym_result &result) { + if (result.found) + return; + +#ifdef bfd_get_section_flags + if ((bfd_get_section_flags(fobj->handle.get(), section) & SEC_ALLOC) == 0) +#else + if ((bfd_section_flags(section) & SEC_ALLOC) == 0) +#endif + return; // a debug section is never loaded automatically. + +#ifdef bfd_get_section_vma + bfd_vma sec_addr = bfd_get_section_vma(fobj->handle.get(), section); +#else + bfd_vma sec_addr = bfd_section_vma(section); +#endif +#ifdef bfd_get_section_size + bfd_size_type size = bfd_get_section_size(section); +#else + bfd_size_type size = bfd_section_size(section); +#endif + + // are we in the boundaries of the section? + if (addr < sec_addr || addr >= sec_addr + size) { + addr -= base_addr; // oups, a relocated object, lets try again... + if (addr < sec_addr || addr >= sec_addr + size) { + return; + } + } + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" +#endif + if (!result.found && fobj->symtab) { + result.found = bfd_find_nearest_line( + fobj->handle.get(), section, fobj->symtab.get(), addr - sec_addr, + &result.filename, &result.funcname, &result.line); + } + + if (!result.found && fobj->dynamic_symtab) { + result.found = bfd_find_nearest_line( + fobj->handle.get(), section, fobj->dynamic_symtab.get(), + addr - sec_addr, &result.filename, &result.funcname, &result.line); + } +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + ResolvedTrace::source_locs_t + backtrace_inliners(bfd_fileobject *fobj, find_sym_result previous_result) { + // This function can be called ONLY after a SUCCESSFUL call to + // find_symbol_details. The state is global to the bfd_handle. + ResolvedTrace::source_locs_t results; + while (previous_result.found) { + find_sym_result result; + result.found = bfd_find_inliner_info(fobj->handle.get(), &result.filename, + &result.funcname, &result.line); + + if (result + .found) /* and not ( + cstrings_eq(previous_result.filename, + result.filename) and + cstrings_eq(previous_result.funcname, result.funcname) + and result.line == previous_result.line + )) */ + { + ResolvedTrace::SourceLoc src_loc; + src_loc.line = result.line; + if (result.filename) { + src_loc.filename = result.filename; + } + if (result.funcname) { + src_loc.function = demangle(result.funcname); + } + results.push_back(src_loc); + } + previous_result = result; + } + return results; + } + + bool cstrings_eq(const char *a, const char *b) { + if (!a || !b) { + return false; + } + return strcmp(a, b) == 0; + } +}; +#endif // BACKWARD_HAS_BFD == 1 + +#if BACKWARD_HAS_DW == 1 + +template <> +class TraceResolverLinuxImpl + : public TraceResolverLinuxBase { +public: + TraceResolverLinuxImpl() : _dwfl_handle_initialized(false) {} + + ResolvedTrace resolve(ResolvedTrace trace) override { + using namespace details; + + Dwarf_Addr trace_addr = (Dwarf_Addr)trace.addr; + + if (!_dwfl_handle_initialized) { + // initialize dwfl... + _dwfl_cb.reset(new Dwfl_Callbacks); + _dwfl_cb->find_elf = &dwfl_linux_proc_find_elf; + _dwfl_cb->find_debuginfo = &dwfl_standard_find_debuginfo; + _dwfl_cb->debuginfo_path = 0; + + _dwfl_handle.reset(dwfl_begin(_dwfl_cb.get())); + _dwfl_handle_initialized = true; + + if (!_dwfl_handle) { + return trace; + } + + // ...from the current process. + dwfl_report_begin(_dwfl_handle.get()); + int r = dwfl_linux_proc_report(_dwfl_handle.get(), getpid()); + dwfl_report_end(_dwfl_handle.get(), NULL, NULL); + if (r < 0) { + return trace; + } + } + + if (!_dwfl_handle) { + return trace; + } + + // find the module (binary object) that contains the trace's address. + // This is not using any debug information, but the addresses ranges of + // all the currently loaded binary object. + Dwfl_Module *mod = dwfl_addrmodule(_dwfl_handle.get(), trace_addr); + if (mod) { + // now that we found it, lets get the name of it, this will be the + // full path to the running binary or one of the loaded library. + const char *module_name = dwfl_module_info(mod, 0, 0, 0, 0, 0, 0, 0); + if (module_name) { + trace.object_filename = module_name; + } + // We also look after the name of the symbol, equal or before this + // address. This is found by walking the symtab. We should get the + // symbol corresponding to the function (mangled) containing the + // address. If the code corresponding to the address was inlined, + // this is the name of the out-most inliner function. + const char *sym_name = dwfl_module_addrname(mod, trace_addr); + if (sym_name) { + trace.object_function = demangle(sym_name); + } + } + + // now let's get serious, and find out the source location (file and + // line number) of the address. + + // This function will look in .debug_aranges for the address and map it + // to the location of the compilation unit DIE in .debug_info and + // return it. + Dwarf_Addr mod_bias = 0; + Dwarf_Die *cudie = dwfl_module_addrdie(mod, trace_addr, &mod_bias); + +#if 1 + if (!cudie) { + // Sadly clang does not generate the section .debug_aranges, thus + // dwfl_module_addrdie will fail early. Clang doesn't either set + // the lowpc/highpc/range info for every compilation unit. + // + // So in order to save the world: + // for every compilation unit, we will iterate over every single + // DIEs. Normally functions should have a lowpc/highpc/range, which + // we will use to infer the compilation unit. + + // note that this is probably badly inefficient. + while ((cudie = dwfl_module_nextcu(mod, cudie, &mod_bias))) { + Dwarf_Die die_mem; + Dwarf_Die *fundie = + find_fundie_by_pc(cudie, trace_addr - mod_bias, &die_mem); + if (fundie) { + break; + } + } + } +#endif + +//#define BACKWARD_I_DO_NOT_RECOMMEND_TO_ENABLE_THIS_HORRIBLE_PIECE_OF_CODE +#ifdef BACKWARD_I_DO_NOT_RECOMMEND_TO_ENABLE_THIS_HORRIBLE_PIECE_OF_CODE + if (!cudie) { + // If it's still not enough, lets dive deeper in the shit, and try + // to save the world again: for every compilation unit, we will + // load the corresponding .debug_line section, and see if we can + // find our address in it. + + Dwarf_Addr cfi_bias; + Dwarf_CFI *cfi_cache = dwfl_module_eh_cfi(mod, &cfi_bias); + + Dwarf_Addr bias; + while ((cudie = dwfl_module_nextcu(mod, cudie, &bias))) { + if (dwarf_getsrc_die(cudie, trace_addr - bias)) { + + // ...but if we get a match, it might be a false positive + // because our (address - bias) might as well be valid in a + // different compilation unit. So we throw our last card on + // the table and lookup for the address into the .eh_frame + // section. + + handle frame; + dwarf_cfi_addrframe(cfi_cache, trace_addr - cfi_bias, &frame); + if (frame) { + break; + } + } + } + } +#endif + + if (!cudie) { + return trace; // this time we lost the game :/ + } + + // Now that we have a compilation unit DIE, this function will be able + // to load the corresponding section in .debug_line (if not already + // loaded) and hopefully find the source location mapped to our + // address. + Dwarf_Line *srcloc = dwarf_getsrc_die(cudie, trace_addr - mod_bias); + + if (srcloc) { + const char *srcfile = dwarf_linesrc(srcloc, 0, 0); + if (srcfile) { + trace.source.filename = srcfile; + } + int line = 0, col = 0; + dwarf_lineno(srcloc, &line); + dwarf_linecol(srcloc, &col); + trace.source.line = line; + trace.source.col = col; + } + + deep_first_search_by_pc(cudie, trace_addr - mod_bias, + inliners_search_cb(trace)); + if (trace.source.function.size() == 0) { + // fallback. + trace.source.function = trace.object_function; + } + + return trace; + } + +private: + typedef details::handle > + dwfl_handle_t; + details::handle > + _dwfl_cb; + dwfl_handle_t _dwfl_handle; + bool _dwfl_handle_initialized; + + // defined here because in C++98, template function cannot take locally + // defined types... grrr. + struct inliners_search_cb { + void operator()(Dwarf_Die *die) { + switch (dwarf_tag(die)) { + const char *name; + case DW_TAG_subprogram: + if ((name = dwarf_diename(die))) { + trace.source.function = name; + } + break; + + case DW_TAG_inlined_subroutine: + ResolvedTrace::SourceLoc sloc; + Dwarf_Attribute attr_mem; + + if ((name = dwarf_diename(die))) { + sloc.function = name; + } + if ((name = die_call_file(die))) { + sloc.filename = name; + } + + Dwarf_Word line = 0, col = 0; + dwarf_formudata(dwarf_attr(die, DW_AT_call_line, &attr_mem), &line); + dwarf_formudata(dwarf_attr(die, DW_AT_call_column, &attr_mem), &col); + sloc.line = (unsigned)line; + sloc.col = (unsigned)col; + + trace.inliners.push_back(sloc); + break; + }; + } + ResolvedTrace &trace; + inliners_search_cb(ResolvedTrace &t) : trace(t) {} + }; + + static bool die_has_pc(Dwarf_Die *die, Dwarf_Addr pc) { + Dwarf_Addr low, high; + + // continuous range + if (dwarf_hasattr(die, DW_AT_low_pc) && dwarf_hasattr(die, DW_AT_high_pc)) { + if (dwarf_lowpc(die, &low) != 0) { + return false; + } + if (dwarf_highpc(die, &high) != 0) { + Dwarf_Attribute attr_mem; + Dwarf_Attribute *attr = dwarf_attr(die, DW_AT_high_pc, &attr_mem); + Dwarf_Word value; + if (dwarf_formudata(attr, &value) != 0) { + return false; + } + high = low + value; + } + return pc >= low && pc < high; + } + + // non-continuous range. + Dwarf_Addr base; + ptrdiff_t offset = 0; + while ((offset = dwarf_ranges(die, offset, &base, &low, &high)) > 0) { + if (pc >= low && pc < high) { + return true; + } + } + return false; + } + + static Dwarf_Die *find_fundie_by_pc(Dwarf_Die *parent_die, Dwarf_Addr pc, + Dwarf_Die *result) { + if (dwarf_child(parent_die, result) != 0) { + return 0; + } + + Dwarf_Die *die = result; + do { + switch (dwarf_tag(die)) { + case DW_TAG_subprogram: + case DW_TAG_inlined_subroutine: + if (die_has_pc(die, pc)) { + return result; + } + }; + bool declaration = false; + Dwarf_Attribute attr_mem; + dwarf_formflag(dwarf_attr(die, DW_AT_declaration, &attr_mem), + &declaration); + if (!declaration) { + // let's be curious and look deeper in the tree, + // function are not necessarily at the first level, but + // might be nested inside a namespace, structure etc. + Dwarf_Die die_mem; + Dwarf_Die *indie = find_fundie_by_pc(die, pc, &die_mem); + if (indie) { + *result = die_mem; + return result; + } + } + } while (dwarf_siblingof(die, result) == 0); + return 0; + } + + template + static bool deep_first_search_by_pc(Dwarf_Die *parent_die, Dwarf_Addr pc, + CB cb) { + Dwarf_Die die_mem; + if (dwarf_child(parent_die, &die_mem) != 0) { + return false; + } + + bool branch_has_pc = false; + Dwarf_Die *die = &die_mem; + do { + bool declaration = false; + Dwarf_Attribute attr_mem; + dwarf_formflag(dwarf_attr(die, DW_AT_declaration, &attr_mem), + &declaration); + if (!declaration) { + // let's be curious and look deeper in the tree, function are + // not necessarily at the first level, but might be nested + // inside a namespace, structure, a function, an inlined + // function etc. + branch_has_pc = deep_first_search_by_pc(die, pc, cb); + } + if (!branch_has_pc) { + branch_has_pc = die_has_pc(die, pc); + } + if (branch_has_pc) { + cb(die); + } + } while (dwarf_siblingof(die, &die_mem) == 0); + return branch_has_pc; + } + + static const char *die_call_file(Dwarf_Die *die) { + Dwarf_Attribute attr_mem; + Dwarf_Word file_idx = 0; + + dwarf_formudata(dwarf_attr(die, DW_AT_call_file, &attr_mem), &file_idx); + + if (file_idx == 0) { + return 0; + } + + Dwarf_Die die_mem; + Dwarf_Die *cudie = dwarf_diecu(die, &die_mem, 0, 0); + if (!cudie) { + return 0; + } + + Dwarf_Files *files = 0; + size_t nfiles; + dwarf_getsrcfiles(cudie, &files, &nfiles); + if (!files) { + return 0; + } + + return dwarf_filesrc(files, file_idx, 0, 0); + } +}; +#endif // BACKWARD_HAS_DW == 1 + +#if BACKWARD_HAS_DWARF == 1 + +template <> +class TraceResolverLinuxImpl + : public TraceResolverLinuxBase { +public: + TraceResolverLinuxImpl() : _dwarf_loaded(false) {} + + ResolvedTrace resolve(ResolvedTrace trace) override { + // trace.addr is a virtual address in memory pointing to some code. + // Let's try to find from which loaded object it comes from. + // The loaded object can be yourself btw. + + Dl_info symbol_info; + int dladdr_result = 0; +#if defined(__GLIBC__) + link_map *link_map; + // We request the link map so we can get information about offsets + dladdr_result = + dladdr1(trace.addr, &symbol_info, reinterpret_cast(&link_map), + RTLD_DL_LINKMAP); +#else + // Android doesn't have dladdr1. Don't use the linker map. + dladdr_result = dladdr(trace.addr, &symbol_info); +#endif + if (!dladdr_result) { + return trace; // dat broken trace... + } + + // Now we get in symbol_info: + // .dli_fname: + // pathname of the shared object that contains the address. + // .dli_fbase: + // where the object is loaded in memory. + // .dli_sname: + // the name of the nearest symbol to trace.addr, we expect a + // function name. + // .dli_saddr: + // the exact address corresponding to .dli_sname. + // + // And in link_map: + // .l_addr: + // difference between the address in the ELF file and the address + // in memory + // l_name: + // absolute pathname where the object was found + + if (symbol_info.dli_sname) { + trace.object_function = demangle(symbol_info.dli_sname); + } + + if (!symbol_info.dli_fname) { + return trace; + } + + trace.object_filename = resolve_exec_path(symbol_info); + dwarf_fileobject &fobj = load_object_with_dwarf(symbol_info.dli_fname); + if (!fobj.dwarf_handle) { + return trace; // sad, we couldn't load the object :( + } + +#if defined(__GLIBC__) + // Convert the address to a module relative one by looking at + // the module's loading address in the link map + Dwarf_Addr address = reinterpret_cast(trace.addr) - + reinterpret_cast(link_map->l_addr); +#else + Dwarf_Addr address = reinterpret_cast(trace.addr); +#endif + + if (trace.object_function.empty()) { + symbol_cache_t::iterator it = fobj.symbol_cache.lower_bound(address); + + if (it != fobj.symbol_cache.end()) { + if (it->first != address) { + if (it != fobj.symbol_cache.begin()) { + --it; + } + } + trace.object_function = demangle(it->second.c_str()); + } + } + + // Get the Compilation Unit DIE for the address + Dwarf_Die die = find_die(fobj, address); + + if (!die) { + return trace; // this time we lost the game :/ + } + + // libdwarf doesn't give us direct access to its objects, it always + // allocates a copy for the caller. We keep that copy alive in a cache + // and we deallocate it later when it's no longer required. + die_cache_entry &die_object = get_die_cache(fobj, die); + if (die_object.isEmpty()) + return trace; // We have no line section for this DIE + + die_linemap_t::iterator it = die_object.line_section.lower_bound(address); + + if (it != die_object.line_section.end()) { + if (it->first != address) { + if (it == die_object.line_section.begin()) { + // If we are on the first item of the line section + // but the address does not match it means that + // the address is below the range of the DIE. Give up. + return trace; + } else { + --it; + } + } + } else { + return trace; // We didn't find the address. + } + + // Get the Dwarf_Line that the address points to and call libdwarf + // to get source file, line and column info. + Dwarf_Line line = die_object.line_buffer[it->second]; + Dwarf_Error error = DW_DLE_NE; + + char *filename; + if (dwarf_linesrc(line, &filename, &error) == DW_DLV_OK) { + trace.source.filename = std::string(filename); + dwarf_dealloc(fobj.dwarf_handle.get(), filename, DW_DLA_STRING); + } + + Dwarf_Unsigned number = 0; + if (dwarf_lineno(line, &number, &error) == DW_DLV_OK) { + trace.source.line = number; + } else { + trace.source.line = 0; + } + + if (dwarf_lineoff_b(line, &number, &error) == DW_DLV_OK) { + trace.source.col = number; + } else { + trace.source.col = 0; + } + + std::vector namespace_stack; + deep_first_search_by_pc(fobj, die, address, namespace_stack, + inliners_search_cb(trace, fobj, die)); + + dwarf_dealloc(fobj.dwarf_handle.get(), die, DW_DLA_DIE); + + return trace; + } + +public: + static int close_dwarf(Dwarf_Debug dwarf) { + return dwarf_finish(dwarf, NULL); + } + +private: + bool _dwarf_loaded; + + typedef details::handle > + dwarf_file_t; + + typedef details::handle > + dwarf_elf_t; + + typedef details::handle > + dwarf_handle_t; + + typedef std::map die_linemap_t; + + typedef std::map die_specmap_t; + + struct die_cache_entry { + die_specmap_t spec_section; + die_linemap_t line_section; + Dwarf_Line *line_buffer; + Dwarf_Signed line_count; + Dwarf_Line_Context line_context; + + inline bool isEmpty() { + return line_buffer == NULL || line_count == 0 || line_context == NULL || + line_section.empty(); + } + + die_cache_entry() : line_buffer(0), line_count(0), line_context(0) {} + + ~die_cache_entry() { + if (line_context) { + dwarf_srclines_dealloc_b(line_context); + } + } + }; + + typedef std::map die_cache_t; + + typedef std::map symbol_cache_t; + + struct dwarf_fileobject { + dwarf_file_t file_handle; + dwarf_elf_t elf_handle; + dwarf_handle_t dwarf_handle; + symbol_cache_t symbol_cache; + + // Die cache + die_cache_t die_cache; + die_cache_entry *current_cu; + }; + + typedef details::hashtable::type + fobj_dwarf_map_t; + fobj_dwarf_map_t _fobj_dwarf_map; + + static bool cstrings_eq(const char *a, const char *b) { + if (!a || !b) { + return false; + } + return strcmp(a, b) == 0; + } + + dwarf_fileobject &load_object_with_dwarf(const std::string &filename_object) { + + if (!_dwarf_loaded) { + // Set the ELF library operating version + // If that fails there's nothing we can do + _dwarf_loaded = elf_version(EV_CURRENT) != EV_NONE; + } + + fobj_dwarf_map_t::iterator it = _fobj_dwarf_map.find(filename_object); + if (it != _fobj_dwarf_map.end()) { + return it->second; + } + + // this new object is empty for now + dwarf_fileobject &r = _fobj_dwarf_map[filename_object]; + + dwarf_file_t file_handle; + file_handle.reset(open(filename_object.c_str(), O_RDONLY)); + if (file_handle.get() < 0) { + return r; + } + + // Try to get an ELF handle. We need to read the ELF sections + // because we want to see if there is a .gnu_debuglink section + // that points to a split debug file + dwarf_elf_t elf_handle; + elf_handle.reset(elf_begin(file_handle.get(), ELF_C_READ, NULL)); + if (!elf_handle) { + return r; + } + + const char *e_ident = elf_getident(elf_handle.get(), 0); + if (!e_ident) { + return r; + } + + // Get the number of sections + // We use the new APIs as elf_getshnum is deprecated + size_t shdrnum = 0; + if (elf_getshdrnum(elf_handle.get(), &shdrnum) == -1) { + return r; + } + + // Get the index to the string section + size_t shdrstrndx = 0; + if (elf_getshdrstrndx(elf_handle.get(), &shdrstrndx) == -1) { + return r; + } + + std::string debuglink; + // Iterate through the ELF sections to try to get a gnu_debuglink + // note and also to cache the symbol table. + // We go the preprocessor way to avoid having to create templated + // classes or using gelf (which might throw a compiler error if 64 bit + // is not supported +#define ELF_GET_DATA(ARCH) \ + Elf_Scn *elf_section = 0; \ + Elf_Data *elf_data = 0; \ + Elf##ARCH##_Shdr *section_header = 0; \ + Elf_Scn *symbol_section = 0; \ + size_t symbol_count = 0; \ + size_t symbol_strings = 0; \ + Elf##ARCH##_Sym *symbol = 0; \ + const char *section_name = 0; \ + \ + while ((elf_section = elf_nextscn(elf_handle.get(), elf_section)) != NULL) { \ + section_header = elf##ARCH##_getshdr(elf_section); \ + if (section_header == NULL) { \ + return r; \ + } \ + \ + if ((section_name = elf_strptr(elf_handle.get(), shdrstrndx, \ + section_header->sh_name)) == NULL) { \ + return r; \ + } \ + \ + if (cstrings_eq(section_name, ".gnu_debuglink")) { \ + elf_data = elf_getdata(elf_section, NULL); \ + if (elf_data && elf_data->d_size > 0) { \ + debuglink = \ + std::string(reinterpret_cast(elf_data->d_buf)); \ + } \ + } \ + \ + switch (section_header->sh_type) { \ + case SHT_SYMTAB: \ + symbol_section = elf_section; \ + symbol_count = section_header->sh_size / section_header->sh_entsize; \ + symbol_strings = section_header->sh_link; \ + break; \ + \ + /* We use .dynsyms as a last resort, we prefer .symtab */ \ + case SHT_DYNSYM: \ + if (!symbol_section) { \ + symbol_section = elf_section; \ + symbol_count = section_header->sh_size / section_header->sh_entsize; \ + symbol_strings = section_header->sh_link; \ + } \ + break; \ + } \ + } \ + \ + if (symbol_section && symbol_count && symbol_strings) { \ + elf_data = elf_getdata(symbol_section, NULL); \ + symbol = reinterpret_cast(elf_data->d_buf); \ + for (size_t i = 0; i < symbol_count; ++i) { \ + int type = ELF##ARCH##_ST_TYPE(symbol->st_info); \ + if (type == STT_FUNC && symbol->st_value > 0) { \ + r.symbol_cache[symbol->st_value] = std::string( \ + elf_strptr(elf_handle.get(), symbol_strings, symbol->st_name)); \ + } \ + ++symbol; \ + } \ + } + + if (e_ident[EI_CLASS] == ELFCLASS32) { + ELF_GET_DATA(32) + } else if (e_ident[EI_CLASS] == ELFCLASS64) { + // libelf might have been built without 64 bit support +#if __LIBELF64 + ELF_GET_DATA(64) +#endif + } + + if (!debuglink.empty()) { + // We have a debuglink section! Open an elf instance on that + // file instead. If we can't open the file, then return + // the elf handle we had already opened. + dwarf_file_t debuglink_file; + debuglink_file.reset(open(debuglink.c_str(), O_RDONLY)); + if (debuglink_file.get() > 0) { + dwarf_elf_t debuglink_elf; + debuglink_elf.reset(elf_begin(debuglink_file.get(), ELF_C_READ, NULL)); + + // If we have a valid elf handle, return the new elf handle + // and file handle and discard the original ones + if (debuglink_elf) { + elf_handle = move(debuglink_elf); + file_handle = move(debuglink_file); + } + } + } + + // Ok, we have a valid ELF handle, let's try to get debug symbols + Dwarf_Debug dwarf_debug; + Dwarf_Error error = DW_DLE_NE; + dwarf_handle_t dwarf_handle; + + int dwarf_result = dwarf_elf_init(elf_handle.get(), DW_DLC_READ, NULL, NULL, + &dwarf_debug, &error); + + // We don't do any special handling for DW_DLV_NO_ENTRY specially. + // If we get an error, or the file doesn't have debug information + // we just return. + if (dwarf_result != DW_DLV_OK) { + return r; + } + + dwarf_handle.reset(dwarf_debug); + + r.file_handle = move(file_handle); + r.elf_handle = move(elf_handle); + r.dwarf_handle = move(dwarf_handle); + + return r; + } + + die_cache_entry &get_die_cache(dwarf_fileobject &fobj, Dwarf_Die die) { + Dwarf_Error error = DW_DLE_NE; + + // Get the die offset, we use it as the cache key + Dwarf_Off die_offset; + if (dwarf_dieoffset(die, &die_offset, &error) != DW_DLV_OK) { + die_offset = 0; + } + + die_cache_t::iterator it = fobj.die_cache.find(die_offset); + + if (it != fobj.die_cache.end()) { + fobj.current_cu = &it->second; + return it->second; + } + + die_cache_entry &de = fobj.die_cache[die_offset]; + fobj.current_cu = &de; + + Dwarf_Addr line_addr; + Dwarf_Small table_count; + + // The addresses in the line section are not fully sorted (they might + // be sorted by block of code belonging to the same file), which makes + // it necessary to do so before searching is possible. + // + // As libdwarf allocates a copy of everything, let's get the contents + // of the line section and keep it around. We also create a map of + // program counter to line table indices so we can search by address + // and get the line buffer index. + // + // To make things more difficult, the same address can span more than + // one line, so we need to keep the index pointing to the first line + // by using insert instead of the map's [ operator. + + // Get the line context for the DIE + if (dwarf_srclines_b(die, 0, &table_count, &de.line_context, &error) == + DW_DLV_OK) { + // Get the source lines for this line context, to be deallocated + // later + if (dwarf_srclines_from_linecontext(de.line_context, &de.line_buffer, + &de.line_count, + &error) == DW_DLV_OK) { + + // Add all the addresses to our map + for (int i = 0; i < de.line_count; i++) { + if (dwarf_lineaddr(de.line_buffer[i], &line_addr, &error) != + DW_DLV_OK) { + line_addr = 0; + } + de.line_section.insert(std::pair(line_addr, i)); + } + } + } + + // For each CU, cache the function DIEs that contain the + // DW_AT_specification attribute. When building with -g3 the function + // DIEs are separated in declaration and specification, with the + // declaration containing only the name and parameters and the + // specification the low/high pc and other compiler attributes. + // + // We cache those specifications so we don't skip over the declarations, + // because they have no pc, and we can do namespace resolution for + // DWARF function names. + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + Dwarf_Die current_die = 0; + if (dwarf_child(die, ¤t_die, &error) == DW_DLV_OK) { + for (;;) { + Dwarf_Die sibling_die = 0; + + Dwarf_Half tag_value; + dwarf_tag(current_die, &tag_value, &error); + + if (tag_value == DW_TAG_subprogram || + tag_value == DW_TAG_inlined_subroutine) { + + Dwarf_Bool has_attr = 0; + if (dwarf_hasattr(current_die, DW_AT_specification, &has_attr, + &error) == DW_DLV_OK) { + if (has_attr) { + Dwarf_Attribute attr_mem; + if (dwarf_attr(current_die, DW_AT_specification, &attr_mem, + &error) == DW_DLV_OK) { + Dwarf_Off spec_offset = 0; + if (dwarf_formref(attr_mem, &spec_offset, &error) == + DW_DLV_OK) { + Dwarf_Off spec_die_offset; + if (dwarf_dieoffset(current_die, &spec_die_offset, &error) == + DW_DLV_OK) { + de.spec_section[spec_offset] = spec_die_offset; + } + } + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + } + } + + int result = dwarf_siblingof(dwarf, current_die, &sibling_die, &error); + if (result == DW_DLV_ERROR) { + break; + } else if (result == DW_DLV_NO_ENTRY) { + break; + } + + if (current_die != die) { + dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); + current_die = 0; + } + + current_die = sibling_die; + } + } + return de; + } + + static Dwarf_Die get_referenced_die(Dwarf_Debug dwarf, Dwarf_Die die, + Dwarf_Half attr, bool global) { + Dwarf_Error error = DW_DLE_NE; + Dwarf_Attribute attr_mem; + + Dwarf_Die found_die = NULL; + if (dwarf_attr(die, attr, &attr_mem, &error) == DW_DLV_OK) { + Dwarf_Off offset; + int result = 0; + if (global) { + result = dwarf_global_formref(attr_mem, &offset, &error); + } else { + result = dwarf_formref(attr_mem, &offset, &error); + } + + if (result == DW_DLV_OK) { + if (dwarf_offdie(dwarf, offset, &found_die, &error) != DW_DLV_OK) { + found_die = NULL; + } + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + return found_die; + } + + static std::string get_referenced_die_name(Dwarf_Debug dwarf, Dwarf_Die die, + Dwarf_Half attr, bool global) { + Dwarf_Error error = DW_DLE_NE; + std::string value; + + Dwarf_Die found_die = get_referenced_die(dwarf, die, attr, global); + + if (found_die) { + char *name; + if (dwarf_diename(found_die, &name, &error) == DW_DLV_OK) { + if (name) { + value = std::string(name); + } + dwarf_dealloc(dwarf, name, DW_DLA_STRING); + } + dwarf_dealloc(dwarf, found_die, DW_DLA_DIE); + } + + return value; + } + + // Returns a spec DIE linked to the passed one. The caller should + // deallocate the DIE + static Dwarf_Die get_spec_die(dwarf_fileobject &fobj, Dwarf_Die die) { + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + Dwarf_Error error = DW_DLE_NE; + Dwarf_Off die_offset; + if (fobj.current_cu && + dwarf_die_CU_offset(die, &die_offset, &error) == DW_DLV_OK) { + die_specmap_t::iterator it = + fobj.current_cu->spec_section.find(die_offset); + + // If we have a DIE that completes the current one, check if + // that one has the pc we are looking for + if (it != fobj.current_cu->spec_section.end()) { + Dwarf_Die spec_die = 0; + if (dwarf_offdie(dwarf, it->second, &spec_die, &error) == DW_DLV_OK) { + return spec_die; + } + } + } + + // Maybe we have an abstract origin DIE with the function information? + return get_referenced_die(fobj.dwarf_handle.get(), die, + DW_AT_abstract_origin, true); + } + + static bool die_has_pc(dwarf_fileobject &fobj, Dwarf_Die die, Dwarf_Addr pc) { + Dwarf_Addr low_pc = 0, high_pc = 0; + Dwarf_Half high_pc_form = 0; + Dwarf_Form_Class return_class; + Dwarf_Error error = DW_DLE_NE; + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + bool has_lowpc = false; + bool has_highpc = false; + bool has_ranges = false; + + if (dwarf_lowpc(die, &low_pc, &error) == DW_DLV_OK) { + // If we have a low_pc check if there is a high pc. + // If we don't have a high pc this might mean we have a base + // address for the ranges list or just an address. + has_lowpc = true; + + if (dwarf_highpc_b(die, &high_pc, &high_pc_form, &return_class, &error) == + DW_DLV_OK) { + // We do have a high pc. In DWARF 4+ this is an offset from the + // low pc, but in earlier versions it's an absolute address. + + has_highpc = true; + // In DWARF 2/3 this would be a DW_FORM_CLASS_ADDRESS + if (return_class == DW_FORM_CLASS_CONSTANT) { + high_pc = low_pc + high_pc; + } + + // We have low and high pc, check if our address + // is in that range + return pc >= low_pc && pc < high_pc; + } + } else { + // Reset the low_pc, in case dwarf_lowpc failing set it to some + // undefined value. + low_pc = 0; + } + + // Check if DW_AT_ranges is present and search for the PC in the + // returned ranges list. We always add the low_pc, as it not set it will + // be 0, in case we had a DW_AT_low_pc and DW_AT_ranges pair + bool result = false; + + Dwarf_Attribute attr; + if (dwarf_attr(die, DW_AT_ranges, &attr, &error) == DW_DLV_OK) { + + Dwarf_Off offset; + if (dwarf_global_formref(attr, &offset, &error) == DW_DLV_OK) { + Dwarf_Ranges *ranges; + Dwarf_Signed ranges_count = 0; + Dwarf_Unsigned byte_count = 0; + + if (dwarf_get_ranges_a(dwarf, offset, die, &ranges, &ranges_count, + &byte_count, &error) == DW_DLV_OK) { + has_ranges = ranges_count != 0; + for (int i = 0; i < ranges_count; i++) { + if (ranges[i].dwr_addr1 != 0 && + pc >= ranges[i].dwr_addr1 + low_pc && + pc < ranges[i].dwr_addr2 + low_pc) { + result = true; + break; + } + } + dwarf_ranges_dealloc(dwarf, ranges, ranges_count); + } + } + } + + // Last attempt. We might have a single address set as low_pc. + if (!result && low_pc != 0 && pc == low_pc) { + result = true; + } + + // If we don't have lowpc, highpc and ranges maybe this DIE is a + // declaration that relies on a DW_AT_specification DIE that happens + // later. Use the specification cache we filled when we loaded this CU. + if (!result && (!has_lowpc && !has_highpc && !has_ranges)) { + Dwarf_Die spec_die = get_spec_die(fobj, die); + if (spec_die) { + result = die_has_pc(fobj, spec_die, pc); + dwarf_dealloc(dwarf, spec_die, DW_DLA_DIE); + } + } + + return result; + } + + static void get_type(Dwarf_Debug dwarf, Dwarf_Die die, std::string &type) { + Dwarf_Error error = DW_DLE_NE; + + Dwarf_Die child = 0; + if (dwarf_child(die, &child, &error) == DW_DLV_OK) { + get_type(dwarf, child, type); + } + + if (child) { + type.insert(0, "::"); + dwarf_dealloc(dwarf, child, DW_DLA_DIE); + } + + char *name; + if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { + type.insert(0, std::string(name)); + dwarf_dealloc(dwarf, name, DW_DLA_STRING); + } else { + type.insert(0, ""); + } + } + + static std::string get_type_by_signature(Dwarf_Debug dwarf, Dwarf_Die die) { + Dwarf_Error error = DW_DLE_NE; + + Dwarf_Sig8 signature; + Dwarf_Bool has_attr = 0; + if (dwarf_hasattr(die, DW_AT_signature, &has_attr, &error) == DW_DLV_OK) { + if (has_attr) { + Dwarf_Attribute attr_mem; + if (dwarf_attr(die, DW_AT_signature, &attr_mem, &error) == DW_DLV_OK) { + if (dwarf_formsig8(attr_mem, &signature, &error) != DW_DLV_OK) { + return std::string(""); + } + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + } + + Dwarf_Unsigned next_cu_header; + Dwarf_Sig8 tu_signature; + std::string result; + bool found = false; + + while (dwarf_next_cu_header_d(dwarf, 0, 0, 0, 0, 0, 0, 0, &tu_signature, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + + if (strncmp(signature.signature, tu_signature.signature, 8) == 0) { + Dwarf_Die type_cu_die = 0; + if (dwarf_siblingof_b(dwarf, 0, 0, &type_cu_die, &error) == DW_DLV_OK) { + Dwarf_Die child_die = 0; + if (dwarf_child(type_cu_die, &child_die, &error) == DW_DLV_OK) { + get_type(dwarf, child_die, result); + found = !result.empty(); + dwarf_dealloc(dwarf, child_die, DW_DLA_DIE); + } + dwarf_dealloc(dwarf, type_cu_die, DW_DLA_DIE); + } + } + } + + if (found) { + while (dwarf_next_cu_header_d(dwarf, 0, 0, 0, 0, 0, 0, 0, 0, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + // Reset the cu header state. Unfortunately, libdwarf's + // next_cu_header API keeps its own iterator per Dwarf_Debug + // that can't be reset. We need to keep fetching elements until + // the end. + } + } else { + // If we couldn't resolve the type just print out the signature + std::ostringstream string_stream; + string_stream << "<0x" << std::hex << std::setfill('0'); + for (int i = 0; i < 8; ++i) { + string_stream << std::setw(2) << std::hex + << (int)(unsigned char)(signature.signature[i]); + } + string_stream << ">"; + result = string_stream.str(); + } + return result; + } + + struct type_context_t { + bool is_const; + bool is_typedef; + bool has_type; + bool has_name; + std::string text; + + type_context_t() + : is_const(false), is_typedef(false), has_type(false), has_name(false) { + } + }; + + // Types are resolved from right to left: we get the variable name first + // and then all specifiers (like const or pointer) in a chain of DW_AT_type + // DIEs. Call this function recursively until we get a complete type + // string. + static void set_parameter_string(dwarf_fileobject &fobj, Dwarf_Die die, + type_context_t &context) { + char *name; + Dwarf_Error error = DW_DLE_NE; + + // typedefs contain also the base type, so we skip it and only + // print the typedef name + if (!context.is_typedef) { + if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { + if (!context.text.empty()) { + context.text.insert(0, " "); + } + context.text.insert(0, std::string(name)); + dwarf_dealloc(fobj.dwarf_handle.get(), name, DW_DLA_STRING); + } + } else { + context.is_typedef = false; + context.has_type = true; + if (context.is_const) { + context.text.insert(0, "const "); + context.is_const = false; + } + } + + bool next_type_is_const = false; + bool is_keyword = true; + + Dwarf_Half tag = 0; + Dwarf_Bool has_attr = 0; + if (dwarf_tag(die, &tag, &error) == DW_DLV_OK) { + switch (tag) { + case DW_TAG_structure_type: + case DW_TAG_union_type: + case DW_TAG_class_type: + case DW_TAG_enumeration_type: + context.has_type = true; + if (dwarf_hasattr(die, DW_AT_signature, &has_attr, &error) == + DW_DLV_OK) { + // If we have a signature it means the type is defined + // in .debug_types, so we need to load the DIE pointed + // at by the signature and resolve it + if (has_attr) { + std::string type = + get_type_by_signature(fobj.dwarf_handle.get(), die); + if (context.is_const) + type.insert(0, "const "); + + if (!context.text.empty()) + context.text.insert(0, " "); + context.text.insert(0, type); + } + + // Treat enums like typedefs, and skip printing its + // base type + context.is_typedef = (tag == DW_TAG_enumeration_type); + } + break; + case DW_TAG_const_type: + next_type_is_const = true; + break; + case DW_TAG_pointer_type: + context.text.insert(0, "*"); + break; + case DW_TAG_reference_type: + context.text.insert(0, "&"); + break; + case DW_TAG_restrict_type: + context.text.insert(0, "restrict "); + break; + case DW_TAG_rvalue_reference_type: + context.text.insert(0, "&&"); + break; + case DW_TAG_volatile_type: + context.text.insert(0, "volatile "); + break; + case DW_TAG_typedef: + // Propagate the const-ness to the next type + // as typedefs are linked to its base type + next_type_is_const = context.is_const; + context.is_typedef = true; + context.has_type = true; + break; + case DW_TAG_base_type: + context.has_type = true; + break; + case DW_TAG_formal_parameter: + context.has_name = true; + break; + default: + is_keyword = false; + break; + } + } + + if (!is_keyword && context.is_const) { + context.text.insert(0, "const "); + } + + context.is_const = next_type_is_const; + + Dwarf_Die ref = + get_referenced_die(fobj.dwarf_handle.get(), die, DW_AT_type, true); + if (ref) { + set_parameter_string(fobj, ref, context); + dwarf_dealloc(fobj.dwarf_handle.get(), ref, DW_DLA_DIE); + } + + if (!context.has_type && context.has_name) { + context.text.insert(0, "void "); + context.has_type = true; + } + } + + // Resolve the function return type and parameters + static void set_function_parameters(std::string &function_name, + std::vector &ns, + dwarf_fileobject &fobj, Dwarf_Die die) { + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + Dwarf_Error error = DW_DLE_NE; + Dwarf_Die current_die = 0; + std::string parameters; + bool has_spec = true; + // Check if we have a spec DIE. If we do we use it as it contains + // more information, like parameter names. + Dwarf_Die spec_die = get_spec_die(fobj, die); + if (!spec_die) { + has_spec = false; + spec_die = die; + } + + std::vector::const_iterator it = ns.begin(); + std::string ns_name; + for (it = ns.begin(); it < ns.end(); ++it) { + ns_name.append(*it).append("::"); + } + + if (!ns_name.empty()) { + function_name.insert(0, ns_name); + } + + // See if we have a function return type. It can be either on the + // current die or in its spec one (usually true for inlined functions) + std::string return_type = + get_referenced_die_name(dwarf, die, DW_AT_type, true); + if (return_type.empty()) { + return_type = get_referenced_die_name(dwarf, spec_die, DW_AT_type, true); + } + if (!return_type.empty()) { + return_type.append(" "); + function_name.insert(0, return_type); + } + + if (dwarf_child(spec_die, ¤t_die, &error) == DW_DLV_OK) { + for (;;) { + Dwarf_Die sibling_die = 0; + + Dwarf_Half tag_value; + dwarf_tag(current_die, &tag_value, &error); + + if (tag_value == DW_TAG_formal_parameter) { + // Ignore artificial (ie, compiler generated) parameters + bool is_artificial = false; + Dwarf_Attribute attr_mem; + if (dwarf_attr(current_die, DW_AT_artificial, &attr_mem, &error) == + DW_DLV_OK) { + Dwarf_Bool flag = 0; + if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) { + is_artificial = flag != 0; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + + if (!is_artificial) { + type_context_t context; + set_parameter_string(fobj, current_die, context); + + if (parameters.empty()) { + parameters.append("("); + } else { + parameters.append(", "); + } + parameters.append(context.text); + } + } + + int result = dwarf_siblingof(dwarf, current_die, &sibling_die, &error); + if (result == DW_DLV_ERROR) { + break; + } else if (result == DW_DLV_NO_ENTRY) { + break; + } + + if (current_die != die) { + dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); + current_die = 0; + } + + current_die = sibling_die; + } + } + if (parameters.empty()) + parameters = "("; + parameters.append(")"); + + // If we got a spec DIE we need to deallocate it + if (has_spec) + dwarf_dealloc(dwarf, spec_die, DW_DLA_DIE); + + function_name.append(parameters); + } + + // defined here because in C++98, template function cannot take locally + // defined types... grrr. + struct inliners_search_cb { + void operator()(Dwarf_Die die, std::vector &ns) { + Dwarf_Error error = DW_DLE_NE; + Dwarf_Half tag_value; + Dwarf_Attribute attr_mem; + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + + dwarf_tag(die, &tag_value, &error); + + switch (tag_value) { + char *name; + case DW_TAG_subprogram: + if (!trace.source.function.empty()) + break; + if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { + trace.source.function = std::string(name); + dwarf_dealloc(dwarf, name, DW_DLA_STRING); + } else { + // We don't have a function name in this DIE. + // Check if there is a referenced non-defining + // declaration. + trace.source.function = + get_referenced_die_name(dwarf, die, DW_AT_abstract_origin, true); + if (trace.source.function.empty()) { + trace.source.function = + get_referenced_die_name(dwarf, die, DW_AT_specification, true); + } + } + + // Append the function parameters, if available + set_function_parameters(trace.source.function, ns, fobj, die); + + // If the object function name is empty, it's possible that + // there is no dynamic symbol table (maybe the executable + // was stripped or not built with -rdynamic). See if we have + // a DWARF linkage name to use instead. We try both + // linkage_name and MIPS_linkage_name because the MIPS tag + // was the unofficial one until it was adopted in DWARF4. + // Old gcc versions generate MIPS_linkage_name + if (trace.object_function.empty()) { + details::demangler demangler; + + if (dwarf_attr(die, DW_AT_linkage_name, &attr_mem, &error) != + DW_DLV_OK) { + if (dwarf_attr(die, DW_AT_MIPS_linkage_name, &attr_mem, &error) != + DW_DLV_OK) { + break; + } + } + + char *linkage; + if (dwarf_formstring(attr_mem, &linkage, &error) == DW_DLV_OK) { + trace.object_function = demangler.demangle(linkage); + dwarf_dealloc(dwarf, linkage, DW_DLA_STRING); + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + break; + + case DW_TAG_inlined_subroutine: + ResolvedTrace::SourceLoc sloc; + + if (dwarf_diename(die, &name, &error) == DW_DLV_OK) { + sloc.function = std::string(name); + dwarf_dealloc(dwarf, name, DW_DLA_STRING); + } else { + // We don't have a name for this inlined DIE, it could + // be that there is an abstract origin instead. + // Get the DW_AT_abstract_origin value, which is a + // reference to the source DIE and try to get its name + sloc.function = + get_referenced_die_name(dwarf, die, DW_AT_abstract_origin, true); + } + + set_function_parameters(sloc.function, ns, fobj, die); + + std::string file = die_call_file(dwarf, die, cu_die); + if (!file.empty()) + sloc.filename = file; + + Dwarf_Unsigned number = 0; + if (dwarf_attr(die, DW_AT_call_line, &attr_mem, &error) == DW_DLV_OK) { + if (dwarf_formudata(attr_mem, &number, &error) == DW_DLV_OK) { + sloc.line = number; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + + if (dwarf_attr(die, DW_AT_call_column, &attr_mem, &error) == + DW_DLV_OK) { + if (dwarf_formudata(attr_mem, &number, &error) == DW_DLV_OK) { + sloc.col = number; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + + trace.inliners.push_back(sloc); + break; + }; + } + ResolvedTrace &trace; + dwarf_fileobject &fobj; + Dwarf_Die cu_die; + inliners_search_cb(ResolvedTrace &t, dwarf_fileobject &f, Dwarf_Die c) + : trace(t), fobj(f), cu_die(c) {} + }; + + static Dwarf_Die find_fundie_by_pc(dwarf_fileobject &fobj, + Dwarf_Die parent_die, Dwarf_Addr pc, + Dwarf_Die result) { + Dwarf_Die current_die = 0; + Dwarf_Error error = DW_DLE_NE; + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + + if (dwarf_child(parent_die, ¤t_die, &error) != DW_DLV_OK) { + return NULL; + } + + for (;;) { + Dwarf_Die sibling_die = 0; + Dwarf_Half tag_value; + dwarf_tag(current_die, &tag_value, &error); + + switch (tag_value) { + case DW_TAG_subprogram: + case DW_TAG_inlined_subroutine: + if (die_has_pc(fobj, current_die, pc)) { + return current_die; + } + }; + bool declaration = false; + Dwarf_Attribute attr_mem; + if (dwarf_attr(current_die, DW_AT_declaration, &attr_mem, &error) == + DW_DLV_OK) { + Dwarf_Bool flag = 0; + if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) { + declaration = flag != 0; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + + if (!declaration) { + // let's be curious and look deeper in the tree, functions are + // not necessarily at the first level, but might be nested + // inside a namespace, structure, a function, an inlined + // function etc. + Dwarf_Die die_mem = 0; + Dwarf_Die indie = find_fundie_by_pc(fobj, current_die, pc, die_mem); + if (indie) { + result = die_mem; + return result; + } + } + + int res = dwarf_siblingof(dwarf, current_die, &sibling_die, &error); + if (res == DW_DLV_ERROR) { + return NULL; + } else if (res == DW_DLV_NO_ENTRY) { + break; + } + + if (current_die != parent_die) { + dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); + current_die = 0; + } + + current_die = sibling_die; + } + return NULL; + } + + template + static bool deep_first_search_by_pc(dwarf_fileobject &fobj, + Dwarf_Die parent_die, Dwarf_Addr pc, + std::vector &ns, CB cb) { + Dwarf_Die current_die = 0; + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + Dwarf_Error error = DW_DLE_NE; + + if (dwarf_child(parent_die, ¤t_die, &error) != DW_DLV_OK) { + return false; + } + + bool branch_has_pc = false; + bool has_namespace = false; + for (;;) { + Dwarf_Die sibling_die = 0; + + Dwarf_Half tag; + if (dwarf_tag(current_die, &tag, &error) == DW_DLV_OK) { + if (tag == DW_TAG_namespace || tag == DW_TAG_class_type) { + char *ns_name = NULL; + if (dwarf_diename(current_die, &ns_name, &error) == DW_DLV_OK) { + if (ns_name) { + ns.push_back(std::string(ns_name)); + } else { + ns.push_back(""); + } + dwarf_dealloc(dwarf, ns_name, DW_DLA_STRING); + } else { + ns.push_back(""); + } + has_namespace = true; + } + } + + bool declaration = false; + Dwarf_Attribute attr_mem; + if (tag != DW_TAG_class_type && + dwarf_attr(current_die, DW_AT_declaration, &attr_mem, &error) == + DW_DLV_OK) { + Dwarf_Bool flag = 0; + if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) { + declaration = flag != 0; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + } + + if (!declaration) { + // let's be curious and look deeper in the tree, function are + // not necessarily at the first level, but might be nested + // inside a namespace, structure, a function, an inlined + // function etc. + branch_has_pc = deep_first_search_by_pc(fobj, current_die, pc, ns, cb); + } + + if (!branch_has_pc) { + branch_has_pc = die_has_pc(fobj, current_die, pc); + } + + if (branch_has_pc) { + cb(current_die, ns); + } + + int result = dwarf_siblingof(dwarf, current_die, &sibling_die, &error); + if (result == DW_DLV_ERROR) { + return false; + } else if (result == DW_DLV_NO_ENTRY) { + break; + } + + if (current_die != parent_die) { + dwarf_dealloc(dwarf, current_die, DW_DLA_DIE); + current_die = 0; + } + + if (has_namespace) { + has_namespace = false; + ns.pop_back(); + } + current_die = sibling_die; + } + + if (has_namespace) { + ns.pop_back(); + } + return branch_has_pc; + } + + static std::string die_call_file(Dwarf_Debug dwarf, Dwarf_Die die, + Dwarf_Die cu_die) { + Dwarf_Attribute attr_mem; + Dwarf_Error error = DW_DLE_NE; + Dwarf_Unsigned file_index; + + std::string file; + + if (dwarf_attr(die, DW_AT_call_file, &attr_mem, &error) == DW_DLV_OK) { + if (dwarf_formudata(attr_mem, &file_index, &error) != DW_DLV_OK) { + file_index = 0; + } + dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR); + + if (file_index == 0) { + return file; + } + + char **srcfiles = 0; + Dwarf_Signed file_count = 0; + if (dwarf_srcfiles(cu_die, &srcfiles, &file_count, &error) == DW_DLV_OK) { + if (file_count > 0 && file_index <= static_cast(file_count)) { + file = std::string(srcfiles[file_index - 1]); + } + + // Deallocate all strings! + for (int i = 0; i < file_count; ++i) { + dwarf_dealloc(dwarf, srcfiles[i], DW_DLA_STRING); + } + dwarf_dealloc(dwarf, srcfiles, DW_DLA_LIST); + } + } + return file; + } + + Dwarf_Die find_die(dwarf_fileobject &fobj, Dwarf_Addr addr) { + // Let's get to work! First see if we have a debug_aranges section so + // we can speed up the search + + Dwarf_Debug dwarf = fobj.dwarf_handle.get(); + Dwarf_Error error = DW_DLE_NE; + Dwarf_Arange *aranges; + Dwarf_Signed arange_count; + + Dwarf_Die returnDie; + bool found = false; + if (dwarf_get_aranges(dwarf, &aranges, &arange_count, &error) != + DW_DLV_OK) { + aranges = NULL; + } + + if (aranges) { + // We have aranges. Get the one where our address is. + Dwarf_Arange arange; + if (dwarf_get_arange(aranges, arange_count, addr, &arange, &error) == + DW_DLV_OK) { + + // We found our address. Get the compilation-unit DIE offset + // represented by the given address range. + Dwarf_Off cu_die_offset; + if (dwarf_get_cu_die_offset(arange, &cu_die_offset, &error) == + DW_DLV_OK) { + // Get the DIE at the offset returned by the aranges search. + // We set is_info to 1 to specify that the offset is from + // the .debug_info section (and not .debug_types) + int dwarf_result = + dwarf_offdie_b(dwarf, cu_die_offset, 1, &returnDie, &error); + + found = dwarf_result == DW_DLV_OK; + } + dwarf_dealloc(dwarf, arange, DW_DLA_ARANGE); + } + } + + if (found) + return returnDie; // The caller is responsible for freeing the die + + // The search for aranges failed. Try to find our address by scanning + // all compilation units. + Dwarf_Unsigned next_cu_header; + Dwarf_Half tag = 0; + returnDie = 0; + + while (!found && + dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + + if (returnDie) + dwarf_dealloc(dwarf, returnDie, DW_DLA_DIE); + + if (dwarf_siblingof(dwarf, 0, &returnDie, &error) == DW_DLV_OK) { + if ((dwarf_tag(returnDie, &tag, &error) == DW_DLV_OK) && + tag == DW_TAG_compile_unit) { + if (die_has_pc(fobj, returnDie, addr)) { + found = true; + } + } + } + } + + if (found) { + while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + // Reset the cu header state. Libdwarf's next_cu_header API + // keeps its own iterator per Dwarf_Debug that can't be reset. + // We need to keep fetching elements until the end. + } + } + + if (found) + return returnDie; + + // We couldn't find any compilation units with ranges or a high/low pc. + // Try again by looking at all DIEs in all compilation units. + Dwarf_Die cudie; + while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + if (dwarf_siblingof(dwarf, 0, &cudie, &error) == DW_DLV_OK) { + Dwarf_Die die_mem = 0; + Dwarf_Die resultDie = find_fundie_by_pc(fobj, cudie, addr, die_mem); + + if (resultDie) { + found = true; + break; + } + } + } + + if (found) { + while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, + &next_cu_header, 0, &error) == DW_DLV_OK) { + // Reset the cu header state. Libdwarf's next_cu_header API + // keeps its own iterator per Dwarf_Debug that can't be reset. + // We need to keep fetching elements until the end. + } + } + + if (found) + return cudie; + + // We failed. + return NULL; + } +}; +#endif // BACKWARD_HAS_DWARF == 1 + +template <> +class TraceResolverImpl + : public TraceResolverLinuxImpl {}; + +#endif // BACKWARD_SYSTEM_LINUX + +#ifdef BACKWARD_SYSTEM_DARWIN + +template class TraceResolverDarwinImpl; + +template <> +class TraceResolverDarwinImpl + : public TraceResolverImplBase { +public: + void load_addresses(void *const*addresses, int address_count) override { + if (address_count == 0) { + return; + } + _symbols.reset(backtrace_symbols(addresses, address_count)); + } + + ResolvedTrace resolve(ResolvedTrace trace) override { + // parse: + // + + char *filename = _symbols[trace.idx]; + + // skip " " + while (*filename && *filename != ' ') + filename++; + while (*filename == ' ') + filename++; + + // find start of from end ( may contain a space) + char *p = filename + strlen(filename) - 1; + // skip to start of " + " + while (p > filename && *p != ' ') + p--; + while (p > filename && *p == ' ') + p--; + while (p > filename && *p != ' ') + p--; + while (p > filename && *p == ' ') + p--; + char *funcname_end = p + 1; + + // skip to start of "" + while (p > filename && *p != ' ') + p--; + char *funcname = p + 1; + + // skip to start of " " + while (p > filename && *p == ' ') + p--; + while (p > filename && *p != ' ') + p--; + while (p > filename && *p == ' ') + p--; + + // skip "", handling the case where it contains a + char *filename_end = p + 1; + if (p == filename) { + // something went wrong, give up + filename_end = filename + strlen(filename); + funcname = filename_end; + } + trace.object_filename.assign( + filename, filename_end); // ok even if filename_end is the ending \0 + // (then we assign entire string) + + if (*funcname) { // if it's not end of string + *funcname_end = '\0'; + + trace.object_function = this->demangle(funcname); + trace.object_function += " "; + trace.object_function += (funcname_end + 1); + trace.source.function = trace.object_function; // we cannot do better. + } + return trace; + } + +private: + details::handle _symbols; +}; + +template <> +class TraceResolverImpl + : public TraceResolverDarwinImpl {}; + +#endif // BACKWARD_SYSTEM_DARWIN + +#ifdef BACKWARD_SYSTEM_WINDOWS + +// Load all symbol info +// Based on: +// https://stackoverflow.com/questions/6205981/windows-c-stack-trace-from-a-running-app/28276227#28276227 + +struct module_data { + std::string image_name; + std::string module_name; + void *base_address; + DWORD load_size; +}; + +class get_mod_info { + HANDLE process; + static const int buffer_length = 4096; + +public: + get_mod_info(HANDLE h) : process(h) {} + + module_data operator()(HMODULE module) { + module_data ret; + char temp[buffer_length]; + MODULEINFO mi; + + GetModuleInformation(process, module, &mi, sizeof(mi)); + ret.base_address = mi.lpBaseOfDll; + ret.load_size = mi.SizeOfImage; + + GetModuleFileNameExA(process, module, temp, sizeof(temp)); + ret.image_name = temp; + GetModuleBaseNameA(process, module, temp, sizeof(temp)); + ret.module_name = temp; + std::vector img(ret.image_name.begin(), ret.image_name.end()); + std::vector mod(ret.module_name.begin(), ret.module_name.end()); + SymLoadModule64(process, 0, &img[0], &mod[0], (DWORD64)ret.base_address, + ret.load_size); + return ret; + } +}; + +template <> class TraceResolverImpl + : public TraceResolverImplBase { +public: + TraceResolverImpl() { + + HANDLE process = GetCurrentProcess(); + + std::vector modules; + DWORD cbNeeded; + std::vector module_handles(1); + SymInitialize(process, NULL, false); + DWORD symOptions = SymGetOptions(); + symOptions |= SYMOPT_LOAD_LINES | SYMOPT_UNDNAME; + SymSetOptions(symOptions); + EnumProcessModules(process, &module_handles[0], + module_handles.size() * sizeof(HMODULE), &cbNeeded); + module_handles.resize(cbNeeded / sizeof(HMODULE)); + EnumProcessModules(process, &module_handles[0], + module_handles.size() * sizeof(HMODULE), &cbNeeded); + std::transform(module_handles.begin(), module_handles.end(), + std::back_inserter(modules), get_mod_info(process)); + void *base = modules[0].base_address; + IMAGE_NT_HEADERS *h = ImageNtHeader(base); + image_type = h->FileHeader.Machine; + } + + static const int max_sym_len = 255; + struct symbol_t { + SYMBOL_INFO sym; + char buffer[max_sym_len]; + } sym; + + DWORD64 displacement; + + ResolvedTrace resolve(ResolvedTrace t) override { + HANDLE process = GetCurrentProcess(); + + char name[256]; + + memset(&sym, 0, sizeof(sym)); + sym.sym.SizeOfStruct = sizeof(SYMBOL_INFO); + sym.sym.MaxNameLen = max_sym_len; + + if (!SymFromAddr(process, (ULONG64)t.addr, &displacement, &sym.sym)) { + // TODO: error handling everywhere + char* lpMsgBuf; + DWORD dw = GetLastError(); + + if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (char*)&lpMsgBuf, 0, NULL)) { + std::fprintf(stderr, "%s\n", lpMsgBuf); + LocalFree(lpMsgBuf); + } + + // abort(); + } + UnDecorateSymbolName(sym.sym.Name, (PSTR)name, 256, UNDNAME_COMPLETE); + + DWORD offset = 0; + IMAGEHLP_LINE line; + if (SymGetLineFromAddr(process, (ULONG64)t.addr, &offset, &line)) { + t.object_filename = line.FileName; + t.source.filename = line.FileName; + t.source.line = line.LineNumber; + t.source.col = offset; + } + + t.source.function = name; + t.object_filename = ""; + t.object_function = name; + + return t; + } + + DWORD machine_type() const { return image_type; } + +private: + DWORD image_type; +}; + +#endif + +class TraceResolver : public TraceResolverImpl {}; + +/*************** CODE SNIPPET ***************/ + +class SourceFile { +public: + typedef std::vector > lines_t; + + SourceFile() {} + SourceFile(const std::string &path) { + // 1. If BACKWARD_CXX_SOURCE_PREFIXES is set then assume it contains + // a colon-separated list of path prefixes. Try prepending each + // to the given path until a valid file is found. + const std::vector &prefixes = get_paths_from_env_variable(); + for (size_t i = 0; i < prefixes.size(); ++i) { + // Double slashes (//) should not be a problem. + std::string new_path = prefixes[i] + '/' + path; + _file.reset(new std::ifstream(new_path.c_str())); + if (is_open()) + break; + } + // 2. If no valid file found then fallback to opening the path as-is. + if (!_file || !is_open()) { + _file.reset(new std::ifstream(path.c_str())); + } + } + bool is_open() const { return _file->is_open(); } + + lines_t &get_lines(unsigned line_start, unsigned line_count, lines_t &lines) { + using namespace std; + // This function make uses of the dumbest algo ever: + // 1) seek(0) + // 2) read lines one by one and discard until line_start + // 3) read line one by one until line_start + line_count + // + // If you are getting snippets many time from the same file, it is + // somewhat a waste of CPU, feel free to benchmark and propose a + // better solution ;) + + _file->clear(); + _file->seekg(0); + string line; + unsigned line_idx; + + for (line_idx = 1; line_idx < line_start; ++line_idx) { + std::getline(*_file, line); + if (!*_file) { + return lines; + } + } + + // think of it like a lambda in C++98 ;) + // but look, I will reuse it two times! + // What a good boy am I. + struct isspace { + bool operator()(char c) { return std::isspace(c); } + }; + + bool started = false; + for (; line_idx < line_start + line_count; ++line_idx) { + getline(*_file, line); + if (!*_file) { + return lines; + } + if (!started) { + if (std::find_if(line.begin(), line.end(), not_isspace()) == line.end()) + continue; + started = true; + } + lines.push_back(make_pair(line_idx, line)); + } + + lines.erase( + std::find_if(lines.rbegin(), lines.rend(), not_isempty()).base(), + lines.end()); + return lines; + } + + lines_t get_lines(unsigned line_start, unsigned line_count) { + lines_t lines; + return get_lines(line_start, line_count, lines); + } + + // there is no find_if_not in C++98, lets do something crappy to + // workaround. + struct not_isspace { + bool operator()(char c) { return !std::isspace(c); } + }; + // and define this one here because C++98 is not happy with local defined + // struct passed to template functions, fuuuu. + struct not_isempty { + bool operator()(const lines_t::value_type &p) { + return !(std::find_if(p.second.begin(), p.second.end(), not_isspace()) == + p.second.end()); + } + }; + + void swap(SourceFile &b) { _file.swap(b._file); } + +#ifdef BACKWARD_ATLEAST_CXX11 + SourceFile(SourceFile &&from) : _file(nullptr) { swap(from); } + SourceFile &operator=(SourceFile &&from) { + swap(from); + return *this; + } +#else + explicit SourceFile(const SourceFile &from) { + // some sort of poor man's move semantic. + swap(const_cast(from)); + } + SourceFile &operator=(const SourceFile &from) { + // some sort of poor man's move semantic. + swap(const_cast(from)); + return *this; + } +#endif + +private: + details::handle > + _file; + + std::vector get_paths_from_env_variable_impl() { + std::vector paths; + const char *prefixes_str = std::getenv("BACKWARD_CXX_SOURCE_PREFIXES"); + if (prefixes_str && prefixes_str[0]) { + paths = details::split_source_prefixes(prefixes_str); + } + return paths; + } + + const std::vector &get_paths_from_env_variable() { + static std::vector paths = get_paths_from_env_variable_impl(); + return paths; + } + +#ifdef BACKWARD_ATLEAST_CXX11 + SourceFile(const SourceFile &) = delete; + SourceFile &operator=(const SourceFile &) = delete; +#endif +}; + +class SnippetFactory { +public: + typedef SourceFile::lines_t lines_t; + + lines_t get_snippet(const std::string &filename, unsigned line_start, + unsigned context_size) { + + SourceFile &src_file = get_src_file(filename); + unsigned start = line_start - context_size / 2; + return src_file.get_lines(start, context_size); + } + + lines_t get_combined_snippet(const std::string &filename_a, unsigned line_a, + const std::string &filename_b, unsigned line_b, + unsigned context_size) { + SourceFile &src_file_a = get_src_file(filename_a); + SourceFile &src_file_b = get_src_file(filename_b); + + lines_t lines = + src_file_a.get_lines(line_a - context_size / 4, context_size / 2); + src_file_b.get_lines(line_b - context_size / 4, context_size / 2, lines); + return lines; + } + + lines_t get_coalesced_snippet(const std::string &filename, unsigned line_a, + unsigned line_b, unsigned context_size) { + SourceFile &src_file = get_src_file(filename); + + using std::max; + using std::min; + unsigned a = min(line_a, line_b); + unsigned b = max(line_a, line_b); + + if ((b - a) < (context_size / 3)) { + return src_file.get_lines((a + b - context_size + 1) / 2, context_size); + } + + lines_t lines = src_file.get_lines(a - context_size / 4, context_size / 2); + src_file.get_lines(b - context_size / 4, context_size / 2, lines); + return lines; + } + +private: + typedef details::hashtable::type src_files_t; + src_files_t _src_files; + + SourceFile &get_src_file(const std::string &filename) { + src_files_t::iterator it = _src_files.find(filename); + if (it != _src_files.end()) { + return it->second; + } + SourceFile &new_src_file = _src_files[filename]; + new_src_file = SourceFile(filename); + return new_src_file; + } +}; + +/*************** PRINTER ***************/ + +namespace ColorMode { +enum type { automatic, never, always }; +} + +class cfile_streambuf : public std::streambuf { +public: + cfile_streambuf(FILE *_sink) : sink(_sink) {} + int_type underflow() override { return traits_type::eof(); } + int_type overflow(int_type ch) override { + if (traits_type::not_eof(ch) && fputc(ch, sink) != EOF) { + return ch; + } + return traits_type::eof(); + } + + std::streamsize xsputn(const char_type *s, std::streamsize count) override { + return static_cast( + fwrite(s, sizeof *s, static_cast(count), sink)); + } + +#ifdef BACKWARD_ATLEAST_CXX11 +public: + cfile_streambuf(const cfile_streambuf &) = delete; + cfile_streambuf &operator=(const cfile_streambuf &) = delete; +#else +private: + cfile_streambuf(const cfile_streambuf &); + cfile_streambuf &operator=(const cfile_streambuf &); +#endif + +private: + FILE *sink; + std::vector buffer; +}; + +#ifdef BACKWARD_SYSTEM_LINUX + +namespace Color { +enum type { yellow = 33, purple = 35, reset = 39 }; +} // namespace Color + +class Colorize { +public: + Colorize(std::ostream &os) : _os(os), _reset(false), _enabled(false) {} + + void activate(ColorMode::type mode) { _enabled = mode == ColorMode::always; } + + void activate(ColorMode::type mode, FILE *fp) { activate(mode, fileno(fp)); } + + void set_color(Color::type ccode) { + if (!_enabled) + return; + + // I assume that the terminal can handle basic colors. Seriously I + // don't want to deal with all the termcap shit. + _os << "\033[" << static_cast(ccode) << "m"; + _reset = (ccode != Color::reset); + } + + ~Colorize() { + if (_reset) { + set_color(Color::reset); + } + } + +private: + void activate(ColorMode::type mode, int fd) { + activate(mode == ColorMode::automatic && isatty(fd) ? ColorMode::always + : mode); + } + + std::ostream &_os; + bool _reset; + bool _enabled; +}; + +#else // ndef BACKWARD_SYSTEM_LINUX + +namespace Color { +enum type { yellow = 0, purple = 0, reset = 0 }; +} // namespace Color + +class Colorize { +public: + Colorize(std::ostream &) {} + void activate(ColorMode::type) {} + void activate(ColorMode::type, FILE *) {} + void set_color(Color::type) {} +}; + +#endif // BACKWARD_SYSTEM_LINUX + +class Printer { +public: + bool snippet; + ColorMode::type color_mode; + bool address; + bool object; + int inliner_context_size; + int trace_context_size; + + Printer() + : snippet(true), color_mode(ColorMode::automatic), address(false), + object(false), inliner_context_size(5), trace_context_size(7) {} + + template FILE *print(ST &st, FILE *fp = stderr) { + cfile_streambuf obuf(fp); + std::ostream os(&obuf); + Colorize colorize(os); + colorize.activate(color_mode, fp); + print_stacktrace(st, os, colorize); + return fp; + } + + template std::ostream &print(ST &st, std::ostream &os) { + Colorize colorize(os); + colorize.activate(color_mode); + print_stacktrace(st, os, colorize); + return os; + } + + template + FILE *print(IT begin, IT end, FILE *fp = stderr, size_t thread_id = 0) { + cfile_streambuf obuf(fp); + std::ostream os(&obuf); + Colorize colorize(os); + colorize.activate(color_mode, fp); + print_stacktrace(begin, end, os, thread_id, colorize); + return fp; + } + + template + std::ostream &print(IT begin, IT end, std::ostream &os, + size_t thread_id = 0) { + Colorize colorize(os); + colorize.activate(color_mode); + print_stacktrace(begin, end, os, thread_id, colorize); + return os; + } + + TraceResolver const &resolver() const { return _resolver; } + +private: + TraceResolver _resolver; + SnippetFactory _snippets; + + template + void print_stacktrace(ST &st, std::ostream &os, Colorize &colorize) { + print_header(os, st.thread_id()); + _resolver.load_stacktrace(st); + for (size_t trace_idx = st.size(); trace_idx > 0; --trace_idx) { + print_trace(os, _resolver.resolve(st[trace_idx - 1]), colorize); + } + } + + template + void print_stacktrace(IT begin, IT end, std::ostream &os, size_t thread_id, + Colorize &colorize) { + print_header(os, thread_id); + for (; begin != end; ++begin) { + print_trace(os, *begin, colorize); + } + } + + void print_header(std::ostream &os, size_t thread_id) { + os << "Stack trace (most recent call last)"; + if (thread_id) { + os << " in thread " << thread_id; + } + os << ":\n"; + } + + void print_trace(std::ostream &os, const ResolvedTrace &trace, + Colorize &colorize) { + os << "#" << std::left << std::setw(2) << trace.idx << std::right; + bool already_indented = true; + + if (!trace.source.filename.size() || object) { + os << " Object \"" << trace.object_filename << "\", at " << trace.addr + << ", in " << trace.object_function << "\n"; + already_indented = false; + } + + for (size_t inliner_idx = trace.inliners.size(); inliner_idx > 0; + --inliner_idx) { + if (!already_indented) { + os << " "; + } + const ResolvedTrace::SourceLoc &inliner_loc = + trace.inliners[inliner_idx - 1]; + print_source_loc(os, " | ", inliner_loc); + if (snippet) { + print_snippet(os, " | ", inliner_loc, colorize, Color::purple, + inliner_context_size); + } + already_indented = false; + } + + if (trace.source.filename.size()) { + if (!already_indented) { + os << " "; + } + print_source_loc(os, " ", trace.source, trace.addr); + if (snippet) { + print_snippet(os, " ", trace.source, colorize, Color::yellow, + trace_context_size); + } + } + } + + void print_snippet(std::ostream &os, const char *indent, + const ResolvedTrace::SourceLoc &source_loc, + Colorize &colorize, Color::type color_code, + int context_size) { + using namespace std; + typedef SnippetFactory::lines_t lines_t; + + lines_t lines = _snippets.get_snippet(source_loc.filename, source_loc.line, + static_cast(context_size)); + + for (lines_t::const_iterator it = lines.begin(); it != lines.end(); ++it) { + if (it->first == source_loc.line) { + colorize.set_color(color_code); + os << indent << ">"; + } else { + os << indent << " "; + } + os << std::setw(4) << it->first << ": " << it->second << "\n"; + if (it->first == source_loc.line) { + colorize.set_color(Color::reset); + } + } + } + + void print_source_loc(std::ostream &os, const char *indent, + const ResolvedTrace::SourceLoc &source_loc, + void *addr = nullptr) { + os << indent << "Source \"" << source_loc.filename << "\", line " + << source_loc.line << ", in " << source_loc.function; + + if (address && addr != nullptr) { + os << " [" << addr << "]"; + } + os << "\n"; + } +}; + +/*************** SIGNALS HANDLING ***************/ + +#if defined(BACKWARD_SYSTEM_LINUX) || defined(BACKWARD_SYSTEM_DARWIN) + +class SignalHandling { +public: + static std::vector make_default_signals() { + const int posix_signals[] = { + // Signals for which the default action is "Core". + SIGABRT, // Abort signal from abort(3) + SIGBUS, // Bus error (bad memory access) + SIGFPE, // Floating point exception + SIGILL, // Illegal Instruction + SIGIOT, // IOT trap. A synonym for SIGABRT + SIGQUIT, // Quit from keyboard + SIGSEGV, // Invalid memory reference + SIGSYS, // Bad argument to routine (SVr4) + SIGTRAP, // Trace/breakpoint trap + SIGXCPU, // CPU time limit exceeded (4.2BSD) + SIGXFSZ, // File size limit exceeded (4.2BSD) +#if defined(BACKWARD_SYSTEM_DARWIN) + SIGEMT, // emulation instruction executed +#endif + }; + return std::vector(posix_signals, + posix_signals + + sizeof posix_signals / sizeof posix_signals[0]); + } + + SignalHandling(const std::vector &posix_signals = make_default_signals()) + : _loaded(false) { + bool success = true; + + const size_t stack_size = 1024 * 1024 * 8; + _stack_content.reset(static_cast(malloc(stack_size))); + if (_stack_content) { + stack_t ss; + ss.ss_sp = _stack_content.get(); + ss.ss_size = stack_size; + ss.ss_flags = 0; + if (sigaltstack(&ss, nullptr) < 0) { + success = false; + } + } else { + success = false; + } + + for (size_t i = 0; i < posix_signals.size(); ++i) { + struct sigaction action; + memset(&action, 0, sizeof action); + action.sa_flags = + static_cast(SA_SIGINFO | SA_ONSTACK | SA_NODEFER | SA_RESETHAND); + sigfillset(&action.sa_mask); + sigdelset(&action.sa_mask, posix_signals[i]); +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdisabled-macro-expansion" +#endif + action.sa_sigaction = &sig_handler; +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + + int r = sigaction(posix_signals[i], &action, nullptr); + if (r < 0) + success = false; + } + + _loaded = success; + } + + bool loaded() const { return _loaded; } + + static void handleSignal(int, siginfo_t *info, void *_ctx) { + ucontext_t *uctx = static_cast(_ctx); + + StackTrace st; + void *error_addr = nullptr; +#ifdef REG_RIP // x86_64 + error_addr = reinterpret_cast(uctx->uc_mcontext.gregs[REG_RIP]); +#elif defined(REG_EIP) // x86_32 + error_addr = reinterpret_cast(uctx->uc_mcontext.gregs[REG_EIP]); +#elif defined(__arm__) + error_addr = reinterpret_cast(uctx->uc_mcontext.arm_pc); +#elif defined(__aarch64__) + #if defined(__APPLE__) + error_addr = reinterpret_cast(uctx->uc_mcontext->__ss.__pc); + #else + error_addr = reinterpret_cast(uctx->uc_mcontext.pc); + #endif +#elif defined(__mips__) + error_addr = reinterpret_cast( + reinterpret_cast(&uctx->uc_mcontext)->sc_pc); +#elif defined(__ppc__) || defined(__powerpc) || defined(__powerpc__) || \ + defined(__POWERPC__) + error_addr = reinterpret_cast(uctx->uc_mcontext.regs->nip); +#elif defined(__riscv) + error_addr = reinterpret_cast(uctx->uc_mcontext.__gregs[REG_PC]); +#elif defined(__s390x__) + error_addr = reinterpret_cast(uctx->uc_mcontext.psw.addr); +#elif defined(__APPLE__) && defined(__x86_64__) + error_addr = reinterpret_cast(uctx->uc_mcontext->__ss.__rip); +#elif defined(__APPLE__) + error_addr = reinterpret_cast(uctx->uc_mcontext->__ss.__eip); +#else +#warning ":/ sorry, ain't know no nothing none not of your architecture!" +#endif + if (error_addr) { + st.load_from(error_addr, 32, reinterpret_cast(uctx), + info->si_addr); + } else { + st.load_here(32, reinterpret_cast(uctx), info->si_addr); + } + + Printer printer; + printer.address = true; + printer.print(st, stderr); + +#if (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 700) || \ + (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200809L) + psiginfo(info, nullptr); +#else + (void)info; +#endif + } + +private: + details::handle _stack_content; + bool _loaded; + +#ifdef __GNUC__ + __attribute__((noreturn)) +#endif + static void + sig_handler(int signo, siginfo_t *info, void *_ctx) { + handleSignal(signo, info, _ctx); + + // try to forward the signal. + raise(info->si_signo); + + // terminate the process immediately. + puts("watf? exit"); + _exit(EXIT_FAILURE); + } +}; + +#endif // BACKWARD_SYSTEM_LINUX || BACKWARD_SYSTEM_DARWIN + +#ifdef BACKWARD_SYSTEM_WINDOWS + +class SignalHandling { +public: + SignalHandling(const std::vector & = std::vector()) + : reporter_thread_([]() { + /* We handle crashes in a utility thread: + backward structures and some Windows functions called here + need stack space, which we do not have when we encounter a + stack overflow. + To support reporting stack traces during a stack overflow, + we create a utility thread at startup, which waits until a + crash happens or the program exits normally. */ + + { + std::unique_lock lk(mtx()); + cv().wait(lk, [] { return crashed() != crash_status::running; }); + } + if (crashed() == crash_status::crashed) { + handle_stacktrace(skip_recs()); + } + { + std::unique_lock lk(mtx()); + crashed() = crash_status::ending; + } + cv().notify_one(); + }) { + SetUnhandledExceptionFilter(crash_handler); + + signal(SIGABRT, signal_handler); + _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT); + + std::set_terminate(&terminator); +#ifndef BACKWARD_ATLEAST_CXX17 + std::set_unexpected(&terminator); +#endif + _set_purecall_handler(&terminator); + _set_invalid_parameter_handler(&invalid_parameter_handler); + } + bool loaded() const { return true; } + + ~SignalHandling() { + { + std::unique_lock lk(mtx()); + crashed() = crash_status::normal_exit; + } + + cv().notify_one(); + + reporter_thread_.join(); + } + +private: + static CONTEXT *ctx() { + static CONTEXT data; + return &data; + } + + enum class crash_status { running, crashed, normal_exit, ending }; + + static crash_status &crashed() { + static crash_status data; + return data; + } + + static std::mutex &mtx() { + static std::mutex data; + return data; + } + + static std::condition_variable &cv() { + static std::condition_variable data; + return data; + } + + static HANDLE &thread_handle() { + static HANDLE handle; + return handle; + } + + std::thread reporter_thread_; + + // TODO: how not to hardcode these? + static const constexpr int signal_skip_recs = +#ifdef __clang__ + // With clang, RtlCaptureContext also captures the stack frame of the + // current function Below that, there ar 3 internal Windows functions + 4 +#else + // With MSVC cl, RtlCaptureContext misses the stack frame of the current + // function The first entries during StackWalk are the 3 internal Windows + // functions + 3 +#endif + ; + + static int &skip_recs() { + static int data; + return data; + } + + static inline void terminator() { + crash_handler(signal_skip_recs); + abort(); + } + + static inline void signal_handler(int) { + crash_handler(signal_skip_recs); + abort(); + } + + static inline void __cdecl invalid_parameter_handler(const wchar_t *, + const wchar_t *, + const wchar_t *, + unsigned int, + uintptr_t) { + crash_handler(signal_skip_recs); + abort(); + } + + NOINLINE static LONG WINAPI crash_handler(EXCEPTION_POINTERS *info) { + // The exception info supplies a trace from exactly where the issue was, + // no need to skip records + crash_handler(0, info->ContextRecord); + return EXCEPTION_CONTINUE_SEARCH; + } + + NOINLINE static void crash_handler(int skip, CONTEXT *ct = nullptr) { + + if (ct == nullptr) { + RtlCaptureContext(ctx()); + } else { + memcpy(ctx(), ct, sizeof(CONTEXT)); + } + DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), + GetCurrentProcess(), &thread_handle(), 0, FALSE, + DUPLICATE_SAME_ACCESS); + + skip_recs() = skip; + + { + std::unique_lock lk(mtx()); + crashed() = crash_status::crashed; + } + + cv().notify_one(); + + { + std::unique_lock lk(mtx()); + cv().wait(lk, [] { return crashed() != crash_status::crashed; }); + } + } + + static void handle_stacktrace(int skip_frames = 0) { + // printer creates the TraceResolver, which can supply us a machine type + // for stack walking. Without this, StackTrace can only guess using some + // macros. + // StackTrace also requires that the PDBs are already loaded, which is done + // in the constructor of TraceResolver + Printer printer; + + StackTrace st; + st.set_machine_type(printer.resolver().machine_type()); + st.set_thread_handle(thread_handle()); + st.load_here(32 + skip_frames, ctx()); + st.skip_n_firsts(skip_frames); + + printer.address = true; + printer.print(st, std::cerr); + } +}; + +#endif // BACKWARD_SYSTEM_WINDOWS + +#ifdef BACKWARD_SYSTEM_UNKNOWN + +class SignalHandling { +public: + SignalHandling(const std::vector & = std::vector()) {} + bool init() { return false; } + bool loaded() { return false; } +}; + +#endif // BACKWARD_SYSTEM_UNKNOWN + +} // namespace backward + +#endif /* H_GUARD */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/builds.sh b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/builds.sh new file mode 100755 index 0000000000000..6e1fb2074ed10 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/builds.sh @@ -0,0 +1,77 @@ +#!/bin/bash + +COMPILERS_CXX98=`cat</dev/null + ( + cd "$builddir" + cmake -DCMAKE_BUILD_TYPE=$buildtype -DBACKWARD_TESTS=ON .. + ) +} + +function build() { + local builddir=$1 + shift + make -C "$builddir" $@ +} + +function dotest() { + local builddir=$1 + shift + make -C "$builddir" test $@ + return 0 +} + +function do_action() { + local lang=$1 + local action=$2 + shift 2 + + for compiler in $COMPILERS; do + local builddir="build_${lang}_${compiler}" + + if [[ $action == "cmake" ]]; then + buildtype=$1 + mkbuild $compiler $lang "$buildtype" "$builddir" + [[ $? != 0 ]] && exit + elif [[ $action == "make" ]]; then + build "$builddir" $@ + [[ $? != 0 ]] && exit + elif [[ $action == "test" ]]; then + dotest "$builddir" $@ + [[ $? != 0 ]] && exit + elif [[ $action == "clean" ]]; then + rm -r "$builddir" + else + echo "usage: $0 cmake [debug|release|relwithdbg]|make|test|clean" + exit 255 + fi + done +} + +COMPILERS=$COMPILERS_CXX98 +do_action c++98 $@ +COMPILERS=$COMPILERS_CXX11 +do_action c++11 $@ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/conanfile.py b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/conanfile.py new file mode 100644 index 0000000000000..d174b257b95db --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/conanfile.py @@ -0,0 +1,45 @@ +from conans import ConanFile, CMake +import os + +class BackwardCpp(ConanFile): + settings = 'os', 'compiler', 'build_type', 'arch' + name = 'backward' + url = 'https://github.com/bombela/backward-cpp' + license = 'MIT' + version = '1.3.0' + options = { + 'stack_walking_unwind': [True, False], + 'stack_walking_backtrace': [True, False], + 'stack_details_auto_detect': [True, False], + 'stack_details_backtrace_symbol': [True, False], + 'stack_details_dw': [True, False], + 'stack_details_bfd': [True, False], + 'shared': [True, False] + } + default_options = ( + 'stack_walking_unwind=True', + 'stack_walking_backtrace=False', + 'stack_details_auto_detect=True', + 'stack_details_backtrace_symbol=False', + 'stack_details_dw=False', + 'stack_details_bfd=False', + 'shared=False' + ) + exports = 'backward.cpp', 'backward.hpp', 'test/*', 'CMakeLists.txt', 'BackwardConfig.cmake' + generators = 'cmake' + + def build(self): + cmake = CMake(self) + + cmake.configure(defs={'BACKWARD_' + name.upper(): value for name, value in self.options.values.as_list()}) + cmake.build() + + def package(self): + self.copy('backward.hpp', os.path.join('include', 'backward')) + self.copy('*.a', dst='lib') + self.copy('*.so', dst='lib') + self.copy('*.lib', dst='lib') + self.copy('*.dll', dst='lib') + + def package_info(self): + self.cpp_info.libs = ['backward'] diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/CMakeLists.txt new file mode 100644 index 0000000000000..81c5904eedbe6 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/CMakeLists.txt @@ -0,0 +1,12 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES +) + +set(HEADERS +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_third_party_backward-cpp_doc) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/nice.png b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/nice.png new file mode 100644 index 0000000000000..42147e5947b7f Binary files /dev/null and b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/nice.png differ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/pretty.png b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/pretty.png new file mode 100644 index 0000000000000..f95d66ee0be9e Binary files /dev/null and b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/pretty.png differ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/rude.png b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/rude.png new file mode 100644 index 0000000000000..6b27252eb087a Binary files /dev/null and b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/doc/rude.png differ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/CMakeLists.txt new file mode 100644 index 0000000000000..c5dad6896dde4 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/CMakeLists.txt @@ -0,0 +1,19 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + _test_main.cpp + rectrace.cpp + select_signals.cpp + stacktrace.cpp + suicide.cpp + test.cpp +) + +set(HEADERS + test.hpp +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_third_party_backward-cpp_test) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/_test_main.cpp b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/_test_main.cpp new file mode 100644 index 0000000000000..68211e030fd29 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/_test_main.cpp @@ -0,0 +1,241 @@ +/* + * _test_main.cpp + * Copyright 2013 Google Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "test.hpp" +#include +#include + +#ifdef _WIN32 +#include +#define strcasecmp _stricmp +#else +#include +#include +#endif + +#if defined(__has_include) && __has_include() +#include +#else +#include + +#ifdef _WIN32 +char argv0[MAX_PATH]; +inline const char *getprogname() { + return GetModuleFileName(NULL, argv0, sizeof(argv0)) ? argv0 : NULL; +} +#elif !defined(__APPLE__) +// N.B. getprogname() is an Apple/BSD-ism. +// program_invocation_name is a GLIBC-ism, but it's also +// supported by libmusl. +#define getprogname() program_invocation_name +#endif + +void error(int status, int errnum, const char *format, ...) { + fflush(stdout); + fprintf(stderr, "%s: ", getprogname()); + + va_list args; + va_start(args, format); + vfprintf(stderr, format, args); + va_end(args); + + if (errnum != 0) { + fprintf(stderr, ": %s\n", strerror(errnum)); + } else { + fprintf(stderr, "\n"); + } + if (status != 0) { + exit(status); + } +} +#endif + +using namespace test; + +bool run_test(TestBase &test, bool use_child_process = true) { + if (!use_child_process) { + exit(static_cast(test.run())); + } + + printf("-- running test case: %s\n", test.name); + + fflush(stdout); + + test::TestStatus status = test::SUCCESS; + +#ifdef _WIN32 + char filename[256]; + GetModuleFileName(NULL, filename, 256); // TODO: check for error + std::string cmd_line = filename; + cmd_line += " --nofork "; + cmd_line += test.name; + + STARTUPINFO si; + PROCESS_INFORMATION pi; + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + ZeroMemory(&pi, sizeof(pi)); + + if (!CreateProcessA(nullptr, const_cast(cmd_line.c_str()), nullptr, + nullptr, FALSE, 0, nullptr, nullptr, &si, &pi)) { + printf("unable to create process\n"); + exit(-1); + } + + WaitForSingleObject(pi.hProcess, INFINITE); + + DWORD exit_code; + GetExitCodeProcess(pi.hProcess, &exit_code); + switch (exit_code) { + case 3: + status = test::SIGNAL_ABORT; + break; + case 5: + status = test::EXCEPTION_UNCAUGHT; + break; + case EXCEPTION_ACCESS_VIOLATION: + status = test::SIGNAL_SEGFAULT; + break; + case EXCEPTION_STACK_OVERFLOW: + status = test::SIGNAL_SEGFAULT; + break; + case EXCEPTION_INT_DIVIDE_BY_ZERO: + status = test::SIGNAL_DIVZERO; + break; + } + printf("Exit code: %lu\n", exit_code); + + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + + if (test.expected_status == test::ASSERT_FAIL) { + // assert calls abort on windows + return (status & test::SIGNAL_ABORT); + } + +#else + + pid_t child_pid = fork(); + if (child_pid == 0) { + exit(static_cast(test.run())); + } + if (child_pid == -1) { + error(EXIT_FAILURE, 0, "unable to fork"); + } + + int child_status = 0; + waitpid(child_pid, &child_status, 0); + + if (WIFEXITED(child_status)) { + int exit_status = WEXITSTATUS(child_status); + if (exit_status & ~test::STATUS_MASK) { + status = test::FAILED; + } else { + status = static_cast(exit_status); + } + } else if (WIFSIGNALED(child_status)) { + const int signum = WTERMSIG(child_status); + printf("!! signal (%d) %s\n", signum, strsignal(signum)); + switch (signum) { + case SIGABRT: + status = test::SIGNAL_ABORT; + break; + case SIGSEGV: + case SIGBUS: + status = test::SIGNAL_SEGFAULT; + break; + case SIGFPE: + status = test::SIGNAL_DIVZERO; + break; + default: + status = test::SIGNAL_UNCAUGHT; + } + } + +#endif + + if (test.expected_status == test::FAILED) { + return (status & test::FAILED); + } + + if (test.expected_status == test::SIGNAL_UNCAUGHT) { + return (status & test::SIGNAL_UNCAUGHT); + } + + return status == test.expected_status; +} + +int main(int argc, const char *const argv[]) { + +#ifdef _WIN32 + _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT); +#endif + + if (argc == 3 && strcmp("--nofork", argv[1]) == 0) { + // Windows has no fork, so we simulate it + // we only execute one test, without forking + for (test_registry_t::iterator it = test_registry().begin(); + it != test_registry().end(); ++it) { + TestBase &test = **it; + if (strcasecmp(argv[2], test.name) == 0) { + run_test(test, false); + + return 0; + } + } + return -1; + } + + size_t success_cnt = 0; + size_t total_cnt = 0; + for (test_registry_t::iterator it = test_registry().begin(); + it != test_registry().end(); ++it) { + TestBase &test = **it; + + bool consider_test = (argc <= 1); + for (int i = 1; i < argc; ++i) { + if (strcasecmp(argv[i], test.name) == 0) { + consider_test = true; + break; + } + } + if (!consider_test) { + continue; + } + + total_cnt += 1; + if (run_test(test)) { + printf("-- test case success: %s\n", test.name); + success_cnt += 1; + } else { + printf("** test case FAILED : %s\n", test.name); + } + } + printf("-- tests passing: %zu/%zu", success_cnt, total_cnt); + if (total_cnt) { + printf(" (%zu%%)\n", success_cnt * 100 / total_cnt); + } else { + printf("\n"); + } + return (success_cnt == total_cnt) ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/rectrace.cpp b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/rectrace.cpp new file mode 100644 index 0000000000000..10a38f475a029 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/rectrace.cpp @@ -0,0 +1,98 @@ +/* + * test/rectrace.cpp + * Copyright 2013 Google Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "backward.hpp" +#include "test/test.hpp" +#include + +using namespace backward; + +typedef StackTrace stacktrace_t; + +void end_of_our_journey(stacktrace_t &st) { + if (!st.size()) { + st.load_here(); + } +} + +int rec(stacktrace_t &st, int level) { + if (level <= 1) { + end_of_our_journey(st); + return 0; + } + return rec(st, level - 1); +} + +namespace toto { + +namespace titi { + +struct foo { + + union bar { + NOINLINE static int trampoline(stacktrace_t &st, int level) { + return rec(st, level); + } + }; +}; + +} // namespace titi + +} // namespace toto + +TEST(recursion) { + { // lexical scope. + stacktrace_t st; + const int input = 3; + int r = toto::titi::foo::bar::trampoline(st, input); + + std::cout << "rec(" << input << ") == " << r << std::endl; + + Printer printer; + // printer.address = true; + printer.object = true; + printer.print(st, stdout); + } +} + +int fib(StackTrace &st, int level) { + if (level == 2) { + return 1; + } + if (level <= 1) { + end_of_our_journey(st); + return 0; + } + return fib(st, level - 1) + fib(st, level - 2); +} + +TEST(fibrecursive) { + StackTrace st; + const int input = 6; + int r = fib(st, input); + + std::cout << "fib(" << input << ") == " << r << std::endl; + + Printer printer; + printer.print(st, stdout); +} diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/select_signals.cpp b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/select_signals.cpp new file mode 100644 index 0000000000000..57e6ebe0877c1 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/select_signals.cpp @@ -0,0 +1,51 @@ +/* + * test/segfault.cpp + * Copyright 2013 Google Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "backward.hpp" + +#include "test/test.hpp" +#include +#include + +using namespace backward; + +void badass_function() { + char *ptr = (char *)42; + *ptr = 42; +} + +TEST_SEGFAULT(pprint_sigsev) { + std::vector signals; + signals.push_back(SIGSEGV); + SignalHandling sh(signals); + std::cout << std::boolalpha << "sh.loaded() == " << sh.loaded() << std::endl; + badass_function(); +} + +TEST_SEGFAULT(wont_pprint) { + std::vector signals; + signals.push_back(SIGABRT); + SignalHandling sh(signals); + std::cout << std::boolalpha << "sh.loaded() == " << sh.loaded() << std::endl; + badass_function(); +} diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/stacktrace.cpp b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/stacktrace.cpp new file mode 100644 index 0000000000000..47084fe7da01f --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/stacktrace.cpp @@ -0,0 +1,57 @@ +/* + * test/stacktrace.cpp + * Copyright 2013 Google Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "backward.hpp" +#include "test/test.hpp" +#include +#include + +using namespace backward; + +void collect_trace(StackTrace &st) { st.load_here(); } + +TEST(minitrace) { + Printer printer; + + StackTrace st; + collect_trace(st); + + printer.print(st, std::cout); +} + +void d(StackTrace &st) { st.load_here(); } + +void c(StackTrace &st) { return d(st); } + +void b(StackTrace &st) { return c(st); } + +NOINLINE void a(StackTrace &st) { return b(st); } + +TEST(smalltrace) { + Printer printer; + + StackTrace st; + a(st); + + printer.print(st, std::cout); +} diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/suicide.cpp b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/suicide.cpp new file mode 100644 index 0000000000000..e694c6fb46166 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/suicide.cpp @@ -0,0 +1,89 @@ +/* + * test/suicide.cpp + * Copyright 2013 Google Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "backward.hpp" + +#include "test/test.hpp" +#include + +#ifndef _WIN32 +#include +#endif + +using namespace backward; + +void badass_function() { + char *ptr = (char *)42; + *ptr = 42; +} + +TEST_SEGFAULT(invalid_write) { badass_function(); } + +int you_shall_not_pass() { + char *ptr = (char *)42; + int v = *ptr; + return v; +} + +TEST_SEGFAULT(invalid_read) { + int v = you_shall_not_pass(); + std::cout << "v=" << v << std::endl; +} + +void abort_abort_I_repeat_abort_abort() { + std::cout << "Jumping off the boat!" << std::endl; + abort(); +} + +TEST_ABORT(calling_abort) { abort_abort_I_repeat_abort_abort(); } + +// aarch64 and mips does not trap Division by zero +#if !defined(__aarch64__) && !defined(__mips__) +volatile int zero = 0; + +int divide_by_zero() { + std::cout << "And the wild black hole appears..." << std::endl; + int v = 42 / zero; + return v; +} + +TEST_DIVZERO(divide_by_zero) { + int v = divide_by_zero(); + std::cout << "v=" << v << std::endl; +} +#endif + +// Darwin does not allow RLIMIT_STACK to be reduced +#ifndef __APPLE__ +int bye_bye_stack(int i) { return bye_bye_stack(i + 1) + bye_bye_stack(i * 2); } + +TEST_SEGFAULT(stackoverflow) { +#ifndef _WIN32 + struct rlimit limit; + limit.rlim_max = 8096; + setrlimit(RLIMIT_STACK, &limit); +#endif + int r = bye_bye_stack(42); + std::cout << "r=" << r << std::endl; +} +#endif diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/test.cpp b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/test.cpp new file mode 100644 index 0000000000000..1a148f12cc2e2 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/test.cpp @@ -0,0 +1,63 @@ +/* + * test/test.cpp + * Copyright 2013 Google Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "test/test.hpp" +#include +#include +#include + +TEST(empty_test) {} + +TEST_FAIL_ASSERT(fail_assert) { ASSERT(1 == 2); } + +TEST_FAIL_ASSERT(fail_assert_ge) { ASSERT_GE(4, 5); } + +TEST_UNCAUGHT_EXCEPTION(uncaught_exception) { + throw std::runtime_error("some random runtime error"); +} + +TEST_UNCAUGHT_EXCEPTION(uncaught_exception_int) { throw 42; } + +TEST_SEGFAULT(segfault) { + char *a = 0; + char b = a[42]; + std::cout << "result: " << b << std::endl; +} + +TEST_ABORT(abort) { abort(); } + +TEST(catch_int) { + ASSERT_THROW({ throw 42; }, int); +} + +TEST_FAIL_ASSERT(fail_catch_int) { ASSERT_THROW({}, int); } + +TEST_FAIL_ASSERT(fail_no_throw) { + ASSERT_NO_THROW({ throw 42; }); +} + +TEST(any_throw) { + ASSERT_ANY_THROW({ throw 42; }); +} + +TEST_FAIL_ASSERT(fail_any_throw) { ASSERT_ANY_THROW({}); } diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/test.hpp b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/test.hpp new file mode 100644 index 0000000000000..dc77c627a16da --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test/test.hpp @@ -0,0 +1,183 @@ +/* + * test/test.hpp + * Copyright 2013 Google Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#pragma once +#ifndef H_54E531F7_9154_454B_BEB9_257408429470 +#define H_54E531F7_9154_454B_BEB9_257408429470 + +#include +#include +#include +#include +#include +#include + +namespace test { + +struct AssertFailedError : std::exception { + ~AssertFailedError() throw() {} + + AssertFailedError(const char *filename, int _line, const char *_errmsg) + : basename(_basename(filename)), line(_line), errmsg(_errmsg) {} + + const char *what() const throw() { + if (!_what.size()) { + std::ostringstream ss; + ss << "assertion failed (" << basename << ":" << line; + ss << ") " << errmsg; + _what = ss.str(); + } + return _what.c_str(); + } + + const char *basename; + int line; + const char *errmsg; + + mutable std::string _what; + + static const char *_basename(const char *filename) { + const char *basename = filename + strlen(filename); + while (basename != filename && *basename != '/') { + basename -= 1; + } + return basename + 1; + } +}; + +enum TestStatus { + SUCCESS = 0 << 0, + FAILED = 1 << 0, + + ASSERT_FAIL = FAILED | 1 << 1, + EXCEPTION_UNCAUGHT = FAILED | 2 << 1, + SIGNAL_UNCAUGHT = FAILED | 3 << 1, + SIGNAL_SEGFAULT = SIGNAL_UNCAUGHT | 1 << 3, + SIGNAL_ABORT = SIGNAL_UNCAUGHT | 2 << 3, + SIGNAL_DIVZERO = SIGNAL_UNCAUGHT | 2 << 3, + + STATUS_MASK = 0x1F +}; + +struct TestBase { + const char *name; + TestStatus expected_status; + + virtual ~TestBase() {} + TestBase(const char *, TestStatus); + virtual void do_test() = 0; + + TestStatus run() { + try { + do_test(); + return SUCCESS; + } catch (const AssertFailedError &e) { + printf("!! %s\n", e.what()); + return ASSERT_FAIL; + } catch (const std::exception &e) { + printf("!! exception: %s\n", e.what()); + return EXCEPTION_UNCAUGHT; + } catch (...) { + printf("!! unknown exception\n"); + return EXCEPTION_UNCAUGHT; + } + } +}; + +typedef std::vector test_registry_t; +inline test_registry_t &test_registry() { + static test_registry_t reg; + return reg; +} + +inline TestBase::TestBase(const char *n, TestStatus s) + : name(n), expected_status(s) { + test_registry().push_back(this); +} + +} // namespace test + +#define _TEST_STATUS(name, status) \ + struct TEST_##name : ::test::TestBase { \ + TEST_##name() : TestBase(#name, status) {} \ + void do_test(); \ + } TEST_##name; \ + void TEST_##name::do_test() + +#define TEST(name) _TEST_STATUS(name, ::test::SUCCESS) +#define TEST_FAIL(name) _TEST_STATUS(name, ::test::FAILED) +#define TEST_FAIL_ASSERT(name) _TEST_STATUS(name, ::test::ASSERT_FAIL) +#define TEST_UNCAUGHT_EXCEPTION(name) \ + _TEST_STATUS(name, ::test::EXCEPTION_UNCAUGHT) +#define TEST_UNCAUGHT_SIGNAL(name) _TEST_STATUS(name, ::test::SIGNAL_UNCAUGHT) +#define TEST_SEGFAULT(name) _TEST_STATUS(name, ::test::SIGNAL_SEGFAULT) +#define TEST_ABORT(name) _TEST_STATUS(name, ::test::SIGNAL_ABORT) +#define TEST_DIVZERO(name) _TEST_STATUS(name, ::test::SIGNAL_DIVZERO) + +#define ASSERT(expr) \ + (expr) ? static_cast(0) \ + : throw ::test::AssertFailedError(__FILE__, __LINE__, #expr) + +#define _ASSERT_BINOP(a, b, cmp) \ + (!(a cmp b)) ? static_cast(0) \ + : throw ::test::AssertFailedError( \ + __FILE__, __LINE__, "because " #a " " #cmp " " #b) + +#define ASSERT_EQ(a, b) _ASSERT_BINOP(a, b, !=) +#define ASSERT_NE(a, b) _ASSERT_BINOP(a, b, ==) +#define ASSERT_LT(a, b) _ASSERT_BINOP(a, b, >=) +#define ASSERT_LE(a, b) _ASSERT_BINOP(a, b, >) +#define ASSERT_GT(a, b) _ASSERT_BINOP(a, b, <=) +#define ASSERT_GE(a, b) _ASSERT_BINOP(a, b, <) + +#define ASSERT_THROW(expr, e_type) \ + do { \ + try { \ + expr \ + } catch (const e_type &) { \ + break; \ + } \ + throw ::test::AssertFailedError(__FILE__, __LINE__, \ + "expected exception " #e_type); \ + } while (0) + +#define ASSERT_ANY_THROW(expr) \ + do { \ + try { \ + expr \ + } catch (...) { \ + break; \ + } \ + throw ::test::AssertFailedError(__FILE__, __LINE__, \ + "expected any exception"); \ + } while (0) + +#define ASSERT_NO_THROW(expr) \ + try { \ + expr \ + } catch (...) { \ + throw ::test::AssertFailedError(__FILE__, __LINE__, \ + "no exception expected"); \ + } + +#endif /* H_GUARD */ diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test_package/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test_package/CMakeLists.txt new file mode 100644 index 0000000000000..56de8b2232c59 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test_package/CMakeLists.txt @@ -0,0 +1,13 @@ +# Auto generated CMakeLists.txt. +# See xbmc/addons/kodi-dev-kit/tools/code-generator.py. + +set(SOURCES + main.cpp +) + +set(HEADERS +) + +if(SOURCES OR HEADERS) + devkit_add_object(devkit_third_party_backward-cpp_test_package) +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test_package/conanfile.py b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test_package/conanfile.py new file mode 100644 index 0000000000000..e509dd5a00c49 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test_package/conanfile.py @@ -0,0 +1,14 @@ +from conans import ConanFile, CMake +import os + +class TestBackward(ConanFile): + settings = 'os', 'compiler', 'build_type', 'arch' + generators = 'cmake' + + def build(self): + cmake = CMake(self) + cmake.configure(defs={'CMAKE_VERBOSE_MAKEFILE': 'ON'}) + cmake.build() + + def test(self): + self.run(os.path.join('.', 'bin', 'example')) diff --git a/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test_package/main.cpp b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test_package/main.cpp new file mode 100644 index 0000000000000..98ca96a43f287 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon/third_party/backward-cpp/test_package/main.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +#include + +using namespace backward; + +class TracedException : public std::runtime_error { +public: + TracedException() : std::runtime_error(_get_trace()) {} + +private: + std::string _get_trace() { + std::ostringstream ss; + + StackTrace stackTrace; + TraceResolver resolver; + stackTrace.load_here(); + resolver.load_stacktrace(stackTrace); + + for (std::size_t i = 0; i < stackTrace.size(); ++i) { + const ResolvedTrace trace = resolver.resolve(stackTrace[i]); + + ss << "#" << i << " at " << trace.object_function << "\n"; + } + + return ss.str(); + } +}; + +void f(int i) { + if (i >= 42) { + throw TracedException(); + } else { + std::cout << "i=" << i << "\n"; + f(i + 1); + } +} + +int main() { + try { + f(0); + } catch (const TracedException &ex) { + std::cout << ex.what(); + } +} diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon_language/CMakeLists.txt new file mode 100644 index 0000000000000..041d72c3c91a4 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/CMakeLists.txt @@ -0,0 +1,48 @@ +cmake_minimum_required(VERSION 3.12) +project(kodi_addon_language) + +option(BUILDSWIG "Build swig modules." ON) +option(BUILDSWIGPYTHON3 "Build swig python 3 modules." ON) +option(BUILDSWIGPYTHON4 "Build swig python 4 modules." ON) +option(BUILDSWIGNODE "Build swig node modules." ON) +option(BUILDSWIGJAVA "Build Java API." ON) +option(BUILDSWIGLUA "Build Lua API." ON) + +if(NOT BUILDSWIG) + set(BUILDSWIGPYTHON3 OFF) + set(BUILDSWIGPYTHON4 OFF) + set(BUILDSWIGNODE OFF) + set(BUILDSWIGJAVA OFF) + set(BUILDSWIGLUA OFF) +endif() + +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/../../cmake) + +include_directories(${PROJECT_SOURCE_DIR}/src + ${PROJECT_SOURCE_DIR}/../../include/kodi) + +if(BUILDSWIG) + cmake_policy(SET CMP0078 NEW) + cmake_policy(SET CMP0086 NEW) + find_package(SWIG REQUIRED) + include("${SWIG_USE_FILE}") + + if(SWIG_FOUND) + add_definitions(-DSWIG) + SET(CMAKE_SWIG_FLAGS -c++) + + set_source_files_properties(kodidevkit.i PROPERTIES SWIG_FLAGS "-I${CMAKE_BINARY_DIR}/swig") + if(BUILDSWIGPYTHON) + add_subdirectory(swig/python) + endif() + if(BUILDSWIGJAVA) + add_subdirectory(swig/java) + endif() + if(BUILDSWIGLUA) + add_subdirectory(swig/lua) + endif() + if(BUILDSWIGNODE) + add_subdirectory(swig/javascript) + endif() + endif() +endif() diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/FindNodejs.cmake b/xbmc/addons/kodi-dev-kit/src/addon_language/FindNodejs.cmake new file mode 100644 index 0000000000000..f1fa1ca900b85 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/FindNodejs.cmake @@ -0,0 +1,97 @@ + # Macro to add directory to NODEJS_INCLUDE_DIRS if it exists and is not /usr/include + macro(add_include_dir dir) + if (IS_DIRECTORY ${dir} AND NOT ${dir} STREQUAL "/usr/include") + set(NODEJS_INCLUDE_DIRS ${NODEJS_INCLUDE_DIRS} ${dir}) + endif() +endmacro() + + +find_program (NODEJS_EXECUTABLE NAMES node nodejs + HINTS + $ENV{NODE_DIR} + PATH_SUFFIXES bin + DOC "Node.js interpreter" +) + +include (FindPackageHandleStandardArgs) + +# If compat-libuv package exists, it must be at start of include path +find_path (UV_ROOT_DIR "uv.h" PATHS /usr/include/compat-libuv010 NO_DEFAULT_PATH) +if (UV_ROOT_DIR) + # set (NODEJS_INCLUDE_DIRS ${UV_ROOT_DIR}) + add_include_dir(${UV_ROOT_DIR}) +endif() + +# Now look for node. Flag an error if not found +find_path (NODE_ROOT_DIR "include/node/node.h" "include/src/node.h" "src/node.h" + PATHS /usr/include/nodejs /usr/local/include/nodejs /usr/local/include) +if (NODE_ROOT_DIR) + add_include_dir(${NODE_ROOT_DIR}/include/src) + add_include_dir(${NODE_ROOT_DIR}/src) + add_include_dir(${NODE_ROOT_DIR}/include/node) + add_include_dir(${NODE_ROOT_DIR}/include/deps/v8/include) + add_include_dir(${NODE_ROOT_DIR}/deps/v8/include) + add_include_dir(${NODE_ROOT_DIR}/include/deps/uv/include) + add_include_dir(${NODE_ROOT_DIR}/deps/uv/include) +else() + unset(NODEJS_INCLUDE_DIRS) + message(ERROR " - node.h not found") +endif() + +# Check that v8.h is in NODEJS_INCLUDE_DIRS +find_path (V8_ROOT_DIR "v8.h" PATHS ${NODEJS_INCLUDE_DIRS}) +if (NOT V8_ROOT_DIR) + unset(NODEJS_INCLUDE_DIRS) + message(ERROR " - v8.h not found") +endif() + +# Check that uv.h is in NODEJS_INCLUDE_DIRS +find_path (UV_ROOT_DIR "uv.h" PATHS ${NODEJS_INCLUDE_DIRS}) +if (NOT UV_ROOT_DIR) + unset(NODEJS_INCLUDE_DIRS) + message(ERROR " - uv.h not found") +endif() + +find_package_handle_standard_args (Nodejs DEFAULT_MSG + NODEJS_EXECUTABLE + NODEJS_INCLUDE_DIRS +) + +if (NODEJS_EXECUTABLE) + execute_process(COMMAND ${NODEJS_EXECUTABLE} --version + OUTPUT_VARIABLE _VERSION + RESULT_VARIABLE _NODE_VERSION_RESULT) + execute_process(COMMAND ${NODEJS_EXECUTABLE} -e "console.log(process.versions.v8)" + OUTPUT_VARIABLE _V8_VERSION + RESULT_VARIABLE _V8_RESULT) + if (NOT _NODE_VERSION_RESULT AND NOT _V8_RESULT) + string (REPLACE "v" "" NODE_VERSION_STRING "${_VERSION}") + string (REPLACE "." ";" _VERSION_LIST "${NODE_VERSION_STRING}") + list (GET _VERSION_LIST 0 NODE_VERSION_MAJOR) + list (GET _VERSION_LIST 1 NODE_VERSION_MINOR) + list (GET _VERSION_LIST 2 NODE_VERSION_PATCH) + set (V8_VERSION_STRING ${_V8_VERSION}) + string (REPLACE "." ";" _V8_VERSION_LIST "${_V8_VERSION}") + list (GET _V8_VERSION_LIST 0 V8_VERSION_MAJOR) + list (GET _V8_VERSION_LIST 1 V8_VERSION_MINOR) + list (GET _V8_VERSION_LIST 2 V8_VERSION_PATCH) + # we end up with a nasty newline so strip everything that isn't a number + string (REGEX MATCH "^[0-9]*" V8_VERSION_PATCH ${V8_VERSION_PATCH}) + else () + set (NODE_VERSION_STRING "0.10.30") + set (NODE_VERSION_MAJOR "0") + set (NODE_VERSION_MINOR "10") + set (NODE_VERSION_PATCH "30") + set (V8_VERSION_MAJOR "3") + set (V8_VERSION_MINOR"14") + set (V8_VERSION_PATCH "5") + set (V8_VERSION_STRING "3.28.72") + message ("defaulted to node 0.10.30") + endif () + string (REGEX REPLACE "\n" "" NODE_VERSION_STRING ${NODE_VERSION_STRING}) + string (REGEX REPLACE "\n" "" V8_VERSION_STRING ${V8_VERSION_STRING}) + message ("INFO - Node version is " ${NODE_VERSION_STRING}) + message ("INFO - Node using v8 " ${V8_VERSION_STRING}) + mark_as_advanced (NODEJS_EXECUTABLE) +endif () + diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/global.i b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/global.i new file mode 100644 index 0000000000000..d8c938df3096e --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/global.i @@ -0,0 +1,13 @@ +%define ATTR_DLL_LOCAL +%enddef +%define __INTRODUCED_IN_KODI(api_level) +%enddef +%define __DEPRECATED_IN_KODI(api_level) +%enddef +%define __REMOVED_IN_KODI(api_level) +%enddef + +%ignore KODI_ADDON_INSTANCE_INFO; + +%include +%apply bool & INOUT { bool & bar }; diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/CMakeLists.txt new file mode 100644 index 0000000000000..ac5ed8ca403d0 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/CMakeLists.txt @@ -0,0 +1,128 @@ +find_package(Java) +find_package(JNI) + +if(NOT Java_FOUND) + message(WARNING "Java package not found, Java Support not possible to create!") + return() +elseif(NOT JNI_FOUND) + message(WARNING "JNI package not found, Java Support not possible to create!") + return() +else() + message(STATUS "Java support becomes included") +endif() + +include(UseJava) + +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/manifest.txt.in + ${CMAKE_CURRENT_BINARY_DIR}/manifest.txt) +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/pom.xml.in + ${CMAKE_CURRENT_BINARY_DIR}/kodidevkit-${VERSION_SHORT}.pom) + +if (PERIPHERALMAN) + # Override the JNI include directory for Android Things since these + # will require an Android-friendly jni.h + set(JAVA_INCLUDE_PATH "${ANDROID_SYSROOT}/usr/include") +endif() + +include_directories ( + ${JAVA_INCLUDE_PATH} + ${JAVA_INCLUDE_PATH2} + ${CMAKE_CURRENT_SOURCE_DIR}/.. +) + +# SWIG treats SWIG_FLAGS as a list and not a string so semicolon seperation is required +set_source_files_properties( + ${PROJECT_SOURCE_DIR}/swig/java/kodi_addon.i + PROPERTIES SWIG_FLAGS ";-package;kodi;-I${CMAKE_BINARY_DIR}/src" + CPLUSPLUS ON +) +set_source_files_properties( + ${PROJECT_SOURCE_DIR}/swig/java/kodi_addon.i + ${PROJECT_SOURCE_DIR}/swig/kodi_addon.i + ${PROJECT_SOURCE_DIR}/swig/global.i + PROPERTIES CPLUSPLUS ON +) +set_source_files_properties( + ${PROJECT_SOURCE_DIR}/swig/java/kodi_gui_dialogs_TextViewer.i + ${PROJECT_SOURCE_DIR}/swig/java/kodi_gui_dialogs_YesNo.i + PROPERTIES SWIG_FLAGS ";-package;kodi.gui.dialogs;-I${CMAKE_BINARY_DIR}/src" + CPLUSPLUS ON +) + +set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fpermissive -DJAVACALLBACK") +set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DJAVACALLBACK") + +if (NOT DEFINED ENV{JAVA_HOME_NATIVE}) + if (NOT DEFINED ENV{JAVA_HOME}) +# message (WARNING "Neither JAVA_HOME nor JAVA_HOME_NATIVE are set, falling back to '/usr' path") + set(JAVA_HOME "/usr") + + set(JAVA_HOME_NATIVE $ENV{JAVA_HOME}) + set(JAVAC ${JAVA_HOME}/bin/javac) + set(JAR ${JAVA_HOME}/bin/jar) + else() + set(JAVA_HOME_NATIVE $ENV{JAVA_HOME}) + set(JAVAC $ENV{JAVA_HOME}/bin/javac) + set(JAR $ENV{JAVA_HOME}/bin/jar) + endif() +else () + set (JAVAC $ENV{JAVA_HOME_NATIVE}/bin/javac) + set (JAR $ENV{JAVA_HOME_NATIVE}/bin/jar) +endif () + +cmake_parse_arguments(arg "WRAPPED" "DEVKIT_OUTPUT_DIRECTORY" "" ${ARGN}) +if(arg_DEVKIT_OUTPUT_DIRECTORY) + set(DEVKIT_OUTPUT_DIRECTORY ${arg_DEVKIT_OUTPUT_DIRECTORY}) +else() + set(DEVKIT_OUTPUT_DIRECTORY "addons/kodi.binary.devkit") +endif() + +#if(CORE_SYSTEM_NAME STREQUAL windows) + set(OUTPUT_NAME ${CMAKE_SHARED_LIBRARY_PREFIX}kodidevkit-java) +#else() + #set(OUTPUT_NAME ${CMAKE_SHARED_LIBRARY_PREFIX}kodidevkit-java-${ARCH}) +#endif() + +swig_add_library( + kodidevkit-java-base + TYPE OBJECT + LANGUAGE java + NO_PROXY + OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR} + SOURCES ${PROJECT_SOURCE_DIR}/swig/java/kodi_addon.i +) +set_property(TARGET kodidevkit-java-base PROPERTY POSITION_INDEPENDENT_CODE ON) +swig_add_library( + kodidevkit-java-gui-dialogs + TYPE OBJECT + LANGUAGE java + NO_PROXY + OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/gui/dialogs + SOURCES ${PROJECT_SOURCE_DIR}/swig/java/kodi_gui_dialogs_TextViewer.i + ${PROJECT_SOURCE_DIR}/swig/java/kodi_gui_dialogs_YesNo.i +) +set_property(TARGET kodidevkit-java-gui-dialogs PROPERTY POSITION_INDEPENDENT_CODE ON) + +add_library(kodidevkit-java SHARED $ + $) + +#swig_link_libraries(kodidevkit-java kodidevkit dl ${JAVA_LIBRARIES}) +set_target_properties(kodidevkit-java PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY}/java + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY}/java + OUTPUT_NAME ${OUTPUT_NAME} PREFIX "") + + +add_custom_command(TARGET kodidevkit-java + POST_BUILD + COMMAND cmake -E echo "Compiling java.." + COMMAND ${JAVAC} *.java gui/dialogs/*.java -d ${CMAKE_CURRENT_BINARY_DIR} + COMMAND cmake -E echo "Creating jar" + COMMAND ${JAR} cvmf manifest.txt kodidevkit.jar kodi/* + COMMAND cmake -E copy ${CMAKE_CURRENT_BINARY_DIR}/kodidevkit.jar ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY}/java + COMMAND cmake -E copy_directory ${CMAKE_CURRENT_BINARY_DIR}/kodi ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY}/java/kodi +) + +#kodidevkit_create_install_pkgconfig (kodijava.pc ${LIB_INSTALL_DIR}/pkgconfig) + +#install (TARGETS kodijava LIBRARY DESTINATION ${LIB_INSTALL_DIR}) +#install (FILES ${CMAKE_CURRENT_BINARY_DIR}/kodidevkit.jar DESTINATION ${LIB_INSTALL_DIR}/../lib/java) diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/kodi_addon.i b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/kodi_addon.i new file mode 100644 index 0000000000000..207e6b803c29a --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/kodi_addon.i @@ -0,0 +1,115 @@ +%module (docstring="Java interface to libkodidevkit") kodi + +%feature("autodoc", "3"); + +%define __INTRODUCED_IN_KODI(api_level) +%enddef +%define __DEPRECATED_IN_KODI(api_level) +%enddef +%define __REMOVED_IN_KODI(api_level) +%enddef + +%include ../kodi_addon.i + +/* This tells SWIG to treat char ** as a special case when used as a parameter + in a function call */ +%typemap(in) char ** (jint size) { + int i = 0; + size = jenv->GetArrayLength($input); + $1 = (char **) malloc((size+1)*sizeof(char *)); + /* make a copy of each string */ + for (i = 0; iGetObjectArrayElement($input, i); + const char * c_string = jenv->GetStringUTFChars(j_string, 0); + $1[i] = static_cast(malloc((strlen(c_string)+1)*sizeof(char))); + strcpy($1[i], c_string); + jenv->ReleaseStringUTFChars(j_string, c_string); + jenv->DeleteLocalRef(j_string); + } + $1[i] = 0; +} + +/* This cleans up the memory we malloc'd before the function call */ +%typemap(freearg) char ** { + int i; + for (i=0; iFindClass("java/lang/String"); + + while ($1[len]) len++; + jresult = jenv->NewObjectArray(len, clazz, NULL); + /* exception checking omitted */ + + for (i=0; iNewStringUTF(*result++); + jenv->SetObjectArrayElement(jresult, i, temp_string); + jenv->DeleteLocalRef(temp_string); + } +} + +/* These 3 typemaps tell SWIG what JNI and Java types to use */ +%typemap(jni) char ** "jobjectArray" +%typemap(jtype) char ** "String[]" +%typemap(jstype) char ** "String[]" + +/* These 2 typemaps handle the conversion of the jtype to jstype typemap type + and vice versa */ +%typemap(javain) char ** "$javainput" +%typemap(javaout) char ** { + return $jnicall; + } + +%inline %{ + +bool Init(unsigned int api, char **argv) +{ + int argc = 0; + while (argv[argc]) + { + argc++; + } + + if (!kodi::dl::LoadDll(argc, argv)) + return false; + + KODI_IFC_HDL hdl = kodi::dl::api.kodi_init(api, argc, argv, nullptr, false, false); + if (!hdl) + return false; + + kodi::dl::hdl = hdl; + + return true; +} + +void Log(const ADDON_LOG loglevel, const char* fmt, ...) +{ + va_list arg; + va_start(arg, fmt); + char *errorStr; + if (vasprintf(&errorStr, fmt, arg) >= 0) + { + kodi::dl::api.kodi_log(loglevel, errorStr); + free(errorStr); + } + va_end(arg); +} + + +%} + + +%constant int KODI_API = __KODI_API__; + +%pragma(java) jniclasscode=%{ + static { + System.loadLibrary("kodidevkit-java"); + } +%} diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/kodi_gui_dialogs_TextViewer.i b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/kodi_gui_dialogs_TextViewer.i new file mode 100644 index 0000000000000..b453418cdfcd6 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/kodi_gui_dialogs_TextViewer.i @@ -0,0 +1,11 @@ +%include global.i + +%module TextViewer + +%import(module="kodi") "AddonBase.h" + +%{ +#include "gui/dialogs/TextViewer.h" +%} +%include "std_string.i" +%include "gui/dialogs/TextViewer.h" diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/kodi_gui_dialogs_YesNo.i b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/kodi_gui_dialogs_YesNo.i new file mode 100644 index 0000000000000..72872cc115f1a --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/kodi_gui_dialogs_YesNo.i @@ -0,0 +1,14 @@ +%include global.i + +%module YesNo + +%include +%apply bool & INOUT { bool & bar }; + +%import "kodi_addon.i" + +%{ +#include "gui/dialogs/YesNo.h" +%} +%include "std_string.i" +%include "gui/dialogs/YesNo.h" diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/manifest.txt.in b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/manifest.txt.in new file mode 100644 index 0000000000000..e6717b11084f1 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/manifest.txt.in @@ -0,0 +1,7 @@ +Manifest-version: 1.0 + +Name: kodidevkit/ +Specification-Title: kodidevkit +Specification-Version: @VERSION_SHORT@ +Package-Title: kodidevkit +Package-Version: @VERSION_SHORT@ diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/pom.xml.in b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/pom.xml.in new file mode 100644 index 0000000000000..7ec311f814503 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/java/pom.xml.in @@ -0,0 +1,38 @@ + + + 4.0.0 + + tv.kodi.javaaddon + kodidevkit + @VERSION_SHORT@ + jar + + kodidevkit + Library who bring interface between a addon and Kodi + + + + + GPL2 + + + + + + + + + Kodi - Open Source Home Theater Software + https://kodi.tv + + + + + + + + + + diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/CMakeLists.txt new file mode 100644 index 0000000000000..d4b582f90ae55 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/CMakeLists.txt @@ -0,0 +1,132 @@ +find_package(Nodejs) + +if(NOT Nodejs_FOUND) + message(WARNING "JavaScript support not possible to create!") + return() +else() + message(STATUS "JavaScript support becomes included") +endif() + +include_directories ( + ${NODEJS_INCLUDE_DIRS} + ${CMAKE_CURRENT_SOURCE_DIR}/.. +) + +# SWIG treats SWIG_FLAGS as a list and not a string so semicolon seperation is +# required. This hardcodes V8_VERSION to be <10 but I assume that's not going +# to be a problem for a little while! SWIG uses a padded SWIG_V8 version which +# we hack together from our findnode module. +set (V8_VERSION_HEX 0x0${V8_VERSION_MAJOR}${V8_VERSION_MINOR}${V8_VERSION_PATCH}) +string (LENGTH "${V8_VERSION_HEX}" V8_VERSION_HEX_length) +while (V8_VERSION_HEX_length LESS 8) + set (V8_VERSION_HEX "${V8_VERSION_HEX}0") + message (STATUS "INFO - Padded V8 version to match SWIG format") + string (LENGTH "${V8_VERSION_HEX}" V8_VERSION_HEX_length) +endwhile () + +set_property (SOURCE kodidevkitjs.i PROPERTY SWIG_FLAGS "-node" + "-I${CMAKE_BINARY_DIR}/src" "-DV8_VERSION=${V8_VERSION_HEX}") +set_source_files_properties (kodidevkitjs.i PROPERTIES CPLUSPLUS ON) + +if (CMAKE_VERSION VERSION_LESS "3.8") + swig_add_module (kodidevkitjs javascript kodidevkitjs.i) +else () + swig_add_library (kodidevkitjs LANGUAGE javascript SOURCES kodidevkitjs.i) +endif () +swig_link_libraries (kodidevkitjs kodidevkit) + +set_target_properties (kodidevkitjs PROPERTIES + COMPILE_FLAGS " -DBUILDING_NODE_EXTENSION -DSWIGJAVASCRIPT=${SWIG_FOUND}" + PREFIX "" + OUTPUT_NAME kodidevkit + SUFFIX ".node" +) + +message (STATUS "INFO - swig Version ${SWIG_VERSION}") +message (STATUS "INFO - CXX compiler Version ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}") + +if (${V8_VERSION_MAJOR} GREATER 3) + message (STATUS "INFO - Using V8 version > 3 so requiring C++11 compiler") + # Node 0.12.x V8 engine major version is '3'. + # Node 2.1.0 V8 engine major version is '4'. + set_property (TARGET kodidevkitjs PROPERTY CXX_STANDARD 11) + set_property (TARGET kodidevkitjs PROPERTY CXX_STANDARD_REQUIRED ON) + if (CMAKE_VERSION VERSION_LESS "3.1") + message (WARNING "Need to use CMAKE version 3.1+, but it is ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION}, using a workaround.") + if (CMAKE_COMPILER_IS_GNUCXX) + if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.7") + message (FATAL_ERROR "GNU gcc compiler is also too old (need 4.7+, but ${CMAKE_CXX_COMPILER_VERSION}) and does not support C++11 standard.") + endif () + set (KODIDEVKIT_CXX11_WORKAROUND_OPTION "-std=gnu++11") + else () + set (KODIDEVKIT_CXX11_WORKAROUND_OPTION "-std=c++11") + endif () + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${KODIDEVKIT_CXX11_WORKAROUND_OPTION} ") + endif () +endif () + +# If a CMAKE_INSTALL_PREFIX has NOT been provided, set NODE_MODULE_INSTALL_PATH +# base on the NODE_ROOT_DIR. +if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set (NODE_MODULE_INSTALL_PATH ${NODE_ROOT_DIR}/lib/node_modules/kodidevkit/) +# If a CMAKE_INSTALL_PREFIX has been provided, set NODE_MODULE_INSTALL_PATH +# relative to the provide install directory. +else (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set (NODE_MODULE_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/lib/node_modules/kodidevkit/) +endif (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) +message (STATUS "INFO - install NODE modules to ${NODE_MODULE_INSTALL_PATH}") + +macro (kodidevkit_CREATE_INSTALL_PACKAGE_JSON generated_file install_location) + configure_file (${generated_file}.cmake ${CMAKE_CURRENT_BINARY_DIR}/${generated_file} @ONLY) + install (FILES ${CMAKE_CURRENT_BINARY_DIR}/${generated_file} DESTINATION ${install_location}) +endmacro (kodidevkit_CREATE_INSTALL_PACKAGE_JSON) +kodidevkit_create_install_package_json (package.json ${NODE_MODULE_INSTALL_PATH}) + +macro (kodidevkit_CREATE_BINDING_GYP generated_file) + set (kodidevkit_LIB_SRCS_GYP "") + set (kodidevkit_NPM_SRCS ${kodidevkit_LIB_SRCS_NOAUTO}) + foreach (srcfile ${kodidevkit_NPM_SRCS}) + file (RELATIVE_PATH rel ${CMAKE_SOURCE_DIR} ${srcfile}) + set (kodidevkit_LIB_SRCS_GYP "'${rel}',\n${kodidevkit_LIB_SRCS_GYP}") + endforeach (srcfile) + foreach (includedir ${kodidevkit_LIB_INCLUDE_DIRS}) + file (RELATIVE_PATH rel ${CMAKE_SOURCE_DIR} ${includedir}) + set (kodidevkit_LIB_INCLUDE_DIRS_GYP "'${rel}',\n${kodidevkit_LIB_INCLUDE_DIRS_GYP}") + endforeach (includedir) + configure_file (${generated_file}.cmake ${CMAKE_CURRENT_BINARY_DIR}/${generated_file} @ONLY) +endmacro (kodidevkit_CREATE_BINDING_GYP) +kodidevkit_create_binding_gyp (binding.gyp) + +add_custom_target (npmpkg) +add_custom_command (TARGET npmpkg POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_BINARY_DIR}/kodidevkitjsJAVASCRIPT_wrap.cxx ${CMAKE_SOURCE_DIR}/src + COMMAND ${CMAKE_COMMAND} -E copy + ${CMAKE_BINARY_DIR}/src/version.c ${CMAKE_SOURCE_DIR}/src + COMMAND ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_BINARY_DIR}/package.json ${CMAKE_SOURCE_DIR} + COMMAND sed -i "'s/kodidevkit.node/build\\/Release\\/kodidevkit.node/'" + ${CMAKE_SOURCE_DIR}/package.json + COMMAND ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_BINARY_DIR}/binding.gyp ${CMAKE_SOURCE_DIR} + COMMAND ${CMAKE_COMMAND} -E copy + ${CMAKE_SOURCE_DIR}/docs/npm.md ${CMAKE_SOURCE_DIR}/READMEFIRST) +add_dependencies (npmpkg kodidevkitjs) + +if (BUILDDOC) + find_package(Yuidoc) + if (YUIDOC_FOUND) + add_custom_target(jsdoc ALL + COMMAND ${CMAKE_SOURCE_DIR}/doxygen2jsdoc/docgen.js -m kodidevkit -i xml/ -o jsdoc -c ${CMAKE_CURRENT_SOURCE_DIR}/doxygen2jsdoc_custom.json --strict + COMMAND ${YUIDOC_EXECUTABLE} -C --no-sort --helpers ${CMAKE_SOURCE_DIR}/doxygen2jsdoc/generators/yuidoc/tmpl/kodidevkit/helper.js --themedir ${CMAKE_SOURCE_DIR}/doxygen2jsdoc/generators/yuidoc/tmpl/kodidevkit -o html/node jsdoc/yuidoc/kodidevkit + COMMAND ${CMAKE_SOURCE_DIR}/doxygen2jsdoc/tolower.js -i html/node + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + DEPENDS doc + COMMENT "Generating API documentation with Yuidoc" VERBATIM + ) + else () + message (STATUS "INFO - Failed to find Yuidoc. node.js API doc will not be generated") + endif () +endif () + +install (TARGETS ${SWIG_MODULE_kodidevkitjs_REAL_NAME} + DESTINATION ${NODE_MODULE_INSTALL_PATH}) diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/binding.gyp.cmake b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/binding.gyp.cmake new file mode 100644 index 0000000000000..60d25e65049ab --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/binding.gyp.cmake @@ -0,0 +1,42 @@ +{ + 'targets': [ + { + 'target_name': 'kodidevkit', + 'sources': [ + @kodidevkit_LIB_SRCS_GYP@ + 'src/version.c', + 'src/kodidevkitjsJAVASCRIPT_wrap.cxx' + ], + 'include_dirs': [ + @kodidevkit_LIB_INCLUDE_DIRS_GYP@ + ], + 'variables': { + "v8_version%": " /dev/null || echo node` -e 'console.log(process.versions.v8)' | sed 's/\.//g' | cut -c 1-5)", + "arch%": " /dev/null || echo node` -e 'console.log(process.arch)')" + }, + 'cflags_cc!': [ '-fno-rtti', '-fno-exceptions' ], + 'cflags!': [ '-fno-exceptions' ], + 'conditions' : [ + ['OS=="android"', { + 'sources' : [ 'src/glob/glob.c' ], + 'include_dirs' : [ 'src/glob' ], + }], + [ 'arch=="x64" or arch=="ia32"', { + 'defines' : [ 'X86PLAT=ON' ], + }], + [ 'arch=="arm"', { + 'defines' : [ 'ARMPLAT=ON'], + }], + ], + 'defines' : [ + 'SWIG', + 'SWIGJAVASCRIPT', + 'FIRMATA=ON', + 'ONEWIRE=ON', + 'BUILDING_NODE_EXTENSION=1', + 'SWIG_V8_VERSION=0x0<(v8_version)', + 'V8_VERSION=0x0<(v8_version)' + ] + } + ] +} diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/doxygen2jsdoc_custom.json b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/doxygen2jsdoc_custom.json new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/kodidevkitjs.i b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/kodidevkitjs.i new file mode 100644 index 0000000000000..62fe00e88c288 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/kodidevkitjs.i @@ -0,0 +1,5 @@ +%module (docstring="Javascript interface to libkodidevkit") kodidevkit + +%feature("autodoc", "3"); + +%include ../kodidevkit.i diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/package.json.cmake b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/package.json.cmake new file mode 100644 index 0000000000000..e5e3469f53555 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/javascript/package.json.cmake @@ -0,0 +1,19 @@ +{ + "name" : "kodidevkit", + "description": "Library who bring interface between a addon and Kodi". + "keywords":["kodi", "kodidevkitjs"], + "homepage": "https://kodi.tv", + "main" : "./kodidevkit.node", + "engines": { + "node": ">= 0.10.x" + }, + "bugs": { + "url" : "" + }, + "license": "MIT", + "version": "@VERSION@", + "authors": "". + "scripts": { + "test": "node -p -e 'require(\".\").getVersion()'" + } +} diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/kodi_addon.i b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/kodi_addon.i new file mode 100644 index 0000000000000..e61cc70c6513b --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/kodi_addon.i @@ -0,0 +1,31 @@ +%include global.i + +%module kodi + +%rename("%s") ADDON_STATUS; + +%{ +#include "c-api/version.h" +#include "c-api/addon_base.h" +#include "AddonBase.h" + +using namespace kodi; + +kodi_api_1 kodi::dl::api; +KODI_IFC_HDL kodi::dl::hdl = nullptr; +KODI_DLL_HDL kodi::dl::dll = nullptr; +kodi::addon::CAddonBase* kodi::addon::CAddonBase::addonBase = nullptr; +kodi::addon::IInstanceInfo kodi::addon::CAddonBase::firstInstance; +KODI_ADDON_HDL kodi::addon::CAddonBase::globalSingleInstance = nullptr; + +ADDON_STATUS kodi::addon::CAddonBase::ADDONBASE_create(const struct KODI_ADDON_INSTANCE_INFO* first_instance, KODI_ADDON_HDL* hdl) +{ + return ADDON_STATUS_NOT_IMPLEMENTED; +} + +%} + +%include "std_string.i" +%include "c-api/version.h" +%include "c-api/addon_base.h" +%include "AddonBase.h" diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/lua/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/lua/CMakeLists.txt new file mode 100644 index 0000000000000..28517f7525348 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/lua/CMakeLists.txt @@ -0,0 +1,20 @@ +find_package(Lua) + +if(NOT Lua_FOUND) + message(WARNING "Lua Support not possible to create!") + return() +else() + message(STATUS "Lus support becomes included") +endif() + +set_source_files_properties (kodidevkitlua.i PROPERTIES CPLUSPLUS ON) +set_source_files_properties (kodidevkitlua.i PROPERTIES SWIG_FLAGS "-I${CMAKE_BINARY_DIR}/src") + +swig_add_library (kodi-lua LANGUAGE lua SOURCES kodidevkitlua.i) +swig_link_libraries (kodi-lua ${LUA_LIBRARIES} kodidevkit) + +target_include_directories(${SWIG_MODULE_kodi-lua_REAL_NAME} + PUBLIC + "${CMAKE_CURRENT_SOURCE_DIR}/../.." + "${LUA_INCLUDE_DIR}" +) diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/lua/kodidevkitlua.i b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/lua/kodidevkitlua.i new file mode 100644 index 0000000000000..bed9aa5b0a2f9 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/lua/kodidevkitlua.i @@ -0,0 +1,5 @@ +%module (docstring="Lua interface to libkodidevkit") kodi + +%feature("autodoc", "3"); + +%include ../kodidevkit.i diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python3/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python3/CMakeLists.txt new file mode 100644 index 0000000000000..74c92cc1677bd --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python3/CMakeLists.txt @@ -0,0 +1,30 @@ +set_source_files_properties (kodidevkit3.i PROPERTIES CPLUSPLUS ON) +set_source_files_properties (kodidevkit3.i PROPERTIES SWIG_FLAGS "-I${CMAKE_BINARY_DIR}/src") + +message ("PYTHON3 attempting to build!") + +if (CMAKE_VERSION VERSION_LESS "3.8") + swig_add_module (python3-kodidevkit python kodidevkit3.i) +else () + swig_add_library (python3-kodidevkit LANGUAGE python SOURCES kodidevkit3.i) +endif () +swig_link_libraries (python3-kodidevkit ${PYTHON3_LIBRARIES} kodidevkit) + +target_include_directories(${SWIG_MODULE_python3-kodidevkit_REAL_NAME} + PUBLIC + "${CMAKE_CURRENT_SOURCE_DIR}/../.." + "${PYTHON3_INCLUDE_DIR}" +) + +set_target_properties (${SWIG_MODULE_python3-kodidevkit_REAL_NAME} PROPERTIES + OUTPUT_NAME _kodi + COMPILE_FLAGS "${CMAKE_C_FLAGS} -DSWIGPYTHON=${SWIG_FOUND} -DSWIGPYTHON3=${SWIG_FOUND}" +) + +install (TARGETS ${SWIG_MODULE_python3-kodidevkit_REAL_NAME} + DESTINATION ${CMAKE_INSTALL_PREFIX}/${PYTHON3_PACKAGES_PATH} +) + +install (FILES ${CMAKE_CURRENT_BINARY_DIR}/kodidevkit.py + DESTINATION ${CMAKE_INSTALL_PREFIX}/${PYTHON3_PACKAGES_PATH} +) diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python3/kodidevkit3.i b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python3/kodidevkit3.i new file mode 100644 index 0000000000000..7dd9522b055e2 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python3/kodidevkit3.i @@ -0,0 +1,3 @@ +%module(docstring="Python 3 interface to Kodi") kodi + +%include ../kodidevkit.i diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python4/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python4/CMakeLists.txt new file mode 100644 index 0000000000000..b2c62d828f9a8 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python4/CMakeLists.txt @@ -0,0 +1,30 @@ +set_source_files_properties (kodidevkit4.i PROPERTIES CPLUSPLUS ON) +set_source_files_properties (kodidevkit4.i PROPERTIES SWIG_FLAGS "-I${CMAKE_BINARY_DIR}/src") + +message ("PYTHON4 attempting to build!") + +if (CMAKE_VERSION VERSION_LESS "3.8") + swig_add_module (python4-kodidevkit python kodidevkit4.i) +else () + swig_add_library (python4-kodidevkit LANGUAGE python SOURCES kodidevkit4.i) +endif () +swig_link_libraries (python4-kodidevkit ${PYTHON4_LIBRARIES} kodidevkit) + +target_include_directories(${SWIG_MODULE_python4-kodidevkit_REAL_NAME} + PUBLIC + "${CMAKE_CURRENT_SOURCE_DIR}/../.." + "${PYTHON4_INCLUDE_DIR}" +) + +set_target_properties (${SWIG_MODULE_python4-kodidevkit_REAL_NAME} PROPERTIES + OUTPUT_NAME _kodi + COMPILE_FLAGS "${CMAKE_C_FLAGS} -DSWIGPYTHON=${SWIG_FOUND} -DSWIGPYTHON4=${SWIG_FOUND}" +) + +install (TARGETS ${SWIG_MODULE_python4-kodidevkit_REAL_NAME} + DESTINATION ${CMAKE_INSTALL_PREFIX}/${PYTHON4_PACKAGES_PATH} +) + +install (FILES ${CMAKE_CURRENT_BINARY_DIR}/kodidevkit.py + DESTINATION ${CMAKE_INSTALL_PREFIX}/${PYTHON4_PACKAGES_PATH} +) diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python4/kodidevkit4.i b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python4/kodidevkit4.i new file mode 100644 index 0000000000000..7dd9522b055e2 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/python4/kodidevkit4.i @@ -0,0 +1,3 @@ +%module(docstring="Python 3 interface to Kodi") kodi + +%include ../kodidevkit.i diff --git a/xbmc/addons/kodi-dev-kit/src/addon_language/swig/test.i b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/test.i new file mode 100644 index 0000000000000..05387a893bbdc --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_language/swig/test.i @@ -0,0 +1,34 @@ +%module kodi + +%rename("%s") ADDON_STATUS; + +%define ATTR_DLL_LOCAL +%enddef + +%ignore KODI_ADDON_INSTANCE_INFO; + +%{ +#include "c-api/version.h" +#include "c-api/addon_base.h" +#include "AddonBase.h" + +using namespace kodi; + +kodi_api_1 kodi::dl::api; +KODI_IFC_HDL kodi::dl::hdl = nullptr; +KODI_DLL_HDL kodi::dl::dll = nullptr; +kodi::addon::CAddonBase* kodi::addon::CAddonBase::addonBase = nullptr; +kodi::addon::IInstanceInfo kodi::addon::CAddonBase::firstInstance; +KODI_ADDON_HDL kodi::addon::CAddonBase::globalSingleInstance = nullptr; + +ADDON_STATUS kodi::addon::CAddonBase::ADDONBASE_create(const struct KODI_ADDON_INSTANCE_INFO* first_instance, KODI_ADDON_HDL* hdl) +{ + return ADDON_STATUS_NOT_IMPLEMENTED; +} + +%} + +%include "std_string.i" +%include "c-api/version.h" +%include "c-api/addon_base.h" +%include "AddonBase.h" diff --git a/xbmc/addons/kodi-dev-kit/src/addon_runner/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/src/addon_runner/CMakeLists.txt new file mode 100644 index 0000000000000..8f34b3b38d7cc --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_runner/CMakeLists.txt @@ -0,0 +1,36 @@ +# Add-on helper executable to launch an add-on library as executable in Kodi +# + +cmake_minimum_required(VERSION 3.5) +project(kodi_addon_runner) + +cmake_parse_arguments(arg "WRAPPED" "DEVKIT_OUTPUT_DIRECTORY" "" ${ARGN}) +if(arg_DEVKIT_OUTPUT_DIRECTORY) + set(DEVKIT_OUTPUT_DIRECTORY ${arg_DEVKIT_OUTPUT_DIRECTORY}) +else() + set(DEVKIT_OUTPUT_DIRECTORY "addons/kodi.binary.devkit") +endif() + +set(SOURCES main.cpp) + +set(DEVKIT_LAUNCH_EXE ${PROJECT_NAME}${CMAKE_EXECUTABLE_SUFFIX} CACHE STRING "Launch executable used for dev-kit") + +add_executable(${PROJECT_NAME} ${SOURCES}) +set_target_properties(${PROJECT_NAME} PROPERTIES C_VISIBILITY_PRESET hidden + CXX_VISIBILITY_PRESET hidden + VISIBILITY_INLINES_HIDDEN ON + POSITION_INDEPENDENT_CODE ON + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY} + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY} + OUTPUT_NAME ${DEVKIT_LAUNCH_EXE} PREFIX "") +foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES}) + string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG) + set_target_properties(${name} PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY} + RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY}) +endforeach() + +target_link_libraries(${PROJECT_NAME} PUBLIC dl) +target_include_directories(${PROJECT_NAME} PRIVATE ${LIBDWARF_INCLUDE_DIRS} ../../include) +target_compile_definitions(${PROJECT_NAME} PRIVATE APP_NAME="${PROJECT_NAME}") + +set(LIBRARY_FILES ${LIBRARY_FILES} ${CMAKE_BINARY_DIR}/${DEVKIT_OUTPUT_DIRECTORY}/${PROJECT_NAME}${CMAKE_EXECUTABLE_SUFFIX} CACHE STRING "" FORCE) diff --git a/xbmc/addons/kodi-dev-kit/src/addon_runner/cxxopts.hpp b/xbmc/addons/kodi-dev-kit/src/addon_runner/cxxopts.hpp new file mode 100644 index 0000000000000..2dd4da6b73d10 --- /dev/null +++ b/xbmc/addons/kodi-dev-kit/src/addon_runner/cxxopts.hpp @@ -0,0 +1,2714 @@ +/* + +Copyright (c) 2014, 2015, 2016, 2017 Jarryd Beck + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +*/ + +#ifndef CXXOPTS_HPP_INCLUDED +#define CXXOPTS_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(__GNUC__) && !defined(__clang__) +# if (__GNUC__ * 10 + __GNUC_MINOR__) < 49 +# define CXXOPTS_NO_REGEX true +# endif +#endif + +#ifndef CXXOPTS_NO_REGEX +# include +#endif // CXXOPTS_NO_REGEX + +// Nonstandard before C++17, which is coincidentally what we also need for +#ifdef __has_include +# if __has_include() +# include +# ifdef __cpp_lib_optional +# define CXXOPTS_HAS_OPTIONAL +# endif +# endif +#endif + +#if __cplusplus >= 201603L +#define CXXOPTS_NODISCARD [[nodiscard]] +#else +#define CXXOPTS_NODISCARD +#endif + +#ifndef CXXOPTS_VECTOR_DELIMITER +#define CXXOPTS_VECTOR_DELIMITER ',' +#endif + +#define CXXOPTS__VERSION_MAJOR 3 +#define CXXOPTS__VERSION_MINOR 0 +#define CXXOPTS__VERSION_PATCH 0 + +#if (__GNUC__ < 10 || (__GNUC__ == 10 && __GNUC_MINOR__ < 1)) && __GNUC__ >= 6 + #define CXXOPTS_NULL_DEREF_IGNORE +#endif + +namespace cxxopts +{ + static constexpr struct { + uint8_t major, minor, patch; + } version = { + CXXOPTS__VERSION_MAJOR, + CXXOPTS__VERSION_MINOR, + CXXOPTS__VERSION_PATCH + }; +} // namespace cxxopts + +//when we ask cxxopts to use Unicode, help strings are processed using ICU, +//which results in the correct lengths being computed for strings when they +//are formatted for the help output +//it is necessary to make sure that can be found by the +//compiler, and that icu-uc is linked in to the binary. + +#ifdef CXXOPTS_USE_UNICODE +#include + +namespace cxxopts +{ + using String = icu::UnicodeString; + + inline + String + toLocalString(std::string s) + { + return icu::UnicodeString::fromUTF8(std::move(s)); + } + +#if defined(__GNUC__) +// GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we want to silence it: +// warning: base class 'class std::enable_shared_from_this' has accessible non-virtual destructor +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wnon-virtual-dtor" +#pragma GCC diagnostic ignored "-Weffc++" +// This will be ignored under other compilers like LLVM clang. +#endif + class UnicodeStringIterator : public + std::iterator + { + public: + + UnicodeStringIterator(const icu::UnicodeString* string, int32_t pos) + : s(string) + , i(pos) + { + } + + value_type + operator*() const + { + return s->char32At(i); + } + + bool + operator==(const UnicodeStringIterator& rhs) const + { + return s == rhs.s && i == rhs.i; + } + + bool + operator!=(const UnicodeStringIterator& rhs) const + { + return !(*this == rhs); + } + + UnicodeStringIterator& + operator++() + { + ++i; + return *this; + } + + UnicodeStringIterator + operator+(int32_t v) + { + return UnicodeStringIterator(s, i + v); + } + + private: + const icu::UnicodeString* s; + int32_t i; + }; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + + inline + String& + stringAppend(String&s, String a) + { + return s.append(std::move(a)); + } + + inline + String& + stringAppend(String& s, size_t n, UChar32 c) + { + for (size_t i = 0; i != n; ++i) + { + s.append(c); + } + + return s; + } + + template + String& + stringAppend(String& s, Iterator begin, Iterator end) + { + while (begin != end) + { + s.append(*begin); + ++begin; + } + + return s; + } + + inline + size_t + stringLength(const String& s) + { + return s.length(); + } + + inline + std::string + toUTF8String(const String& s) + { + std::string result; + s.toUTF8String(result); + + return result; + } + + inline + bool + empty(const String& s) + { + return s.isEmpty(); + } +} + +namespace std +{ + inline + cxxopts::UnicodeStringIterator + begin(const icu::UnicodeString& s) + { + return cxxopts::UnicodeStringIterator(&s, 0); + } + + inline + cxxopts::UnicodeStringIterator + end(const icu::UnicodeString& s) + { + return cxxopts::UnicodeStringIterator(&s, s.length()); + } +} + +//ifdef CXXOPTS_USE_UNICODE +#else + +namespace cxxopts +{ + using String = std::string; + + template + T + toLocalString(T&& t) + { + return std::forward(t); + } + + inline + size_t + stringLength(const String& s) + { + return s.length(); + } + + inline + String& + stringAppend(String&s, const String& a) + { + return s.append(a); + } + + inline + String& + stringAppend(String& s, size_t n, char c) + { + return s.append(n, c); + } + + template + String& + stringAppend(String& s, Iterator begin, Iterator end) + { + return s.append(begin, end); + } + + template + std::string + toUTF8String(T&& t) + { + return std::forward(t); + } + + inline + bool + empty(const std::string& s) + { + return s.empty(); + } +} // namespace cxxopts + +//ifdef CXXOPTS_USE_UNICODE +#endif + +namespace cxxopts +{ + namespace + { +#ifdef _WIN32 + const std::string LQUOTE("\'"); + const std::string RQUOTE("\'"); +#else + const std::string LQUOTE("‘"); + const std::string RQUOTE("’"); +#endif + } // namespace + +#if defined(__GNUC__) +// GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we want to silence it: +// warning: base class 'class std::enable_shared_from_this' has accessible non-virtual destructor +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wnon-virtual-dtor" +#pragma GCC diagnostic ignored "-Weffc++" +// This will be ignored under other compilers like LLVM clang. +#endif + class Value : public std::enable_shared_from_this + { + public: + + virtual ~Value() = default; + + virtual + std::shared_ptr + clone() const = 0; + + virtual void + parse(const std::string& text) const = 0; + + virtual void + parse() const = 0; + + virtual bool + has_default() const = 0; + + virtual bool + is_container() const = 0; + + virtual bool + has_implicit() const = 0; + + virtual std::string + get_default_value() const = 0; + + virtual std::string + get_implicit_value() const = 0; + + virtual std::shared_ptr + default_value(const std::string& value) = 0; + + virtual std::shared_ptr + implicit_value(const std::string& value) = 0; + + virtual std::shared_ptr + no_implicit_value() = 0; + + virtual bool + is_boolean() const = 0; + }; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + class OptionException : public std::exception + { + public: + explicit OptionException(std::string message) + : m_message(std::move(message)) + { + } + + CXXOPTS_NODISCARD + const char* + what() const noexcept override + { + return m_message.c_str(); + } + + private: + std::string m_message; + }; + + class OptionSpecException : public OptionException + { + public: + + explicit OptionSpecException(const std::string& message) + : OptionException(message) + { + } + }; + + class OptionParseException : public OptionException + { + public: + explicit OptionParseException(const std::string& message) + : OptionException(message) + { + } + }; + + class option_exists_error : public OptionSpecException + { + public: + explicit option_exists_error(const std::string& option) + : OptionSpecException("Option " + LQUOTE + option + RQUOTE + " already exists") + { + } + }; + + class invalid_option_format_error : public OptionSpecException + { + public: + explicit invalid_option_format_error(const std::string& format) + : OptionSpecException("Invalid option format " + LQUOTE + format + RQUOTE) + { + } + }; + + class option_syntax_exception : public OptionParseException { + public: + explicit option_syntax_exception(const std::string& text) + : OptionParseException("Argument " + LQUOTE + text + RQUOTE + + " starts with a - but has incorrect syntax") + { + } + }; + + class option_not_exists_exception : public OptionParseException + { + public: + explicit option_not_exists_exception(const std::string& option) + : OptionParseException("Option " + LQUOTE + option + RQUOTE + " does not exist") + { + } + }; + + class missing_argument_exception : public OptionParseException + { + public: + explicit missing_argument_exception(const std::string& option) + : OptionParseException( + "Option " + LQUOTE + option + RQUOTE + " is missing an argument" + ) + { + } + }; + + class option_requires_argument_exception : public OptionParseException + { + public: + explicit option_requires_argument_exception(const std::string& option) + : OptionParseException( + "Option " + LQUOTE + option + RQUOTE + " requires an argument" + ) + { + } + }; + + class option_not_has_argument_exception : public OptionParseException + { + public: + option_not_has_argument_exception + ( + const std::string& option, + const std::string& arg + ) + : OptionParseException( + "Option " + LQUOTE + option + RQUOTE + + " does not take an argument, but argument " + + LQUOTE + arg + RQUOTE + " given" + ) + { + } + }; + + class option_not_present_exception : public OptionParseException + { + public: + explicit option_not_present_exception(const std::string& option) + : OptionParseException("Option " + LQUOTE + option + RQUOTE + " not present") + { + } + }; + + class option_has_no_value_exception : public OptionException + { + public: + explicit option_has_no_value_exception(const std::string& option) + : OptionException( + !option.empty() ? + ("Option " + LQUOTE + option + RQUOTE + " has no value") : + "Option has no value") + { + } + }; + + class argument_incorrect_type : public OptionParseException + { + public: + explicit argument_incorrect_type + ( + const std::string& arg + ) + : OptionParseException( + "Argument " + LQUOTE + arg + RQUOTE + " failed to parse" + ) + { + } + }; + + class option_required_exception : public OptionParseException + { + public: + explicit option_required_exception(const std::string& option) + : OptionParseException( + "Option " + LQUOTE + option + RQUOTE + " is required but not present" + ) + { + } + }; + + template + void throw_or_mimic(const std::string& text) + { + static_assert(std::is_base_of::value, + "throw_or_mimic only works on std::exception and " + "deriving classes"); + +#ifndef CXXOPTS_NO_EXCEPTIONS + // If CXXOPTS_NO_EXCEPTIONS is not defined, just throw + throw T{text}; +#else + // Otherwise manually instantiate the exception, print what() to stderr, + // and exit + T exception{text}; + std::cerr << exception.what() << std::endl; + std::exit(EXIT_FAILURE); +#endif + } + + namespace values + { + namespace parser_tool + { + struct IntegerDesc + { + std::string negative = ""; + std::string base = ""; + std::string value = ""; + }; + struct ArguDesc { + std::string arg_name = ""; + bool grouping = false; + bool set_value = false; + std::string value = ""; + }; +#ifdef CXXOPTS_NO_REGEX + inline IntegerDesc SplitInteger(const std::string &text) + { + if (text.empty()) + { + throw_or_mimic(text); + } + IntegerDesc desc; + const char *pdata = text.c_str(); + if (*pdata == '-') + { + pdata += 1; + desc.negative = "-"; + } + if (strncmp(pdata, "0x", 2) == 0) + { + pdata += 2; + desc.base = "0x"; + } + if (*pdata != '\0') + { + desc.value = std::string(pdata); + } + else + { + throw_or_mimic(text); + } + return desc; + } + + inline bool IsTrueText(const std::string &text) + { + const char *pdata = text.c_str(); + if (*pdata == 't' || *pdata == 'T') + { + pdata += 1; + if (strncmp(pdata, "rue\0", 4) == 0) + { + return true; + } + } + else if (strncmp(pdata, "1\0", 2) == 0) + { + return true; + } + return false; + } + + inline bool IsFalseText(const std::string &text) + { + const char *pdata = text.c_str(); + if (*pdata == 'f' || *pdata == 'F') + { + pdata += 1; + if (strncmp(pdata, "alse\0", 5) == 0) + { + return true; + } + } + else if (strncmp(pdata, "0\0", 2) == 0) + { + return true; + } + return false; + } + + inline std::pair SplitSwitchDef(const std::string &text) + { + std::string short_sw, long_sw; + const char *pdata = text.c_str(); + if (isalnum(*pdata) && *(pdata + 1) == ',') { + short_sw = std::string(1, *pdata); + pdata += 2; + } + while (*pdata == ' ') { pdata += 1; } + if (isalnum(*pdata)) { + const char *store = pdata; + pdata += 1; + while (isalnum(*pdata) || *pdata == '-' || *pdata == '_') { + pdata += 1; + } + if (*pdata == '\0') { + long_sw = std::string(store, pdata - store); + } else { + throw_or_mimic(text); + } + } + return std::pair(short_sw, long_sw); + } + + inline ArguDesc ParseArgument(const char *arg, bool &matched) + { + ArguDesc argu_desc; + const char *pdata = arg; + matched = false; + if (strncmp(pdata, "--", 2) == 0) + { + pdata += 2; + if (isalnum(*pdata)) + { + argu_desc.arg_name.push_back(*pdata); + pdata += 1; + while (isalnum(*pdata) || *pdata == '-' || *pdata == '_') + { + argu_desc.arg_name.push_back(*pdata); + pdata += 1; + } + if (argu_desc.arg_name.length() > 1) + { + if (*pdata == '=') + { + argu_desc.set_value = true; + pdata += 1; + if (*pdata != '\0') + { + argu_desc.value = std::string(pdata); + } + matched = true; + } + else if (*pdata == '\0') + { + matched = true; + } + } + } + } + else if (strncmp(pdata, "-", 1) == 0) + { + pdata += 1; + argu_desc.grouping = true; + while (isalnum(*pdata)) + { + argu_desc.arg_name.push_back(*pdata); + pdata += 1; + } + matched = !argu_desc.arg_name.empty() && *pdata == '\0'; + } + return argu_desc; + } + +#else // CXXOPTS_NO_REGEX + + namespace + { + + std::basic_regex integer_pattern + ("(-)?(0x)?([0-9a-zA-Z]+)|((0x)?0)"); + std::basic_regex truthy_pattern + ("(t|T)(rue)?|1"); + std::basic_regex falsy_pattern + ("(f|F)(alse)?|0"); + + std::basic_regex option_matcher + ("--([[:alnum:]][-_[:alnum:]]+)(=(.*))?|-([[:alnum:]]+)"); + std::basic_regex option_specifier + ("(([[:alnum:]]),)?[ ]*([[:alnum:]][-_[:alnum:]]*)?"); + + } // namespace + + inline IntegerDesc SplitInteger(const std::string &text) + { + std::smatch match; + std::regex_match(text, match, integer_pattern); + + if (match.length() == 0) + { + throw_or_mimic(text); + } + + IntegerDesc desc; + desc.negative = match[1]; + desc.base = match[2]; + desc.value = match[3]; + + if (match.length(4) > 0) + { + desc.base = match[5]; + desc.value = "0"; + return desc; + } + + return desc; + } + + inline bool IsTrueText(const std::string &text) + { + std::smatch result; + std::regex_match(text, result, truthy_pattern); + return !result.empty(); + } + + inline bool IsFalseText(const std::string &text) + { + std::smatch result; + std::regex_match(text, result, falsy_pattern); + return !result.empty(); + } + + inline std::pair SplitSwitchDef(const std::string &text) + { + std::match_results result; + std::regex_match(text.c_str(), result, option_specifier); + if (result.empty()) + { + throw_or_mimic(text); + } + + const std::string& short_sw = result[2]; + const std::string& long_sw = result[3]; + + return std::pair(short_sw, long_sw); + } + + inline ArguDesc ParseArgument(const char *arg, bool &matched) + { + std::match_results result; + std::regex_match(arg, result, option_matcher); + matched = !result.empty(); + + ArguDesc argu_desc; + if (matched) { + argu_desc.arg_name = result[1].str(); + argu_desc.set_value = result[2].length() > 0; + argu_desc.value = result[3].str(); + if (result[4].length() > 0) + { + argu_desc.grouping = true; + argu_desc.arg_name = result[4].str(); + } + } + + return argu_desc; + } + +#endif // CXXOPTS_NO_REGEX +#undef CXXOPTS_NO_REGEX + } + + namespace detail + { + template + struct SignedCheck; + + template + struct SignedCheck + { + template + void + operator()(bool negative, U u, const std::string& text) + { + if (negative) + { + if (u > static_cast((std::numeric_limits::min)())) + { + throw_or_mimic(text); + } + } + else + { + if (u > static_cast((std::numeric_limits::max)())) + { + throw_or_mimic(text); + } + } + } + }; + + template + struct SignedCheck + { + template + void + operator()(bool, U, const std::string&) const {} + }; + + template + void + check_signed_range(bool negative, U value, const std::string& text) + { + SignedCheck::is_signed>()(negative, value, text); + } + } // namespace detail + + template + void + checked_negate(R& r, T&& t, const std::string&, std::true_type) + { + // if we got to here, then `t` is a positive number that fits into + // `R`. So to avoid MSVC C4146, we first cast it to `R`. + // See https://github.com/jarro2783/cxxopts/issues/62 for more details. + r = static_cast(-static_cast(t-1)-1); + } + + template + void + checked_negate(R&, T&&, const std::string& text, std::false_type) + { + throw_or_mimic(text); + } + + template + void + integer_parser(const std::string& text, T& value) + { + parser_tool::IntegerDesc int_desc = parser_tool::SplitInteger(text); + + using US = typename std::make_unsigned::type; + constexpr bool is_signed = std::numeric_limits::is_signed; + + const bool negative = int_desc.negative.length() > 0; + const uint8_t base = int_desc.base.length() > 0 ? 16 : 10; + const std::string & value_match = int_desc.value; + + US result = 0; + + for (char ch : value_match) + { + US digit = 0; + + if (ch >= '0' && ch <= '9') + { + digit = static_cast(ch - '0'); + } + else if (base == 16 && ch >= 'a' && ch <= 'f') + { + digit = static_cast(ch - 'a' + 10); + } + else if (base == 16 && ch >= 'A' && ch <= 'F') + { + digit = static_cast(ch - 'A' + 10); + } + else + { + throw_or_mimic(text); + } + + const US next = static_cast(result * base + digit); + if (result > next) + { + throw_or_mimic(text); + } + + result = next; + } + + detail::check_signed_range(negative, result, text); + + if (negative) + { + checked_negate(value, result, text, std::integral_constant()); + } + else + { + value = static_cast(result); + } + } + + template + void stringstream_parser(const std::string& text, T& value) + { + std::stringstream in(text); + in >> value; + if (!in) { + throw_or_mimic(text); + } + } + + template ::value>::type* = nullptr + > + void parse_value(const std::string& text, T& value) + { + integer_parser(text, value); + } + + inline + void + parse_value(const std::string& text, bool& value) + { + if (parser_tool::IsTrueText(text)) + { + value = true; + return; + } + + if (parser_tool::IsFalseText(text)) + { + value = false; + return; + } + + throw_or_mimic(text); + } + + inline + void + parse_value(const std::string& text, std::string& value) + { + value = text; + } + + // The fallback parser. It uses the stringstream parser to parse all types + // that have not been overloaded explicitly. It has to be placed in the + // source code before all other more specialized templates. + template ::value>::type* = nullptr + > + void + parse_value(const std::string& text, T& value) { + stringstream_parser(text, value); + } + + template + void + parse_value(const std::string& text, std::vector& value) + { + if (text.empty()) { + T v; + parse_value(text, v); + value.emplace_back(std::move(v)); + return; + } + std::stringstream in(text); + std::string token; + while(!in.eof() && std::getline(in, token, CXXOPTS_VECTOR_DELIMITER)) { + T v; + parse_value(token, v); + value.emplace_back(std::move(v)); + } + } + +#ifdef CXXOPTS_HAS_OPTIONAL + template + void + parse_value(const std::string& text, std::optional& value) + { + T result; + parse_value(text, result); + value = std::move(result); + } +#endif + + inline + void parse_value(const std::string& text, char& c) + { + if (text.length() != 1) + { + throw_or_mimic(text); + } + + c = text[0]; + } + + template + struct type_is_container + { + static constexpr bool value = false; + }; + + template + struct type_is_container> + { + static constexpr bool value = true; + }; + + template + class abstract_value : public Value + { + using Self = abstract_value; + + public: + abstract_value() + : m_result(std::make_shared()) + , m_store(m_result.get()) + { + } + + explicit abstract_value(T* t) + : m_store(t) + { + } + + ~abstract_value() override = default; + + abstract_value& operator=(const abstract_value&) = default; + + abstract_value(const abstract_value& rhs) + { + if (rhs.m_result) + { + m_result = std::make_shared(); + m_store = m_result.get(); + } + else + { + m_store = rhs.m_store; + } + + m_default = rhs.m_default; + m_implicit = rhs.m_implicit; + m_default_value = rhs.m_default_value; + m_implicit_value = rhs.m_implicit_value; + } + + void + parse(const std::string& text) const override + { + parse_value(text, *m_store); + } + + bool + is_container() const override + { + return type_is_container::value; + } + + void + parse() const override + { + parse_value(m_default_value, *m_store); + } + + bool + has_default() const override + { + return m_default; + } + + bool + has_implicit() const override + { + return m_implicit; + } + + std::shared_ptr + default_value(const std::string& value) override + { + m_default = true; + m_default_value = value; + return shared_from_this(); + } + + std::shared_ptr + implicit_value(const std::string& value) override + { + m_implicit = true; + m_implicit_value = value; + return shared_from_this(); + } + + std::shared_ptr + no_implicit_value() override + { + m_implicit = false; + return shared_from_this(); + } + + std::string + get_default_value() const override + { + return m_default_value; + } + + std::string + get_implicit_value() const override + { + return m_implicit_value; + } + + bool + is_boolean() const override + { + return std::is_same::value; + } + + const T& + get() const + { + if (m_store == nullptr) + { + return *m_result; + } + return *m_store; + } + + protected: + std::shared_ptr m_result{}; + T* m_store{}; + + bool m_default = false; + bool m_implicit = false; + + std::string m_default_value{}; + std::string m_implicit_value{}; + }; + + template + class standard_value : public abstract_value + { + public: + using abstract_value::abstract_value; + + CXXOPTS_NODISCARD + std::shared_ptr + clone() const override + { + return std::make_shared>(*this); + } + }; + + template <> + class standard_value : public abstract_value + { + public: + ~standard_value() override = default; + + standard_value() + { + set_default_and_implicit(); + } + + explicit standard_value(bool* b) + : abstract_value(b) + { + set_default_and_implicit(); + } + + std::shared_ptr + clone() const override + { + return std::make_shared>(*this); + } + + private: + + void + set_default_and_implicit() + { + m_default = true; + m_default_value = "false"; + m_implicit = true; + m_implicit_value = "true"; + } + }; + } // namespace values + + template + std::shared_ptr + value() + { + return std::make_shared>(); + } + + template + std::shared_ptr + value(T& t) + { + return std::make_shared>(&t); + } + + class OptionAdder; + + class OptionDetails + { + public: + OptionDetails + ( + std::string short_, + std::string long_, + String desc, + std::shared_ptr val + ) + : m_short(std::move(short_)) + , m_long(std::move(long_)) + , m_desc(std::move(desc)) + , m_value(std::move(val)) + , m_count(0) + { + m_hash = std::hash{}(m_long + m_short); + } + + OptionDetails(const OptionDetails& rhs) + : m_desc(rhs.m_desc) + , m_value(rhs.m_value->clone()) + , m_count(rhs.m_count) + { + } + + OptionDetails(OptionDetails&& rhs) = default; + + CXXOPTS_NODISCARD + const String& + description() const + { + return m_desc; + } + + CXXOPTS_NODISCARD + const Value& + value() const { + return *m_value; + } + + CXXOPTS_NODISCARD + std::shared_ptr + make_storage() const + { + return m_value->clone(); + } + + CXXOPTS_NODISCARD + const std::string& + short_name() const + { + return m_short; + } + + CXXOPTS_NODISCARD + const std::string& + long_name() const + { + return m_long; + } + + size_t + hash() const + { + return m_hash; + } + + private: + std::string m_short{}; + std::string m_long{}; + String m_desc{}; + std::shared_ptr m_value{}; + int m_count; + + size_t m_hash{}; + }; + + struct HelpOptionDetails + { + std::string s; + std::string l; + String desc; + bool has_default; + std::string default_value; + bool has_implicit; + std::string implicit_value; + std::string arg_help; + bool is_container; + bool is_boolean; + }; + + struct HelpGroupDetails + { + std::string name{}; + std::string description{}; + std::vector options{}; + }; + + class OptionValue + { + public: + void + parse + ( + const std::shared_ptr& details, + const std::string& text + ) + { + ensure_value(details); + ++m_count; + m_value->parse(text); + m_long_name = &details->long_name(); + } + + void + parse_default(const std::shared_ptr& details) + { + ensure_value(details); + m_default = true; + m_long_name = &details->long_name(); + m_value->parse(); + } + + void + parse_no_value(const std::shared_ptr& details) + { + m_long_name = &details->long_name(); + } + +#if defined(CXXOPTS_NULL_DEREF_IGNORE) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wnull-dereference" +#endif + + CXXOPTS_NODISCARD + size_t + count() const noexcept + { + return m_count; + } + +#if defined(CXXOPTS_NULL_DEREF_IGNORE) +#pragma GCC diagnostic pop +#endif + + // TODO: maybe default options should count towards the number of arguments + CXXOPTS_NODISCARD + bool + has_default() const noexcept + { + return m_default; + } + + template + const T& + as() const + { + if (m_value == nullptr) { + throw_or_mimic( + m_long_name == nullptr ? "" : *m_long_name); + } + +#ifdef CXXOPTS_NO_RTTI + return static_cast&>(*m_value).get(); +#else + return dynamic_cast&>(*m_value).get(); +#endif + } + + private: + void + ensure_value(const std::shared_ptr& details) + { + if (m_value == nullptr) + { + m_value = details->make_storage(); + } + } + + + const std::string* m_long_name = nullptr; + // Holding this pointer is safe, since OptionValue's only exist in key-value pairs, + // where the key has the string we point to. + std::shared_ptr m_value{}; + size_t m_count = 0; + bool m_default = false; + }; + + class KeyValue + { + public: + KeyValue(std::string key_, std::string value_) + : m_key(std::move(key_)) + , m_value(std::move(value_)) + { + } + + CXXOPTS_NODISCARD + const std::string& + key() const + { + return m_key; + } + + CXXOPTS_NODISCARD + const std::string& + value() const + { + return m_value; + } + + template + T + as() const + { + T result; + values::parse_value(m_value, result); + return result; + } + + private: + std::string m_key; + std::string m_value; + }; + + using ParsedHashMap = std::unordered_map; + using NameHashMap = std::unordered_map; + + class ParseResult + { + public: + class Iterator + { + public: + using iterator_category = std::forward_iterator_tag; + using value_type = KeyValue; + using difference_type = void; + using pointer = const KeyValue*; + using reference = const KeyValue&; + + Iterator() = default; + Iterator(const Iterator&) = default; + + Iterator(const ParseResult *pr, bool end=false) + : m_pr(pr) + , m_iter(end? pr->m_defaults.end(): pr->m_sequential.begin()) + { + } + + Iterator& operator++() + { + ++m_iter; + if(m_iter == m_pr->m_sequential.end()) + { + m_iter = m_pr->m_defaults.begin(); + return *this; + } + return *this; + } + + Iterator operator++(int) + { + Iterator retval = *this; + ++(*this); + return retval; + } + + bool operator==(const Iterator& other) const + { + return m_iter == other.m_iter; + } + + bool operator!=(const Iterator& other) const + { + return !(*this == other); + } + + const KeyValue& operator*() + { + return *m_iter; + } + + const KeyValue* operator->() + { + return m_iter.operator->(); + } + + private: + const ParseResult* m_pr; + std::vector::const_iterator m_iter; + }; + + ParseResult() = default; + ParseResult(const ParseResult&) = default; + + ParseResult(NameHashMap&& keys, ParsedHashMap&& values, std::vector sequential, + std::vector default_opts, std::vector&& unmatched_args) + : m_keys(std::move(keys)) + , m_values(std::move(values)) + , m_sequential(std::move(sequential)) + , m_defaults(std::move(default_opts)) + , m_unmatched(std::move(unmatched_args)) + { + } + + ParseResult& operator=(ParseResult&&) = default; + ParseResult& operator=(const ParseResult&) = default; + + Iterator + begin() const + { + return Iterator(this); + } + + Iterator + end() const + { + return Iterator(this, true); + } + + size_t + count(const std::string& o) const + { + auto iter = m_keys.find(o); + if (iter == m_keys.end()) + { + return 0; + } + + auto viter = m_values.find(iter->second); + + if (viter == m_values.end()) + { + return 0; + } + + return viter->second.count(); + } + + const OptionValue& + operator[](const std::string& option) const + { + auto iter = m_keys.find(option); + + if (iter == m_keys.end()) + { + throw_or_mimic(option); + } + + auto viter = m_values.find(iter->second); + + if (viter == m_values.end()) + { + throw_or_mimic(option); + } + + return viter->second; + } + + const std::vector& + arguments() const + { + return m_sequential; + } + + const std::vector& + unmatched() const + { + return m_unmatched; + } + + const std::vector& + defaults() const + { + return m_defaults; + } + + const std::string + arguments_string() const + { + std::string result; + for(const auto& kv: m_sequential) + { + result += kv.key() + " = " + kv.value() + "\n"; + } + for(const auto& kv: m_defaults) + { + result += kv.key() + " = " + kv.value() + " " + "(default)" + "\n"; + } + return result; + } + + private: + NameHashMap m_keys{}; + ParsedHashMap m_values{}; + std::vector m_sequential{}; + std::vector m_defaults{}; + std::vector m_unmatched{}; + }; + + struct Option + { + Option + ( + std::string opts, + std::string desc, + std::shared_ptr value = ::cxxopts::value(), + std::string arg_help = "" + ) + : opts_(std::move(opts)) + , desc_(std::move(desc)) + , value_(std::move(value)) + , arg_help_(std::move(arg_help)) + { + } + + std::string opts_; + std::string desc_; + std::shared_ptr value_; + std::string arg_help_; + }; + + using OptionMap = std::unordered_map>; + using PositionalList = std::vector; + using PositionalListIterator = PositionalList::const_iterator; + + class OptionParser + { + public: + OptionParser(const OptionMap& options, const PositionalList& positional, bool allow_unrecognised) + : m_options(options) + , m_positional(positional) + , m_allow_unrecognised(allow_unrecognised) + { + } + + ParseResult + parse(int argc, const char* const* argv); + + bool + consume_positional(const std::string& a, PositionalListIterator& next); + + void + checked_parse_arg + ( + int argc, + const char* const* argv, + int& current, + const std::shared_ptr& value, + const std::string& name + ); + + void + add_to_option(OptionMap::const_iterator iter, const std::string& option, const std::string& arg); + + void + parse_option + ( + const std::shared_ptr& value, + const std::string& name, + const std::string& arg = "" + ); + + void + parse_default(const std::shared_ptr& details); + + void + parse_no_value(const std::shared_ptr& details); + + private: + + void finalise_aliases(); + + const OptionMap& m_options; + const PositionalList& m_positional; + + std::vector m_sequential{}; + std::vector m_defaults{}; + bool m_allow_unrecognised; + + ParsedHashMap m_parsed{}; + NameHashMap m_keys{}; + }; + + class Options + { + public: + + explicit Options(std::string program, std::string help_string = "") + : m_program(std::move(program)) + , m_help_string(toLocalString(std::move(help_string))) + , m_custom_help("[OPTION...]") + , m_positional_help("positional parameters") + , m_show_positional(false) + , m_allow_unrecognised(false) + , m_width(76) + , m_tab_expansion(false) + , m_options(std::make_shared()) + { + } + + Options& + positional_help(std::string help_text) + { + m_positional_help = std::move(help_text); + return *this; + } + + Options& + custom_help(std::string help_text) + { + m_custom_help = std::move(help_text); + return *this; + } + + Options& + show_positional_help() + { + m_show_positional = true; + return *this; + } + + Options& + allow_unrecognised_options() + { + m_allow_unrecognised = true; + return *this; + } + + Options& + set_width(size_t width) + { + m_width = width; + return *this; + } + + Options& + set_tab_expansion(bool expansion=true) + { + m_tab_expansion = expansion; + return *this; + } + + ParseResult + parse(int argc, const char* const* argv); + + OptionAdder + add_options(std::string group = ""); + + void + add_options + ( + const std::string& group, + std::initializer_list