diff options
Diffstat (limited to 'xbmc/interfaces/python')
36 files changed, 4580 insertions, 0 deletions
diff --git a/xbmc/interfaces/python/AddonPythonInvoker.cpp b/xbmc/interfaces/python/AddonPythonInvoker.cpp new file mode 100644 index 0000000..b6158a8 --- /dev/null +++ b/xbmc/interfaces/python/AddonPythonInvoker.cpp @@ -0,0 +1,131 @@ +/* + * Copyright (C) 2013-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. + */ + +// python.h should always be included first before any other includes +#include "AddonPythonInvoker.h" + +#include <utility> + +#include <Python.h> +#include <osdefs.h> + +#define MODULE "xbmc" + +#define RUNSCRIPT_PREAMBLE \ + "" \ + "import " MODULE "\n" \ + "class xbmcout:\n" \ + " def __init__(self, loglevel=" MODULE ".LOGDEBUG):\n" \ + " self.ll=loglevel\n" \ + " def write(self, data):\n" \ + " " MODULE ".log(data,self.ll)\n" \ + " def close(self):\n" \ + " " MODULE ".log('.')\n" \ + " def flush(self):\n" \ + " " MODULE ".log('.')\n" \ + "import sys\n" \ + "sys.stdout = xbmcout()\n" \ + "sys.stderr = xbmcout(" MODULE ".LOGERROR)\n" \ + "" + +#define RUNSCRIPT_SETUPTOOLS_HACK \ + "" \ + "import types,sys\n" \ + "pkg_resources_code = \\\n" \ + "\"\"\"\n" \ + "def resource_filename(__name__,__path__):\n" \ + " return __path__\n" \ + "\"\"\"\n" \ + "pkg_resources = types.ModuleType('pkg_resources')\n" \ + "exec(pkg_resources_code, pkg_resources.__dict__)\n" \ + "sys.modules['pkg_resources'] = pkg_resources\n" \ + "" + +#define RUNSCRIPT_SETUP_ENVIROMENT_VARIABLES \ + "" \ + "from os import environ\n" \ + "environ['SSL_CERT_FILE'] = 'system/certs/cacert.pem'\n" \ + "" + +#define RUNSCRIPT_POSTSCRIPT \ + "print('-->Python Interpreter Initialized<--')\n" \ + "" + +#if defined(TARGET_ANDROID) + +#define RUNSCRIPT_COMPLIANT \ + RUNSCRIPT_PREAMBLE RUNSCRIPT_SETUPTOOLS_HACK RUNSCRIPT_POSTSCRIPT + +#elif defined(TARGET_WINDOWS_STORE) + +#define RUNSCRIPT_COMPLIANT \ + RUNSCRIPT_PREAMBLE RUNSCRIPT_SETUP_ENVIROMENT_VARIABLES RUNSCRIPT_POSTSCRIPT + +#else + +#define RUNSCRIPT_COMPLIANT \ + RUNSCRIPT_PREAMBLE RUNSCRIPT_POSTSCRIPT + +#endif + +namespace PythonBindings { +PyObject* PyInit_Module_xbmcdrm(void); +PyObject* PyInit_Module_xbmcgui(void); +PyObject* PyInit_Module_xbmc(void); +PyObject* PyInit_Module_xbmcplugin(void); +PyObject* PyInit_Module_xbmcaddon(void); +PyObject* PyInit_Module_xbmcvfs(void); +} + +using namespace PythonBindings; + +typedef struct +{ + const char *name; + CPythonInvoker::PythonModuleInitialization initialization; +} PythonModule; + +static PythonModule PythonModules[] = + { + { "xbmcdrm", PyInit_Module_xbmcdrm }, + { "xbmcgui", PyInit_Module_xbmcgui }, + { "xbmc", PyInit_Module_xbmc }, + { "xbmcplugin", PyInit_Module_xbmcplugin }, + { "xbmcaddon", PyInit_Module_xbmcaddon }, + { "xbmcvfs", PyInit_Module_xbmcvfs } + }; + +CAddonPythonInvoker::CAddonPythonInvoker(ILanguageInvocationHandler *invocationHandler) + : CPythonInvoker(invocationHandler) +{ + PyImport_AppendInittab("xbmcdrm", PyInit_Module_xbmcdrm); + PyImport_AppendInittab("xbmcgui", PyInit_Module_xbmcgui); + PyImport_AppendInittab("xbmc", PyInit_Module_xbmc); + PyImport_AppendInittab("xbmcplugin", PyInit_Module_xbmcplugin); + PyImport_AppendInittab("xbmcaddon", PyInit_Module_xbmcaddon); + PyImport_AppendInittab("xbmcvfs", PyInit_Module_xbmcvfs); +} + +CAddonPythonInvoker::~CAddonPythonInvoker() = default; + +std::map<std::string, CPythonInvoker::PythonModuleInitialization> CAddonPythonInvoker::getModules() const +{ + static std::map<std::string, PythonModuleInitialization> modules; + if (modules.empty()) + { + for (const PythonModule& pythonModule : PythonModules) + modules.insert(std::make_pair(pythonModule.name, pythonModule.initialization)); + } + + return modules; +} + +const char* CAddonPythonInvoker::getInitializationScript() const +{ + return RUNSCRIPT_COMPLIANT; +} diff --git a/xbmc/interfaces/python/AddonPythonInvoker.h b/xbmc/interfaces/python/AddonPythonInvoker.h new file mode 100644 index 0000000..a846071 --- /dev/null +++ b/xbmc/interfaces/python/AddonPythonInvoker.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2013-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 "interfaces/python/PythonInvoker.h" + +class CAddonPythonInvoker : public CPythonInvoker +{ +public: + explicit CAddonPythonInvoker(ILanguageInvocationHandler *invocationHandler); + ~CAddonPythonInvoker() override; + +protected: + // overrides of CPythonInvoker + std::map<std::string, PythonModuleInitialization> getModules() const override; + const char* getInitializationScript() const override; +}; diff --git a/xbmc/interfaces/python/CMakeLists.txt b/xbmc/interfaces/python/CMakeLists.txt new file mode 100644 index 0000000..061cc2b --- /dev/null +++ b/xbmc/interfaces/python/CMakeLists.txt @@ -0,0 +1,21 @@ +set(SOURCES AddonPythonInvoker.cpp + CallbackHandler.cpp + ContextItemAddonInvoker.cpp + LanguageHook.cpp + PythonInvoker.cpp + XBPython.cpp + swig.cpp + PyContext.cpp) + +set(HEADERS AddonPythonInvoker.h + CallbackHandler.h + ContextItemAddonInvoker.h + LanguageHook.h + preamble.h + PyContext.h + PythonInvoker.h + pythreadstate.h + swig.h + XBPython.h) + +core_add_library(python_interface) diff --git a/xbmc/interfaces/python/CallbackHandler.cpp b/xbmc/interfaces/python/CallbackHandler.cpp new file mode 100644 index 0000000..8fd31a7 --- /dev/null +++ b/xbmc/interfaces/python/CallbackHandler.cpp @@ -0,0 +1,65 @@ +/* + * 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 "CallbackHandler.h" + +#include "LanguageHook.h" + +namespace XBMCAddon +{ + namespace Python + { + /** + * We are ASS-U-MEing that this construction is happening + * within the context of a Python call. This way we can + * store off the PyThreadState to later verify that we're + * handling callbacks in the appropriate thread. + */ + PythonCallbackHandler::PythonCallbackHandler() + { + XBMC_TRACE; + objectThreadState = PyThreadState_Get(); + } + + /** + * Now we are answering the question as to whether or not we are in the + * PyThreadState that we were in when we started. + */ + bool PythonCallbackHandler::isStateOk(AddonClass* obj) + { + XBMC_TRACE; + PyThreadState* state = PyThreadState_Get(); + if (objectThreadState == state) + { + // make sure the interpreter is still active. + AddonClass::Ref<XBMCAddon::Python::PythonLanguageHook> lh(XBMCAddon::Python::PythonLanguageHook::GetIfExists(state->interp)); + if (lh.isNotNull() && lh->HasRegisteredAddonClassInstance(obj) && lh.get() == obj->GetLanguageHook()) + return true; + } + return false; + } + + /** + * For this method we expect the PyThreadState to be passed as the user + * data for the check. + * + * @todo This is a stupid way to get this information back to the handler. + * there should be a more language neutral means. + */ + bool PythonCallbackHandler::shouldRemoveCallback(AddonClass* obj, void* threadState) + { + XBMC_TRACE; + if (threadState == objectThreadState) + return true; + + // we also want to remove the callback if the language hook no longer exists. + // this is a belt-and-suspenders cleanup mechanism + return ! XBMCAddon::Python::PythonLanguageHook::IsAddonClassInstanceRegistered(obj); + } + } +} diff --git a/xbmc/interfaces/python/CallbackHandler.h b/xbmc/interfaces/python/CallbackHandler.h new file mode 100644 index 0000000..b128b27 --- /dev/null +++ b/xbmc/interfaces/python/CallbackHandler.h @@ -0,0 +1,40 @@ +/* + * 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 "interfaces/legacy/CallbackHandler.h" + +#include <Python.h> + +namespace XBMCAddon +{ + namespace Python + { + /** + * This class represents a specialization of the callback handler + * that specifically checks to see if we're in an OK thread state + * based on Python specifics. + */ + class PythonCallbackHandler : public RetardedAsyncCallbackHandler + { + PyThreadState* objectThreadState; + public: + + /** + * We are ASS-U-MEing that this construction is happening + * within the context of a Python call. This way we can + * store off the PyThreadState to later verify that we're + * handling callbacks in the appropriate thread. + */ + PythonCallbackHandler(); + bool isStateOk(AddonClass* obj) override; + bool shouldRemoveCallback(AddonClass* obj, void* threadState) override; + }; + } +} diff --git a/xbmc/interfaces/python/ContextItemAddonInvoker.cpp b/xbmc/interfaces/python/ContextItemAddonInvoker.cpp new file mode 100644 index 0000000..734193b --- /dev/null +++ b/xbmc/interfaces/python/ContextItemAddonInvoker.cpp @@ -0,0 +1,42 @@ +/* + * 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. + */ + +// python.h should always be included first before any other includes +#include "ContextItemAddonInvoker.h" + +#include "interfaces/python/swig.h" +#include "utils/log.h" + +#include <Python.h> +#include <osdefs.h> + + +CContextItemAddonInvoker::CContextItemAddonInvoker( + ILanguageInvocationHandler *invocationHandler, + const CFileItemPtr& item) + : CAddonPythonInvoker(invocationHandler), m_item(CFileItemPtr(new CFileItem(*item.get()))) +{ +} + +CContextItemAddonInvoker::~CContextItemAddonInvoker() = default; + +void CContextItemAddonInvoker::onPythonModuleInitialization(void* moduleDict) +{ + CAddonPythonInvoker::onPythonModuleInitialization(moduleDict); + if (m_item) + { + XBMCAddon::xbmcgui::ListItem* arg = new XBMCAddon::xbmcgui::ListItem(m_item); + PyObject* pyItem = PythonBindings::makePythonInstance(arg, true); + if (pyItem == Py_None || PySys_SetObject("listitem", pyItem) == -1) + { + CLog::Log(LOGERROR, "CPythonInvoker({}, {}): Failed to set sys parameter", GetId(), + m_sourceFile); + //FIXME: we should really abort execution + } + } +} diff --git a/xbmc/interfaces/python/ContextItemAddonInvoker.h b/xbmc/interfaces/python/ContextItemAddonInvoker.h new file mode 100644 index 0000000..b2f4d03 --- /dev/null +++ b/xbmc/interfaces/python/ContextItemAddonInvoker.h @@ -0,0 +1,30 @@ +/* + * 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. + */ + +#pragma once + +#include "interfaces/python/AddonPythonInvoker.h" + +#include <memory> + +class CFileItem; +typedef std::shared_ptr<CFileItem> CFileItemPtr; + +class CContextItemAddonInvoker : public CAddonPythonInvoker +{ +public: + explicit CContextItemAddonInvoker(ILanguageInvocationHandler *invocationHandler, + const CFileItemPtr& item); + ~CContextItemAddonInvoker() override; + +protected: + void onPythonModuleInitialization(void* moduleDict) override; + +private: + const CFileItemPtr m_item; +}; diff --git a/xbmc/interfaces/python/LanguageHook.cpp b/xbmc/interfaces/python/LanguageHook.cpp new file mode 100644 index 0000000..0d4747f --- /dev/null +++ b/xbmc/interfaces/python/LanguageHook.cpp @@ -0,0 +1,231 @@ +/* + * 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 "LanguageHook.h" + +#include "CallbackHandler.h" +#include "PyContext.h" +#include "ServiceBroker.h" +#include "XBPython.h" +#include "interfaces/legacy/AddonUtils.h" +#include "utils/log.h" + +#include <mutex> + +namespace XBMCAddon +{ + namespace Python + { + static AddonClass::Ref<PythonLanguageHook> instance; + + static CCriticalSection hooksMutex; + static std::map<PyInterpreterState*,AddonClass::Ref<PythonLanguageHook> > hooks; + + // vtab instantiation + PythonLanguageHook::~PythonLanguageHook() + { + XBMC_TRACE; + XBMCAddon::LanguageHook::deallocating(); + } + + void PythonLanguageHook::MakePendingCalls() + { + XBMC_TRACE; + PythonCallbackHandler::makePendingCalls(); + } + + void PythonLanguageHook::DelayedCallOpen() + { + XBMC_TRACE; + PyGILLock::releaseGil(); + } + + void PythonLanguageHook::DelayedCallClose() + { + XBMC_TRACE; + PyGILLock::acquireGil(); + } + + void PythonLanguageHook::RegisterMe() + { + XBMC_TRACE; + std::unique_lock<CCriticalSection> lock(hooksMutex); + hooks[m_interp] = AddonClass::Ref<PythonLanguageHook>(this); + } + + void PythonLanguageHook::UnregisterMe() + { + XBMC_TRACE; + std::unique_lock<CCriticalSection> lock(hooksMutex); + hooks.erase(m_interp); + } + + static AddonClass::Ref<XBMCAddon::Python::PythonLanguageHook> g_languageHook; + + // Ok ... we're going to get it even if it doesn't exist. If it doesn't exist then + // we're going to assume we're not in control of the interpreter. This (apparently) + // can be the case. E.g. Libspotify manages to call into a script using a ctypes + // extension but under the control of an Interpreter we know nothing about. In + // cases like this we're going to use a global interpreter + AddonClass::Ref<PythonLanguageHook> PythonLanguageHook::GetIfExists(PyInterpreterState* interp) + { + XBMC_TRACE; + std::unique_lock<CCriticalSection> lock(hooksMutex); + std::map<PyInterpreterState*,AddonClass::Ref<PythonLanguageHook> >::iterator iter = hooks.find(interp); + if (iter != hooks.end()) + return iter->second; + + // if we got here then we need to use the global one. + if (g_languageHook.isNull()) + g_languageHook = new XBMCAddon::Python::PythonLanguageHook(); + + return g_languageHook; + } + + bool PythonLanguageHook::IsAddonClassInstanceRegistered(AddonClass* obj) + { + for (const auto& iter : hooks) + { + if (iter.second->HasRegisteredAddonClassInstance(obj)) + return true; + } + return false; + } + + /** + * PythonCallbackHandler expects to be instantiated PER AddonClass instance + * that is to be used as a callback. This is why this cannot be instantiated + * once. + * + * There is an expectation that this method is called from the Python thread + * that instantiated an AddonClass that has the potential for a callback. + * + * See RetardedAsyncCallbackHandler for more details. + * See PythonCallbackHandler for more details + * See PythonCallbackHandler::PythonCallbackHandler for more details + */ + XBMCAddon::CallbackHandler* PythonLanguageHook::GetCallbackHandler() + { + XBMC_TRACE; + return new PythonCallbackHandler(); + } + + String PythonLanguageHook::GetAddonId() + { + XBMC_TRACE; + + // Get a reference to the main module + // and global dictionary + PyObject* main_module = PyImport_AddModule("__main__"); + if (!main_module) + { + CLog::Log(LOGDEBUG, "PythonLanguageHook::{}: __main__ returns null", __FUNCTION__); + return ""; + } + PyObject* global_dict = PyModule_GetDict(main_module); + // Extract a reference to the function "func_name" + // from the global dictionary + PyObject* pyid = PyDict_GetItemString(global_dict, "__xbmcaddonid__"); + if (pyid) + return PyUnicode_AsUTF8(pyid); + return ""; + } + + String PythonLanguageHook::GetAddonVersion() + { + XBMC_TRACE; + // Get a reference to the main module + // and global dictionary + PyObject* main_module = PyImport_AddModule("__main__"); + if (!main_module) + { + CLog::Log(LOGDEBUG, "PythonLanguageHook::{}: __main__ returns null", __FUNCTION__); + return ""; + } + PyObject* global_dict = PyModule_GetDict(main_module); + // Extract a reference to the function "func_name" + // from the global dictionary + PyObject* pyversion = PyDict_GetItemString(global_dict, "__xbmcapiversion__"); + if (pyversion) + return PyUnicode_AsUTF8(pyversion); + return ""; + } + + long PythonLanguageHook::GetInvokerId() + { + XBMC_TRACE; + + // Get a reference to the main module + // and global dictionary + PyObject* main_module = PyImport_AddModule("__main__"); + if (!main_module) + { + CLog::Log(LOGDEBUG, "PythonLanguageHook::{}: __main__ returns null", __FUNCTION__); + return -1; + } + PyObject* global_dict = PyModule_GetDict(main_module); + // Extract a reference to the function "func_name" + // from the global dictionary + PyObject* pyid = PyDict_GetItemString(global_dict, "__xbmcinvokerid__"); + if (pyid) + return PyLong_AsLong(pyid); + return -1; + } + + void PythonLanguageHook::RegisterPlayerCallback(IPlayerCallback* player) + { + XBMC_TRACE; + CServiceBroker::GetXBPython().RegisterPythonPlayerCallBack(player); + } + void PythonLanguageHook::UnregisterPlayerCallback(IPlayerCallback* player) + { + XBMC_TRACE; + CServiceBroker::GetXBPython().UnregisterPythonPlayerCallBack(player); + } + void PythonLanguageHook::RegisterMonitorCallback(XBMCAddon::xbmc::Monitor* monitor) + { + XBMC_TRACE; + CServiceBroker::GetXBPython().RegisterPythonMonitorCallBack(monitor); + } + void PythonLanguageHook::UnregisterMonitorCallback(XBMCAddon::xbmc::Monitor* monitor) + { + XBMC_TRACE; + CServiceBroker::GetXBPython().UnregisterPythonMonitorCallBack(monitor); + } + + bool PythonLanguageHook::WaitForEvent(CEvent& hEvent, unsigned int milliseconds) + { + XBMC_TRACE; + return CServiceBroker::GetXBPython().WaitForEvent(hEvent, milliseconds); + } + + void PythonLanguageHook::RegisterAddonClassInstance(AddonClass* obj) + { + XBMC_TRACE; + std::unique_lock<CCriticalSection> l(*this); + obj->Acquire(); + currentObjects.insert(obj); + } + + void PythonLanguageHook::UnregisterAddonClassInstance(AddonClass* obj) + { + XBMC_TRACE; + std::unique_lock<CCriticalSection> l(*this); + if (currentObjects.erase(obj) > 0) + obj->Release(); + } + + bool PythonLanguageHook::HasRegisteredAddonClassInstance(AddonClass* obj) + { + XBMC_TRACE; + std::unique_lock<CCriticalSection> l(*this); + return currentObjects.find(obj) != currentObjects.end(); + } + } +} diff --git a/xbmc/interfaces/python/LanguageHook.h b/xbmc/interfaces/python/LanguageHook.h new file mode 100644 index 0000000..6a4e0d0 --- /dev/null +++ b/xbmc/interfaces/python/LanguageHook.h @@ -0,0 +1,94 @@ +/* + * 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 "interfaces/legacy/LanguageHook.h" +#include "threads/Event.h" + +#include <map> +#include <mutex> +#include <set> + +#include <Python.h> + +namespace XBMCAddon +{ + namespace Python + { + struct MutableInteger; + + /** + * This class supplies the python specific functionality for + * plugging into the API. It's got a static only implementation + * and uses the singleton pattern for access. + */ + class PythonLanguageHook : public XBMCAddon::LanguageHook + { + PyInterpreterState* m_interp; + CCriticalSection crit; + std::set<AddonClass*> currentObjects; + + // This constructor is only used to instantiate the global LanguageHook + inline PythonLanguageHook() : m_interp(NULL) { } + + public: + + inline explicit PythonLanguageHook(PyInterpreterState* interp) : m_interp(interp) { } + ~PythonLanguageHook() override; + + void DelayedCallOpen() override; + void DelayedCallClose() override; + void MakePendingCalls() override; + + /** + * PythonCallbackHandler expects to be instantiated PER AddonClass instance + * that is to be used as a callback. This is why this cannot be instantiated + * once. + * + * There is an expectation that this method is called from the Python thread + * that instantiated an AddonClass that has the potential for a callback. + * + * See RetardedAsyncCallbackHandler for more details. + * See PythonCallbackHandler for more details + * See PythonCallbackHandler::PythonCallbackHandler for more details + */ + XBMCAddon::CallbackHandler* GetCallbackHandler() override; + + String GetAddonId() override; + String GetAddonVersion() override; + long GetInvokerId() override; + + void RegisterPlayerCallback(IPlayerCallback* player) override; + void UnregisterPlayerCallback(IPlayerCallback* player) override; + void RegisterMonitorCallback(XBMCAddon::xbmc::Monitor* monitor) override; + void UnregisterMonitorCallback(XBMCAddon::xbmc::Monitor* monitor) override; + bool WaitForEvent(CEvent& hEvent, unsigned int milliseconds) override; + + static AddonClass::Ref<PythonLanguageHook> GetIfExists(PyInterpreterState* interp); + static bool IsAddonClassInstanceRegistered(AddonClass* obj); + + void RegisterAddonClassInstance(AddonClass* obj); + void UnregisterAddonClassInstance(AddonClass* obj); + bool HasRegisteredAddonClassInstance(AddonClass* obj); + inline bool HasRegisteredAddonClasses() + { + std::unique_lock<CCriticalSection> l(*this); + return !currentObjects.empty(); + } + + // You should hold the lock on the LanguageHook itself if you're + // going to do anything with the set that gets returned. + inline std::set<AddonClass*>& GetRegisteredAddonClasses() { return currentObjects; } + + void UnregisterMe(); + void RegisterMe(); + }; + } +} + diff --git a/xbmc/interfaces/python/MethodType.groovy b/xbmc/interfaces/python/MethodType.groovy new file mode 100644 index 0000000..18597fd --- /dev/null +++ b/xbmc/interfaces/python/MethodType.groovy @@ -0,0 +1,14 @@ +/* + * 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. + */ + +public enum MethodType +{ + constructor, destructor, method +} + + diff --git a/xbmc/interfaces/python/PyContext.cpp b/xbmc/interfaces/python/PyContext.cpp new file mode 100644 index 0000000..3b64ac6 --- /dev/null +++ b/xbmc/interfaces/python/PyContext.cpp @@ -0,0 +1,117 @@ +/* + * 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 "PyContext.h" + +#include "utils/log.h" + +#include <Python.h> + +namespace XBMCAddon +{ + namespace Python + { + struct PyContextState + { + inline explicit PyContextState(bool pcreatedByGilRelease = false) : + state(NULL), createdByGilRelease(pcreatedByGilRelease) {} + + int value = 0; + PyThreadState* state; + int gilReleasedDepth = 0; + bool createdByGilRelease; + }; + + static thread_local PyContextState* tlsPyContextState; + + void* PyContext::enterContext() + { + PyContextState* cur = tlsPyContextState; + if (cur == NULL) + { + cur = new PyContextState(); + tlsPyContextState = cur; + } + + // increment the count + cur->value++; + + return cur; + } + + void PyContext::leaveContext() + { + // here we ASSUME that the constructor was called. + PyContextState* cur = tlsPyContextState; + cur->value--; + int curlevel = cur->value; + + // this is a hack but ... + if (curlevel < 0) + { + CLog::Log(LOGERROR, "FATAL: PyContext closed more than opened"); + curlevel = cur->value = 0; + } + + if (curlevel == 0) + { + // clear the tlsPyContextState + tlsPyContextState = NULL; + delete cur; + } + } + + void PyGILLock::releaseGil() + { + PyContextState* cur = tlsPyContextState; + + // This means we're not within the python context, but + // because we may be in a thread spawned by python itself, + // we need to handle this. + if (!cur) + { + cur = static_cast<PyContextState*>(PyContext::enterContext()); + cur->createdByGilRelease = true; + } + + if (cur->gilReleasedDepth == 0) // true if we are at the outermost + { + PyThreadState* _save; + // this macro sets _save + { + Py_UNBLOCK_THREADS + } + cur->state = _save; + } + cur->gilReleasedDepth++; // the first time this goes to 1 + } + + void PyGILLock::acquireGil() + { + PyContextState* cur = tlsPyContextState; + + // it's not possible for cur to be NULL (and if it is, we want to fail anyway). + + // decrement the depth and make sure we're in the right place. + cur->gilReleasedDepth--; + if (cur->gilReleasedDepth == 0) // are we back to zero? + { + PyThreadState* _save = cur->state; + // This macros uses _save + { + Py_BLOCK_THREADS + } + cur->state = NULL; // clear the state to indicate we've reacquired the gil + + // we clear it only if we created it on this level. + if (cur->createdByGilRelease) + PyContext::leaveContext(); + } + } + } +} diff --git a/xbmc/interfaces/python/PyContext.h b/xbmc/interfaces/python/PyContext.h new file mode 100644 index 0000000..216a45f --- /dev/null +++ b/xbmc/interfaces/python/PyContext.h @@ -0,0 +1,49 @@ +/* + * 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 + +namespace XBMCAddon +{ + namespace Python + { + class PyGILLock; + + /** + * These classes should NOT be used with 'new'. They are expected to reside + * as stack instances and they act as "Guard" classes that track the + * current context. + */ + class PyContext + { + protected: + friend class PyGILLock; + static void* enterContext(); + static void leaveContext(); + public: + + inline PyContext() { enterContext(); } + inline ~PyContext() { leaveContext(); } + }; + + /** + * This class supports recursive locking of the GIL. It assumes that + * all Python GIL manipulation is done through this class so that it + * can monitor the current owner. + */ + class PyGILLock + { + public: + static void releaseGil(); + static void acquireGil(); + + inline PyGILLock() { releaseGil(); } + inline ~PyGILLock() { acquireGil(); } + }; + } +} diff --git a/xbmc/interfaces/python/PythonInvoker.cpp b/xbmc/interfaces/python/PythonInvoker.cpp new file mode 100644 index 0000000..1e9d344 --- /dev/null +++ b/xbmc/interfaces/python/PythonInvoker.cpp @@ -0,0 +1,724 @@ +/* + * Copyright (C) 2013-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. + */ + +// clang-format off +// python.h should always be included first before any other includes +#include <mutex> +#include <Python.h> +// clang-format on + +#include "PythonInvoker.h" + +#include "ServiceBroker.h" +#include "addons/AddonManager.h" +#include "addons/addoninfo/AddonInfo.h" +#include "addons/addoninfo/AddonType.h" +#include "dialogs/GUIDialogKaiToast.h" +#include "filesystem/SpecialProtocol.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/LocalizeStrings.h" +#include "interfaces/python/PyContext.h" +#include "interfaces/python/pythreadstate.h" +#include "interfaces/python/swig.h" +#include "messaging/ApplicationMessenger.h" +#include "threads/SingleLock.h" +#include "threads/SystemClock.h" +#include "utils/CharsetConverter.h" +#include "utils/FileUtils.h" +#include "utils/StringUtils.h" +#include "utils/URIUtils.h" +#include "utils/XTimeUtils.h" +#include "utils/log.h" +#include "windowing/GraphicContext.h" + +// clang-format off +// This breaks fmt because of SEP define, don't include +// before anything that includes logging +#include <osdefs.h> +// clang-format on + +#include <cassert> +#include <iterator> + +#ifdef TARGET_WINDOWS +extern "C" FILE* fopen_utf8(const char* _Filename, const char* _Mode); +#else +#define fopen_utf8 fopen +#endif + +#define GC_SCRIPT \ + "import gc\n" \ + "gc.collect(2)\n" + +#define PY_PATH_SEP DELIM + +// Time before ill-behaved scripts are terminated +#define PYTHON_SCRIPT_TIMEOUT 5000ms // ms + +using namespace XFILE; +using namespace std::chrono_literals; + +#define PythonModulesSize sizeof(PythonModules) / sizeof(PythonModule) + +CCriticalSection CPythonInvoker::s_critical; + +static const std::string getListOfAddonClassesAsString( + XBMCAddon::AddonClass::Ref<XBMCAddon::Python::PythonLanguageHook>& languageHook) +{ + std::string message; + std::unique_lock<CCriticalSection> l(*(languageHook.get())); + const std::set<XBMCAddon::AddonClass*>& acs = languageHook->GetRegisteredAddonClasses(); + bool firstTime = true; + for (const auto& iter : acs) + { + if (!firstTime) + message += ","; + else + firstTime = false; + message += iter->GetClassname(); + } + + return message; +} + +CPythonInvoker::CPythonInvoker(ILanguageInvocationHandler* invocationHandler) + : ILanguageInvoker(invocationHandler), m_threadState(NULL), m_stop(false) +{ +} + +CPythonInvoker::~CPythonInvoker() +{ + // nothing to do for the default invoker used for registration with the + // CScriptInvocationManager + if (GetId() < 0) + return; + + if (GetState() < InvokerStateExecutionDone) + CLog::Log(LOGDEBUG, "CPythonInvoker({}): waiting for python thread \"{}\" to stop", GetId(), + (!m_sourceFile.empty() ? m_sourceFile : "unknown script")); + Stop(true); + pulseGlobalEvent(); + + onExecutionFinalized(); +} + +bool CPythonInvoker::Execute( + const std::string& script, + const std::vector<std::string>& arguments /* = std::vector<std::string>() */) +{ + if (script.empty()) + return false; + + if (!CFileUtils::Exists(script)) + { + CLog::Log(LOGERROR, "CPythonInvoker({}): python script \"{}\" does not exist", GetId(), + CSpecialProtocol::TranslatePath(script)); + return false; + } + + if (!onExecutionInitialized()) + return false; + + return ILanguageInvoker::Execute(script, arguments); +} + +bool CPythonInvoker::execute(const std::string& script, const std::vector<std::string>& arguments) +{ + std::vector<std::wstring> w_arguments; + for (const auto& argument : arguments) + { + std::wstring w_argument; + g_charsetConverter.utf8ToW(argument, w_argument); + w_arguments.push_back(w_argument); + } + return execute(script, w_arguments); +} + +bool CPythonInvoker::execute(const std::string& script, std::vector<std::wstring>& arguments) +{ + // copy the code/script into a local string buffer + m_sourceFile = script; + std::set<std::string> pythonPath; + + CLog::Log(LOGDEBUG, "CPythonInvoker({}, {}): start processing", GetId(), m_sourceFile); + + std::string realFilename(CSpecialProtocol::TranslatePath(m_sourceFile)); + std::string scriptDir = URIUtils::GetDirectory(realFilename); + URIUtils::RemoveSlashAtEnd(scriptDir); + + // set m_threadState if it's not set. + PyThreadState* l_threadState = nullptr; + bool newInterp = false; + { + if (!m_threadState) + { +#if PY_VERSION_HEX < 0x03070000 + // this is a TOTAL hack. We need the GIL but we need to borrow a PyThreadState in order to get it + // as of Python 3.2 since PyEval_AcquireLock is deprecated + extern PyThreadState* savestate; + PyEval_RestoreThread(savestate); +#else + PyThreadState* ts = PyInterpreterState_ThreadHead(PyInterpreterState_Main()); + PyEval_RestoreThread(ts); +#endif + l_threadState = Py_NewInterpreter(); + PyEval_ReleaseThread(l_threadState); + if (l_threadState == NULL) + { + CLog::Log(LOGERROR, "CPythonInvoker({}, {}): FAILED to get thread m_threadState!", GetId(), + m_sourceFile); + return false; + } + newInterp = true; + } + else + l_threadState = m_threadState; + } + + // get the GIL + PyEval_RestoreThread(l_threadState); + if (newInterp) + { + m_languageHook = new XBMCAddon::Python::PythonLanguageHook(l_threadState->interp); + m_languageHook->RegisterMe(); + + onInitialization(); + setState(InvokerStateInitialized); + + if (realFilename == m_sourceFile) + CLog::Log(LOGDEBUG, "CPythonInvoker({}, {}): the source file to load is \"{}\"", GetId(), + m_sourceFile, m_sourceFile); + else + CLog::Log(LOGDEBUG, "CPythonInvoker({}, {}): the source file to load is \"{}\" (\"{}\")", + GetId(), m_sourceFile, m_sourceFile, realFilename); + + // get path from script file name and add python path's + // this is used for python so it will search modules from script path first + pythonPath.emplace(scriptDir); + + // add all addon module dependencies to path + if (m_addon) + { + std::set<std::string> paths; + getAddonModuleDeps(m_addon, paths); + for (const auto& it : paths) + pythonPath.emplace(it); + } + else + { // for backwards compatibility. + // we don't have any addon so just add all addon modules installed + CLog::Log( + LOGWARNING, + "CPythonInvoker({}): Script invoked without an addon. Adding all addon " + "modules installed to python path as fallback. This behaviour will be removed in future " + "version.", + GetId()); + ADDON::VECADDONS addons; + CServiceBroker::GetAddonMgr().GetAddons(addons, ADDON::AddonType::SCRIPT_MODULE); + for (unsigned int i = 0; i < addons.size(); ++i) + pythonPath.emplace(CSpecialProtocol::TranslatePath(addons[i]->LibPath())); + } + + PyObject* sysPath = PySys_GetObject("path"); + + std::for_each(pythonPath.crbegin(), pythonPath.crend(), + [&sysPath](const auto& path) + { + PyObject* pyPath = PyUnicode_FromString(path.c_str()); + PyList_Insert(sysPath, 0, pyPath); + + Py_DECREF(pyPath); + }); + + CLog::Log(LOGDEBUG, "CPythonInvoker({}): full python path:", GetId()); + + Py_ssize_t pathListSize = PyList_Size(sysPath); + + for (Py_ssize_t index = 0; index < pathListSize; index++) + { + if (index == 0 && !pythonPath.empty()) + CLog::Log(LOGDEBUG, "CPythonInvoker({}): custom python path:", GetId()); + + if (index == static_cast<ssize_t>(pythonPath.size())) + CLog::Log(LOGDEBUG, "CPythonInvoker({}): default python path:", GetId()); + + PyObject* pyPath = PyList_GetItem(sysPath, index); + CLog::Log(LOGDEBUG, "CPythonInvoker({}): {}", GetId(), PyUnicode_AsUTF8(pyPath)); + } + + { // set the m_threadState to this new interp + std::unique_lock<CCriticalSection> lockMe(m_critical); + m_threadState = l_threadState; + } + } + else + // swap in my thread m_threadState + PyThreadState_Swap(m_threadState); + + PyObject* sysArgv = PyList_New(0); + + if (arguments.empty()) + arguments.emplace_back(L""); + + CLog::Log(LOGDEBUG, "CPythonInvoker({}): adding args:", GetId()); + + for (const auto& arg : arguments) + { + PyObject* pyArg = PyUnicode_FromWideChar(arg.c_str(), arg.length()); + PyList_Append(sysArgv, pyArg); + CLog::Log(LOGDEBUG, "CPythonInvoker({}): {}", GetId(), PyUnicode_AsUTF8(pyArg)); + + Py_DECREF(pyArg); + } + + PySys_SetObject("argv", sysArgv); + + CLog::Log(LOGDEBUG, "CPythonInvoker({}, {}): entering source directory {}", GetId(), m_sourceFile, + scriptDir); + PyObject* module = PyImport_AddModule("__main__"); + PyObject* moduleDict = PyModule_GetDict(module); + + // we need to check if we was asked to abort before we had inited + bool stopping = false; + { + GilSafeSingleLock lock(m_critical); + stopping = m_stop; + } + + bool failed = false; + std::string exceptionType, exceptionValue, exceptionTraceback; + if (!stopping) + { + try + { + // run script from file + // We need to have python open the file because on Windows the DLL that python + // is linked against may not be the DLL that xbmc is linked against so + // passing a FILE* to python from an fopen has the potential to crash. + + PyObject* pyRealFilename = Py_BuildValue("s", realFilename.c_str()); + FILE* fp = _Py_fopen_obj(pyRealFilename, "rb"); + Py_DECREF(pyRealFilename); + + if (fp != NULL) + { + PyObject* f = PyUnicode_FromString(realFilename.c_str()); + PyDict_SetItemString(moduleDict, "__file__", f); + + onPythonModuleInitialization(moduleDict); + + Py_DECREF(f); + setState(InvokerStateRunning); + XBMCAddon::Python::PyContext + pycontext; // this is a guard class that marks this callstack as being in a python context + executeScript(fp, realFilename, moduleDict); + } + else + CLog::Log(LOGERROR, "CPythonInvoker({}, {}): {} not found!", GetId(), m_sourceFile, + m_sourceFile); + } + catch (const XbmcCommons::Exception& e) + { + setState(InvokerStateFailed); + e.LogThrowMessage(); + failed = true; + } + catch (...) + { + setState(InvokerStateFailed); + CLog::Log(LOGERROR, "CPythonInvoker({}, {}): failure in script", GetId(), m_sourceFile); + failed = true; + } + } + + m_systemExitThrown = false; + InvokerState stateToSet; + if (!failed && !PyErr_Occurred()) + { + CLog::Log(LOGDEBUG, "CPythonInvoker({}, {}): script successfully run", GetId(), m_sourceFile); + stateToSet = InvokerStateScriptDone; + onSuccess(); + } + else if (PyErr_ExceptionMatches(PyExc_SystemExit)) + { + m_systemExitThrown = true; + CLog::Log(LOGDEBUG, "CPythonInvoker({}, {}): script aborted", GetId(), m_sourceFile); + stateToSet = InvokerStateFailed; + onAbort(); + } + else + { + stateToSet = InvokerStateFailed; + + // if it failed with an exception we already logged the details + if (!failed) + { + PythonBindings::PythonToCppException* e = NULL; + if (PythonBindings::PythonToCppException::ParsePythonException(exceptionType, exceptionValue, + exceptionTraceback)) + e = new PythonBindings::PythonToCppException(exceptionType, exceptionValue, + exceptionTraceback); + else + e = new PythonBindings::PythonToCppException(); + + e->LogThrowMessage(); + delete e; + } + + onError(exceptionType, exceptionValue, exceptionTraceback); + } + + std::unique_lock<CCriticalSection> lock(m_critical); + // no need to do anything else because the script has already stopped + if (failed) + { + setState(stateToSet); + return true; + } + + if (m_threadState) + { + // make sure all sub threads have finished + for (PyThreadState* old = nullptr; m_threadState != nullptr;) + { + PyThreadState* s = PyInterpreterState_ThreadHead(m_threadState->interp); + for (; s && s == m_threadState;) + s = PyThreadState_Next(s); + + if (!s) + break; + + if (old != s) + { + CLog::Log(LOGINFO, "CPythonInvoker({}, {}): waiting on thread {}", GetId(), m_sourceFile, + (uint64_t)s->thread_id); + old = s; + } + + lock.unlock(); + CPyThreadState pyState; + KODI::TIME::Sleep(100ms); + pyState.Restore(); + lock.lock(); + } + } + + // pending calls must be cleared out + XBMCAddon::RetardedAsyncCallbackHandler::clearPendingCalls(m_threadState); + + assert(m_threadState != nullptr); + PyEval_ReleaseThread(m_threadState); + + setState(stateToSet); + + return true; +} + +void CPythonInvoker::executeScript(FILE* fp, const std::string& script, PyObject* moduleDict) +{ + if (fp == NULL || script.empty() || moduleDict == NULL) + return; + + int m_Py_file_input = Py_file_input; + PyRun_FileExFlags(fp, script.c_str(), m_Py_file_input, moduleDict, moduleDict, 1, NULL); +} + +FILE* CPythonInvoker::PyFile_AsFileWithMode(PyObject* py_file, const char* mode) +{ + PyObject* ret = PyObject_CallMethod(py_file, "flush", ""); + if (ret == NULL) + return NULL; + Py_DECREF(ret); + + int fd = PyObject_AsFileDescriptor(py_file); + if (fd == -1) + return NULL; + + FILE* f = fdopen(fd, mode); + if (f == NULL) + { + PyErr_SetFromErrno(PyExc_OSError); + return NULL; + } + + return f; +} + +bool CPythonInvoker::stop(bool abort) +{ + std::unique_lock<CCriticalSection> lock(m_critical); + m_stop = true; + + if (!IsRunning() && !m_threadState) + return false; + + if (m_threadState != NULL) + { + if (IsRunning()) + { + setState(InvokerStateStopping); + lock.unlock(); + + PyEval_RestoreThread((PyThreadState*)m_threadState); + + //tell xbmc.Monitor to call onAbortRequested() + if (m_addon) + { + CLog::Log(LOGDEBUG, "CPythonInvoker({}, {}): trigger Monitor abort request", GetId(), + m_sourceFile); + AbortNotification(); + } + + PyEval_ReleaseThread(m_threadState); + } + else + //Release the lock while waiting for threads to finish + lock.unlock(); + + XbmcThreads::EndTime<> timeout(PYTHON_SCRIPT_TIMEOUT); + while (!m_stoppedEvent.Wait(15ms)) + { + if (timeout.IsTimePast()) + { + CLog::Log(LOGERROR, + "CPythonInvoker({}, {}): script didn't stop in {} seconds - let's kill it", + GetId(), m_sourceFile, + std::chrono::duration_cast<std::chrono::seconds>(PYTHON_SCRIPT_TIMEOUT).count()); + break; + } + + // We can't empty-spin in the main thread and expect scripts to be able to + // dismantle themselves. Python dialogs aren't normal XBMC dialogs, they rely + // on TMSG_GUI_PYTHON_DIALOG messages, so pump the message loop. + if (CServiceBroker::GetAppMessenger()->IsProcessThread()) + { + CServiceBroker::GetAppMessenger()->ProcessMessages(); + } + } + + lock.lock(); + + setState(InvokerStateExecutionDone); + + // Useful for add-on performance metrics + if (!timeout.IsTimePast()) + CLog::Log(LOGDEBUG, "CPythonInvoker({}, {}): script termination took {}ms", GetId(), + m_sourceFile, (PYTHON_SCRIPT_TIMEOUT - timeout.GetTimeLeft()).count()); + + // Since we released the m_critical it's possible that the state is cleaned up + // so we need to recheck for m_threadState == NULL + if (m_threadState != NULL) + { + { + // grabbing the PyLock while holding the m_critical is asking for a deadlock + CSingleExit ex2(m_critical); + PyEval_RestoreThread((PyThreadState*)m_threadState); + } + + + PyThreadState* state = PyInterpreterState_ThreadHead(m_threadState->interp); + while (state) + { + // Raise a SystemExit exception in python threads + Py_XDECREF(state->async_exc); + state->async_exc = PyExc_SystemExit; + Py_XINCREF(state->async_exc); + state = PyThreadState_Next(state); + } + + // If a dialog entered its doModal(), we need to wake it to see the exception + pulseGlobalEvent(); + + PyEval_ReleaseThread(m_threadState); + } + lock.unlock(); + + setState(InvokerStateFailed); + } + + return true; +} + +// Always called from Invoker thread +void CPythonInvoker::onExecutionDone() +{ + std::unique_lock<CCriticalSection> lock(m_critical); + if (m_threadState != NULL) + { + CLog::Log(LOGDEBUG, "{}({}, {})", __FUNCTION__, GetId(), m_sourceFile); + + PyEval_RestoreThread(m_threadState); + + onDeinitialization(); + + // run the gc before finishing + // + // if the script exited by throwing a SystemExit exception then going back + // into the interpreter causes this python bug to get hit: + // http://bugs.python.org/issue10582 + // and that causes major failures. So we are not going to go back in + // to run the GC if that's the case. + if (!m_stop && m_languageHook->HasRegisteredAddonClasses() && !m_systemExitThrown && + PyRun_SimpleString(GC_SCRIPT) == -1) + CLog::Log(LOGERROR, + "CPythonInvoker({}, {}): failed to run the gc to clean up after running prior to " + "shutting down the Interpreter", + GetId(), m_sourceFile); + + Py_EndInterpreter(m_threadState); + + // If we still have objects left around, produce an error message detailing what's been left behind + if (m_languageHook->HasRegisteredAddonClasses()) + CLog::Log(LOGWARNING, + "CPythonInvoker({}, {}): the python script \"{}\" has left several " + "classes in memory that we couldn't clean up. The classes include: {}", + GetId(), m_sourceFile, m_sourceFile, getListOfAddonClassesAsString(m_languageHook)); + + // unregister the language hook + m_languageHook->UnregisterMe(); + +#if PY_VERSION_HEX < 0x03070000 + PyEval_ReleaseLock(); +#else + PyThreadState_Swap(PyInterpreterState_ThreadHead(PyInterpreterState_Main())); + PyEval_SaveThread(); +#endif + + // set stopped event - this allows ::stop to run and kill remaining threads + // this event has to be fired without holding m_critical + // also the GIL (PyEval_AcquireLock) must not be held + // if not obeyed there is still no deadlock because ::stop waits with timeout (smart one!) + m_stoppedEvent.Set(); + + m_threadState = nullptr; + + setState(InvokerStateExecutionDone); + } + ILanguageInvoker::onExecutionDone(); +} + +void CPythonInvoker::onExecutionFailed() +{ + PyEval_SaveThread(); + + setState(InvokerStateFailed); + CLog::Log(LOGERROR, "CPythonInvoker({}, {}): abnormally terminating python thread", GetId(), + m_sourceFile); + + std::unique_lock<CCriticalSection> lock(m_critical); + m_threadState = NULL; + + ILanguageInvoker::onExecutionFailed(); +} + +void CPythonInvoker::onInitialization() +{ + XBMC_TRACE; + { + GilSafeSingleLock lock(s_critical); + initializeModules(getModules()); + } + + // get a possible initialization script + const char* runscript = getInitializationScript(); + if (runscript != NULL && strlen(runscript) > 0) + { + // redirecting default output to debug console + if (PyRun_SimpleString(runscript) == -1) + CLog::Log(LOGFATAL, "CPythonInvoker({}, {}): initialize error", GetId(), m_sourceFile); + } +} + +void CPythonInvoker::onPythonModuleInitialization(void* moduleDict) +{ + if (m_addon.get() == NULL || moduleDict == NULL) + return; + + PyObject* moduleDictionary = (PyObject*)moduleDict; + + PyObject* pyaddonid = PyUnicode_FromString(m_addon->ID().c_str()); + PyDict_SetItemString(moduleDictionary, "__xbmcaddonid__", pyaddonid); + + ADDON::CAddonVersion version = m_addon->GetDependencyVersion("xbmc.python"); + PyObject* pyxbmcapiversion = PyUnicode_FromString(version.asString().c_str()); + PyDict_SetItemString(moduleDictionary, "__xbmcapiversion__", pyxbmcapiversion); + + PyObject* pyinvokerid = PyLong_FromLong(GetId()); + PyDict_SetItemString(moduleDictionary, "__xbmcinvokerid__", pyinvokerid); + + CLog::Log(LOGDEBUG, + "CPythonInvoker({}, {}): instantiating addon using automatically obtained id of \"{}\" " + "dependent on version {} of the xbmc.python api", + GetId(), m_sourceFile, m_addon->ID(), version.asString()); +} + +void CPythonInvoker::onDeinitialization() +{ + XBMC_TRACE; +} + +void CPythonInvoker::onError(const std::string& exceptionType /* = "" */, + const std::string& exceptionValue /* = "" */, + const std::string& exceptionTraceback /* = "" */) +{ + CPyThreadState releaseGil; + std::unique_lock<CCriticalSection> gc(CServiceBroker::GetWinSystem()->GetGfxContext()); + + CGUIDialogKaiToast* pDlgToast = + CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogKaiToast>( + WINDOW_DIALOG_KAI_TOAST); + if (pDlgToast != NULL) + { + std::string message; + if (m_addon && !m_addon->Name().empty()) + message = StringUtils::Format(g_localizeStrings.Get(2102), m_addon->Name()); + else + message = g_localizeStrings.Get(2103); + pDlgToast->QueueNotification(CGUIDialogKaiToast::Error, message, g_localizeStrings.Get(2104)); + } +} + +void CPythonInvoker::initializeModules( + const std::map<std::string, PythonModuleInitialization>& modules) +{ + for (const auto& module : modules) + { + if (!initializeModule(module.second)) + CLog::Log(LOGWARNING, "CPythonInvoker({}, {}): unable to initialize python module \"{}\"", + GetId(), m_sourceFile, module.first); + } +} + +bool CPythonInvoker::initializeModule(PythonModuleInitialization module) +{ + if (module == NULL) + return false; + + return module() != nullptr; +} + +void CPythonInvoker::getAddonModuleDeps(const ADDON::AddonPtr& addon, std::set<std::string>& paths) +{ + for (const auto& it : addon->GetDependencies()) + { + //Check if dependency is a module addon + ADDON::AddonPtr dependency; + if (CServiceBroker::GetAddonMgr().GetAddon(it.id, dependency, ADDON::AddonType::SCRIPT_MODULE, + ADDON::OnlyEnabled::CHOICE_YES)) + { + std::string path = CSpecialProtocol::TranslatePath(dependency->LibPath()); + if (paths.find(path) == paths.end()) + { + // add it and its dependencies + paths.insert(path); + getAddonModuleDeps(dependency, paths); + } + } + } +} diff --git a/xbmc/interfaces/python/PythonInvoker.h b/xbmc/interfaces/python/PythonInvoker.h new file mode 100644 index 0000000..dd093ed --- /dev/null +++ b/xbmc/interfaces/python/PythonInvoker.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2013-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 "interfaces/generic/ILanguageInvoker.h" +#include "interfaces/legacy/Addon.h" +#include "interfaces/python/LanguageHook.h" +#include "threads/CriticalSection.h" +#include "threads/Event.h" + +#include <map> +#include <string> +#include <vector> + +typedef struct _object PyObject; + +class CPythonInvoker : public ILanguageInvoker +{ +public: + explicit CPythonInvoker(ILanguageInvocationHandler* invocationHandler); + ~CPythonInvoker() override; + + bool Execute(const std::string& script, + const std::vector<std::string>& arguments = std::vector<std::string>()) override; + + bool IsStopping() const override { return m_stop || ILanguageInvoker::IsStopping(); } + + typedef PyObject* (*PythonModuleInitialization)(); + +protected: + // implementation of ILanguageInvoker + bool execute(const std::string& script, const std::vector<std::string>& arguments) override; + virtual void executeScript(FILE* fp, const std::string& script, PyObject* moduleDict); + bool stop(bool abort) override; + void onExecutionDone() override; + void onExecutionFailed() override; + + // custom virtual methods + virtual std::map<std::string, PythonModuleInitialization> getModules() const = 0; + virtual const char* getInitializationScript() const = 0; + virtual void onInitialization(); + // actually a PyObject* but don't wanna draw Python.h include into the header + virtual void onPythonModuleInitialization(void* moduleDict); + virtual void onDeinitialization(); + + virtual void onSuccess() {} + virtual void onAbort() {} + virtual void onError(const std::string& exceptionType = "", + const std::string& exceptionValue = "", + const std::string& exceptionTraceback = ""); + + std::string m_sourceFile; + CCriticalSection m_critical; + +private: + void initializeModules(const std::map<std::string, PythonModuleInitialization>& modules); + bool initializeModule(PythonModuleInitialization module); + void getAddonModuleDeps(const ADDON::AddonPtr& addon, std::set<std::string>& paths); + bool execute(const std::string& script, std::vector<std::wstring>& arguments); + FILE* PyFile_AsFileWithMode(PyObject* py_file, const char* mode); + + PyThreadState* m_threadState; + bool m_stop; + CEvent m_stoppedEvent; + + XBMCAddon::AddonClass::Ref<XBMCAddon::Python::PythonLanguageHook> m_languageHook; + bool m_systemExitThrown = false; + + static CCriticalSection s_critical; +}; diff --git a/xbmc/interfaces/python/PythonSwig.cpp.template b/xbmc/interfaces/python/PythonSwig.cpp.template new file mode 100644 index 0000000..24756ea --- /dev/null +++ b/xbmc/interfaces/python/PythonSwig.cpp.template @@ -0,0 +1,942 @@ +<% +/* + * 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. + */ +%> +<% +import Helper +import SwigTypeParser +import PythonTools + +import groovy.xml.XmlUtil +import groovy.text.SimpleTemplateEngine +import java.util.regex.Pattern + +/** + * All of the method nodes and all of the class nodes are used several + * times over, so they are pulled out once here. + */ + +// --------------------------------------------------------- +// initialize the SwigTypeParser with the module's typetables +module.findAll( { it.name() == 'typetab' } ).each { SwigTypeParser.appendTypeTable(it) } +// --------------------------------------------------------- + +// --------------------------------------------------------- +// Flatten out all of the method/function nodes, whether inside +// classes or not, into 'methods' +List methods = module.depthFirst().findAll { it.name() == 'function' || it.name() == 'constructor' || it.name() == 'destructor' } +// --------------------------------------------------------- + +// --------------------------------------------------------- +// Flatten out all of the class nodes into 'classes' +List classes = module.depthFirst().findAll { it.name() == 'class' } +// --------------------------------------------------------- + +// --------------------------------------------------------- +// Initialize the Helper with the type conversions +Helper.setup(this,classes, + /** + * This is meant to contain mini-templates for converting the return type + * of the native call to be returned to the python caller. + */ + [ 'void' : 'Py_INCREF(Py_None);\n ${result} = Py_None;', + 'long': '${result} = PyLong_FromLong(${api});', + 'unsigned long': '${result} = PyLong_FromLong(${api});', + 'bool': '${result} = ${api} ? Py_True : Py_False; Py_INCREF(${result});', + 'long long': '${result} = Py_BuildValue("L", ${api});', + 'int': '${result} = Py_BuildValue("i", ${api});', + 'unsigned int': '${result} = Py_BuildValue("I", ${api});', + 'double': '${result} = PyFloat_FromDouble(${api});', + 'float': '${result} = Py_BuildValue("f", static_cast<double>(${api}));', + 'std::string' : new File('typemaps/python.string.outtm'), + 'p.q(const).char' : '${result} = PyUnicode_FromString(${api});', + (Pattern.compile('''(p.){0,1}XbmcCommons::Buffer''')) : new File('typemaps/python.buffer.outtm'), + (Pattern.compile('''std::shared_ptr<\\(.*\\)>''')) : new File('typemaps/python.smart_ptr.outtm'), + (Pattern.compile('''std::unique_ptr<\\(.*\\)>''')) : new File('typemaps/python.smart_ptr.outtm'), + (Pattern.compile('''(p.){0,1}std::vector<\\(.*\\)>''')) : new File('typemaps/python.vector.outtm'), + (Pattern.compile('''(p.){0,1}Tuple<\\(.*\\)>''')) : new File('typemaps/python.Tuple.outtm'), + (Pattern.compile('''(p.){0,1}Alternative<\\(.*\\)>''')) : new File('typemaps/python.Alternative.outtm') + ], '${result} = makePythonInstance(${api},true);', + /** + * This is meant to contain mini-templates for converting the parameter types + * of the native call to be converted from the python types provided by the caller. + * + * Note: if the type can be handled by PythonTools.ltypeToFormatChar then it wont + * appear here as it gets converted directly within the PyArg_ParseTupleAndKeywords + * call. + */ + [ + 'std::string' : 'if (${slarg}) PyXBMCGetUnicodeString(${api},${slarg},false,"${api}","${method.@name}");', + (Pattern.compile('''(p.){0,1}std::vector<\\(.*\\)>''')) : new File('typemaps/python.vector.intm'), + (Pattern.compile('''(p.){0,1}Tuple(3){0,1}<\\(.*\\)>''')) : new File('typemaps/python.Tuple.intm'), + (Pattern.compile('''(p.){0,1}Alternative<\\(.*\\)>''')) : new File('typemaps/python.Alternative.intm'), + (Pattern.compile('''(r.){0,1}XbmcCommons::Buffer''')) : new File('typemaps/python.buffer.intm'), + (Pattern.compile('''(p.){0,1}std::map<\\(.*\\)>''')) : new File('typemaps/python.map.intm'), + (Pattern.compile('''(r.){0,1}XBMCAddon::Dictionary<\\(.*\\)>''')) : new File('typemaps/python.dict.intm'), + (Pattern.compile('''p.void''')) : '${api} = (void*)${slarg};', + 'bool' : '${api} = (PyLong_AsLong(${slarg}) == 0L ? false : true);', + 'long' : '${api} = PyLong_AsLong(${slarg});', + 'unsigned long' : '${api} = PyLong_AsUnsignedLong(${slarg});', + 'long long' : '${api} = PyLong_AsLongLong(${slarg});', + 'unsigned long long' : '${api} = PyLong_AsUnsignedLongLong(${slarg});', + 'int' : '${api} = (int)PyLong_AsLong(${slarg});', + 'double' : '${api} = PyFloat_AsDouble(${slarg});', + 'float' : '${api} = (float)PyFloat_AsDouble(${slarg});', + 'XBMCAddon::StringOrInt' : 'if (${slarg}) PyXBMCGetUnicodeString(${api},${slarg},PyLong_Check(${slarg}) || PyFloat_Check(${slarg}),"${api}","${method.@name}");' + ], '${api} = (${swigTypeParser.SwigType_str(ltype)})retrieveApiInstance(${slarg},"${ltype}","${helper.findNamespace(method)}","${helper.callingName(method)}");') +// --------------------------------------------------------- + +/*******************************************************************************/ +/** + * The doMethod will actually write out the CPython method call for + * the method/function represented by the provided Node ('method'). + */ +void doMethod(Node method, MethodType methodType) +{ + boolean isOperator = method.@name.startsWith("operator ") + boolean doAsMappingIndex = false + boolean doAsCallable = false + + if (isOperator) + { + if("[]" == method.@name.substring(9)) + doAsMappingIndex = true + else if("()" == method.@name.substring(9)) + doAsCallable = true + else + return; + } + + boolean constructor = methodType == MethodType.constructor + + // if we're a constructor, but we're private, then we're outta here + if (constructor && method.@access != null && method.@access != "public") + return + + boolean destructor = methodType == MethodType.destructor + List params = method?.parm + int numParams = params?.size() + String clazz = Helper.findFullClassName(method) + String returns = constructor ? 'p.' + clazz : (destructor ? 'void' : Helper.getReturnSwigType(method)) + Node classnode = Helper.findClassNode(method) + String classNameAsVariable = clazz == null ? null : PythonTools.getClassNameAsVariable(classnode) + boolean useKeywordParsing = !('true' == classnode?.@feature_python_nokwds || 'true' == method?.@feature_python_nokwds) + + // do the docs + if (!constructor && !destructor) + { + if (Helper.hasDoc(method)) + { +%> + PyDoc_STRVAR(${PythonTools.getPyMethodName(method,methodType)}__doc__, + ${PythonTools.makeDocString(method.doc[0])}); +<% } + } +%> + static <% if(methodType == MethodType.destructor) { %>void<% } else { %>PyObject*<% } %> ${module.@name}_${PythonTools.getPyMethodName(method,methodType)} (<%= ((clazz == null) ? "PyObject" : + (constructor ? "PyTypeObject" : 'PyHolder')) %>* ${constructor ? 'pytype' : 'self'} <% + if (doAsMappingIndex) { %>, PyObject* py${params[0].@name}<% } + else if (methodType != MethodType.destructor) { %> , PyObject *args, PyObject *kwds <%} %> ) + { + XBMC_TRACE; +<% if (numParams > 0) + { + if (useKeywordParsing && !doAsMappingIndex) + { %> + static const char *keywords[] = {<% + params.each { %> + "${it.@name}",<% } %> + NULL}; +<% } + params.each { +%> + ${SwigTypeParser.SwigType_str(SwigTypeParser.convertTypeToLTypeForParam(it.@type))} ${it.@name} ${it.@value != null ? ' = ' + it.@value : SwigTypeParser.SwigType_ispointer(it.@type) ? ' = nullptr' : ''};<% + if (!PythonTools.parameterCanBeUsedDirectly(it) && !doAsMappingIndex) + { %> + PyObject* py${it.@name} = NULL;<% + } + } + if (!doAsMappingIndex) + { %> + if (!${useKeywordParsing ? 'PyArg_ParseTupleAndKeywords' : 'PyArg_ParseTuple'}( + args, + <% if (useKeywordParsing) { %>kwds,<% } %> + "<%= PythonTools.makeFormatStringFromParameters(method) %>", + <% if (useKeywordParsing) { %>const_cast<char**>(keywords),<% } %><% params.eachWithIndex { param,i -> %> + &${PythonTools.parameterCanBeUsedDirectly(param) ? '' : 'py'}${param.@name}${i < params.size() - 1 ? "," : ""}<% } %> + )) + { + return NULL; + } + +<% } + } + // now actually invoke the method + if (returns != "void") { %> ${SwigTypeParser.SwigType_str(returns)} apiResult;<% } +%> + try + { +<% + // now do the input conversion if any are necessary + params.findAll({ !PythonTools.parameterCanBeUsedDirectly(it) || doAsMappingIndex }).each { %> ${Helper.getInConversion(it.@type, it.@name, 'py' + it.@name, method)} <% println() } +%> +<% + // check to see if this method is a call to a virtual function on a director class. + boolean isDirectorCall = Helper.isDirector(method) + if (isDirectorCall) + { +%> // This is a director call coming from python so it explicitly calls the base class method. +<% + } + // now do the method call itself + if (!destructor) { + if (constructor || !clazz) { %> XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());<% println() } +%> <% + if (returns != "void") { %>apiResult = <% } + if (clazz && !constructor) { + %>((${clazz}*)retrieveApiInstance((PyObject*)self,&Ty${classNameAsVariable}_Type,"${Helper.callingName(method)}","${clazz}"))-> <% + } + if (constructor && classnode.@feature_director) { + %>(&(Ty${classNameAsVariable}_Type.pythonType) != pytype) ? new ${classNameAsVariable}_Director(<% params.eachWithIndex { param, i -> %> ${param.@name}${i < params.size() - 1 ? "," : ""} <% } %>) : <% } + + // Here is the actual call ... if this is a Director we need to do an upCall (from Python) + if (isDirectorCall){ %>${clazz}::<% } + %>${Helper.callingName(method)}( <% params.eachWithIndex { param, i -> %> ${param.@name}${i < params.size() - 1 ? "," : ""} <% } %> ); +<% + if (constructor) { %> prepareForReturn(apiResult);<% } + } // close the 'if method is not a destructor' + else { // it is a destructor +%> + ${clazz}* theObj = (${clazz}*)retrieveApiInstance((PyObject*)self,&Ty${classNameAsVariable}_Type,"~${Helper.callingName(method)}","${clazz}"); + cleanForDealloc(theObj); +<% + } +%> + } + catch (const XBMCAddon::WrongTypeException& e) + { + CLog::Log(LOGERROR,"EXCEPTION: {}",e.GetExMessage()); + PyErr_SetString(PyExc_TypeError, e.GetExMessage()); <% + if (!destructor) { %> + return NULL; <% + } %> + } + catch (const XbmcCommons::Exception& e) + { + CLog::Log(LOGERROR,"EXCEPTION: {}",e.GetExMessage()); + PyErr_SetString(PyExc_RuntimeError, e.GetExMessage()); <% + if (!destructor) { %> + return NULL; <% + } %> + } + catch (...) + { + CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"${Helper.callingName(method)}\""); + PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"${Helper.callingName(method)}\""); <% + if (!destructor) { %> + return NULL; <% + } %> + } +<% + if (!destructor) { %> + PyObject* result = Py_None; + + // transform the result +<% + if (constructor) { + %> result = makePythonInstance(apiResult,pytype,false);<% + } + else { +%> ${Helper.getOutConversion(returns,'result',method)}<% + } + if (constructor && method.@feature_director) { %> + if (&(Ty${classNameAsVariable}_Type.pythonType) != pytype) + ((${classNameAsVariable}_Director*)apiResult)->setPyObjectForDirector(result);<% + } + %> + + return result; <% } + else { %> + (((PyObject*)(self))->ob_type)->tp_free((PyObject*)self); + <% + } + %> + } <% +} +/*******************************************************************************/ + +/** + * This method writes out the instance of a TypeInfo (which includes + * The PyTypeObject as a member) for the class node provided. + * + * If classNameAsVariable is not null then the class name as a + * variable will be appended to it. + */ +void doClassTypeInfo(Node clazz, List classNameAsVariables = null) +{ + String classNameAsVariable = PythonTools.getClassNameAsVariable(clazz) + String fullClassName = Helper.findFullClassName(clazz) + classNameAsVariables?.add(classNameAsVariable) +%> + //========================================================================= + // These variables will hold the Python Type information for ${fullClassName} + TypeInfo Ty${classNameAsVariable}_Type(typeid(${fullClassName}));<% +%> + //========================================================================= +<% +} + +/** + * This method will take the name of an API class from another module and + * create an external reference to its TypeInfo instance. + */ +void doExternClassTypeInfo(String knownType) +{ + String classNameAsVariable = knownType.replaceAll('::','_') +%> + //========================================================================= + // These variables define the type ${knownType} from another module + extern TypeInfo Ty${classNameAsVariable}_Type; + //========================================================================= +<% +} + +/*******************************************************************************/ +/** + * This method takes the class node and outputs all of the python meta-data + * and class oddities (like comparators, as_mapping, etc.). These include: + * + * 1) comparator *_cmp python method as long as there's an operator==, an + * operator>, AND an operator<. + * 2) it will create a python "as_mapping" method as long as there's both + * an operator[], AND a .size() method on the class. + * 3) it will handle the explicitly defined rich compare (_rcmp) if the + * feature is included in the .i file using %feature("python:rcmp") + * 4) The array of PyMethodDefs for the class definition + * 5) It will handle public fields as if the were python properties by: + * a) Creating a get/set_member if there are read/write properties. + * b) Creating only a get if there are only read-only properties. + * 6) It will write the init[Classname] method for the class which will + * initialize the TypeInfo and PyTypeObject structs. + * + * If initTypeCalls is not null then the method name for the generated init + * method (see #6 above) will be appended to it. + */ +void doClassMethodInfo(Node clazz, List initTypeCalls) +{ + String classNameAsVariable = PythonTools.getClassNameAsVariable(clazz) + String fullClassName = Helper.findFullClassName(clazz) + String initTypeCall = "initPy${classNameAsVariable}_Type" + initTypeCalls?.add(initTypeCall) + + // see if we have any valid (or invalid) operators + boolean doComparator = false + boolean doAsMapping = false + boolean hasEquivalenceOp = false + boolean hasLtOp = false + boolean hasGtOp = false + Node indexOp = null + Node callableOp = null + Node sizeNode = null + + List normalMethods = clazz.function.findAll { !it.@name.startsWith("operator ") } + List operators = clazz.function.findAll { it.@name.startsWith("operator ") } + List properties = clazz.variable.findAll { it.@access != null && it.@access == "public" } + List properties_set = properties.findAll { it.@feature_immutable == null || it.@feature_immutable == 0 } + + operators.each { + // we have an operator. The only one we can handle is == + if (it.@name.substring(9).startsWith("==")) + hasEquivalenceOp = true + else if (it.@name.substring(9) == "<") + hasLtOp = true + else if (it.@name.substring(9) == ">") + hasGtOp = true + else if (it.@name.substring(9) == "[]") + indexOp = it + else if (it.@name.substring(9) == "()") + callableOp = it + else + System.err.println ("Warning: class ${fullClassName} has an operator \"${it.@name}\" that is being ignored."); + } + + if (hasGtOp || hasLtOp || hasEquivalenceOp) + { + if (!(hasLtOp && hasGtOp && hasEquivalenceOp)) + System.err.println ("Warning: class ${fullClassName} has an inconsistent operator set. To get a comparator you must implement all 3 operators >,<,==.") + else + doComparator = true + } + + if (indexOp) + { + sizeNode = clazz.function.find { it.@name == "size" } + if (sizeNode) + doAsMapping = true + else + System.err.println ("Warning: class ${fullClassName} has an inconsistent operator set. To get a as_mapping you must implement 'size' as well as operator[]") + } + + if (doAsMapping) + { +%> + static Py_ssize_t ${module.@name}_${classNameAsVariable}_size_(PyObject* self) + { + return (Py_ssize_t)((${fullClassName}*)retrieveApiInstance(self,&Ty${classNameAsVariable}_Type,"${Helper.callingName(indexOp)}","${fullClassName}"))-> size(); + } + + //========================================================================= + // tp_as_mapping struct for ${fullClassName} + //========================================================================= + PyMappingMethods ${module.@name}_${classNameAsVariable}_as_mapping = { + ${module.@name}_${classNameAsVariable}_size_, /* inquiry mp_length; __len__ */ + (PyCFunction)${module.@name}_${PythonTools.getPyMethodName(indexOp,MethodType.method)}, /* binaryfunc mp_subscript __getitem__ */ + 0, /* objargproc mp_ass_subscript; __setitem__ */ + }; +<% + } + + if (clazz.@feature_python_rcmp) + { %> + static PyObject* ${module.@name}_${classNameAsVariable}_rcmp(PyObject* obj1, PyObject *obj2, int method) + ${Helper.unescape(clazz.@feature_python_rcmp)} +<% + } +%> + //========================================================================= + // This section contains the initialization for the + // Python extension for the Api class ${fullClassName} + //========================================================================= + // All of the methods on this class + static PyMethodDef ${classNameAsVariable}_methods[] = { <% + normalMethods.each { %> + {"${it.@sym_name}", (PyCFunction)${module.@name}_${PythonTools.getPyMethodName(it,MethodType.method)}, METH_VARARGS|METH_KEYWORDS, ${Helper.hasDoc(it) ? PythonTools.getPyMethodName(it,MethodType.method) + '__doc__' : 'NULL'} }, <% } + + // now do all of the explicit feature:python:method's that may be in this class + List tmpl = [] + tmpl.addAll(clazz.attributes().keySet()) + List newMethodKeys = tmpl.findAll { it.startsWith('feature_python_method_') } + newMethodKeys.each { key -> + String featureEntry = clazz.attribute(key) + String methodName = key.substring('feature_python_method_'.length()) %> + {"${methodName}", (PyCFunction)${module.@name}_${PythonTools.getClassNameAsVariable(clazz)}_${methodName}, METH_VARARGS|METH_KEYWORDS, NULL}, +<% + } +%> + {NULL, NULL, 0, NULL} + }; + +<% + if (properties.size() > 0) { +%> static PyObject* ${classNameAsVariable}_getMember(PyHolder *self, void *name) + { + if (self == NULL) + return NULL; +<% + String clazzName = Helper.findFullClassName(properties[0]) +%> + try + { + ${clazzName}* theObj = (${clazzName}*)retrieveApiInstance((PyObject*)self, &Ty${classNameAsVariable}_Type, "${classNameAsVariable}_getMember()", "${clazzName}"); + + PyObject* result = NULL; + <% + properties.each { + String returns = Helper.getPropertyReturnSwigType(it); +%> if (strcmp((char*)name, "${it.@sym_name}") == 0) + { + ${SwigTypeParser.SwigType_lstr(returns)} apiResult = theObj->${it.@sym_name}; + ${Helper.getOutConversion(returns, 'result', it)} + } + else<% + } %> + { + Py_INCREF(Py_None); + return Py_None; + } + + return result; + } + catch (const XBMCAddon::WrongTypeException& e) + { + CLog::Log(LOGERROR,"EXCEPTION: {}",e.GetExMessage()); + PyErr_SetString(PyExc_TypeError, e.GetExMessage()); + return NULL; + } + catch (const XbmcCommons::Exception& e) + { + CLog::Log(LOGERROR,"EXCEPTION: {}",e.GetExMessage()); + PyErr_SetString(PyExc_RuntimeError, e.GetExMessage()); + return NULL; + } + catch (...) + { + CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"${classNameAsVariable}_getMember()\""); + PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"${classNameAsVariable}_getMember()\""); + return NULL; + } + + return NULL; + } + +<% + if (properties_set.size() > 0) { +%> int ${classNameAsVariable}_setMember(PyHolder *self, PyObject *value, void *name) + { + if (self == NULL) + return -1; + + ${clazzName}* theObj = NULL; + try + { + theObj = (${clazzName}*)retrieveApiInstance((PyObject*)self, &Ty${classNameAsVariable}_Type, "${classNameAsVariable}_getMember()", "${clazzName}"); + } + catch (const XBMCAddon::WrongTypeException& e) + { + CLog::Log(LOGERROR,"EXCEPTION: {}",e.GetExMessage()); + PyErr_SetString(PyExc_TypeError, e.GetExMessage()); + return -1; + } + catch (const XbmcCommons::Exception& e) + { + CLog::Log(LOGERROR,"EXCEPTION: {}",e.GetExMessage()); + PyErr_SetString(PyExc_RuntimeError, e.GetExMessage()); + return -1; + } + catch (...) + { + CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"${classNameAsVariable}_getMember()\""); + PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"${classNameAsVariable}_getMember()\""); + return -1; + } + +<% + properties_set.each { + String returns = Helper.getPropertyReturnSwigType(it); +%> if (strcmp((char*)name, "${it.@sym_name}") == 0) + { + ${SwigTypeParser.SwigType_lstr(returns)} tmp; + ${Helper.getInConversion(returns, 'tmp', 'value', it)} + if (PyErr_Occurred()) + throw PythonBindings::PythonToCppException(); + + theObj->${it.@sym_name} = tmp; + } + else<% + } %> + return -1; + + return 0; + } <% + } +%> + + // All of the methods on this class + static PyGetSetDef ${classNameAsVariable}_getsets[] = { <% + properties.each { %> + {(char*)"${it.@sym_name}", (getter)${classNameAsVariable}_getMember, ${(it.@feature_immutable == null || it.@feature_immutable == 0) ? '(setter)' + classNameAsVariable + '_setMember' : 'NULL'}, (char*)${Helper.hasDoc(it) ? PythonTools.makeDocString(it.doc[0]) : 'NULL'}, (char*)"${it.@sym_name}" }, <% } +%> + {NULL} + }; +<% + } + + if ((clazz.@feature_iterator && clazz.@feature_iterator != '') || + (clazz.@feature_iterable && clazz.@feature_iterable != '')) { %> + static PyObject* ${module.@name}_${classNameAsVariable}_iter(PyObject* self) + { <% + if (clazz.@feature_iterator) { %> + return self; <% + } + else { %> + PyObject* result = NULL; + try + { + ${clazz.@feature_iterable}* apiResult = ((${fullClassName}*)retrieveApiInstance(self,&Ty${classNameAsVariable}_Type,"${module.@name}_${classNameAsVariable}_iternext","${fullClassName}"))->begin(); + + ${Helper.getOutConversion('p.' + clazz.@feature_iterable,'result',clazz)} + } + catch (const XBMCAddon::WrongTypeException& e) + { + CLog::Log(LOGERROR,"EXCEPTION: {}",e.GetExMessage()); + PyErr_SetString(PyExc_TypeError, e.GetExMessage()); + return NULL; + } + catch (const XbmcCommons::Exception& e) + { + CLog::Log(LOGERROR,"EXCEPTION: {}",e.GetExMessage()); + PyErr_SetString(PyExc_RuntimeError, e.GetExMessage()); + return NULL; + } + catch (...) + { + CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"${module.@name}_${classNameAsVariable}_iternext\""); + PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"${module.@name}_${classNameAsVariable}_iternext\""); + return NULL; + } + + return result; <% + } %> + } +<% + + if (clazz.@feature_iterator) { %> + static PyObject* ${module.@name}_${classNameAsVariable}_iternext(PyObject* self) + { + PyObject* result = NULL; + try + { + ${fullClassName}* iter = (${fullClassName}*)retrieveApiInstance(self,&Ty${classNameAsVariable}_Type,"${module.@name}_${classNameAsVariable}_iternext","${fullClassName}"); + + // check if we have reached the end + if (!iter->end()) + { + ++(*iter); + + ${clazz.@feature_iterator} apiResult = **iter; + ${Helper.getOutConversion(clazz.@feature_iterator,'result',clazz)} + } + } + catch (const XBMCAddon::WrongTypeException& e) + { + CLog::Log(LOGERROR,"EXCEPTION: {}",e.GetExMessage()); + PyErr_SetString(PyExc_TypeError, e.GetExMessage()); + return NULL; + } + catch (const XbmcCommons::Exception& e) + { + CLog::Log(LOGERROR,"EXCEPTION: {}",e.GetExMessage()); + PyErr_SetString(PyExc_RuntimeError, e.GetExMessage()); + return NULL; + } + catch (...) + { + CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"${module.@name}_${classNameAsVariable}_iternext\""); + PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"${module.@name}_${classNameAsVariable}_iternext\""); + return NULL; + } + + return result; + } +<% + } + } +%> + + // This method initializes the above mentioned Python Type structure + static void ${initTypeCall}() + { +<% + if (Helper.hasDoc(clazz)) + { +%> + PyDoc_STRVAR(${classNameAsVariable}__doc__, + ${PythonTools.makeDocString(clazz.doc[0])} + ); +<% } %> + + PyTypeObject& pythonType = Ty${classNameAsVariable}_Type.pythonType; + pythonType.tp_name = "${module.@name}.${clazz.@sym_name}"; + pythonType.tp_basicsize = sizeof(PyHolder); + pythonType.tp_dealloc = (destructor)${module.@name}_${classNameAsVariable}_Dealloc; <% + + if (clazz.@feature_python_rcmp) { %> + pythonType.tp_richcompare=(richcmpfunc)${module.@name}_${classNameAsVariable}_rcmp;<% + } %> + + pythonType.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE; + + pythonType.tp_doc = ${Helper.hasDoc(clazz) ? (classNameAsVariable + '__doc__') : 'NULL' }; + pythonType.tp_methods = ${classNameAsVariable}_methods; <% + if (properties.size() > 0) { %> + pythonType.tp_getset = ${classNameAsVariable}_getsets; +<% + } + if (callableOp) { %> + pythonType.tp_call = (ternaryfunc)${module.@name}_${PythonTools.getPyMethodName(callableOp,MethodType.method)}; +<% + } + if (doAsMapping) { %> + pythonType.tp_as_mapping = &${module.@name}_${classNameAsVariable}_as_mapping; +<% + } + + if (clazz.@feature_iterator) { %> + pythonType.tp_iter = (getiterfunc)${module.@name}_${classNameAsVariable}_iter; + pythonType.tp_iternext = (iternextfunc)${module.@name}_${classNameAsVariable}_iternext; +<% + } + else if (clazz.@feature_iterable && clazz.@feature_iterable != '') { %> + pythonType.tp_iter = (getiterfunc)${module.@name}_${classNameAsVariable}_iter; +<% + } + + Node baseclass = PythonTools.findValidBaseClass(clazz, module) +%> + + pythonType.tp_base = ${baseclass ? ('&(Ty' + PythonTools.getClassNameAsVariable(baseclass) + '_Type.pythonType)') : "NULL"}; + pythonType.tp_new = <% !Helper.hasDefinedConstructor(clazz) || Helper.hasHiddenConstructor(clazz) ? print('NULL') : print("${module.@name}_${classNameAsVariable}_New") %>; + pythonType.tp_init = dummy_tp_init; + + Ty${classNameAsVariable}_Type.swigType="p.${fullClassName}";<% + if (baseclass) { %> + Ty${classNameAsVariable}_Type.parentType=&Ty${PythonTools.getClassNameAsVariable(baseclass)}_Type; +<%} + + if (!Helper.hasHiddenConstructor(clazz)) { %> + registerAddonClassTypeInformation(&Ty${classNameAsVariable}_Type); +<%} %> + } + //========================================================================= +<% +} +/*******************************************************************************/ + + +List getAllVirtualMethods(Node clazz) +{ + List ret = [] + ret.addAll(clazz.findAll({ it.name() == 'function' && it.@storage && it.@storage == 'virtual' })) + if (clazz.baselist) { + if (clazz.baselist[0].base) clazz.baselist[0].base.each { + Node baseclassnode = Helper.findClassNodeByName(module,it.@name,clazz) + if (baseclassnode && baseclassnode.@feature_director) ret.addAll(getAllVirtualMethods(baseclassnode)) + } + } + return ret; +} + +%> +/* + * 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. + */ + +// ************************************************************************ +// This file was generated by xbmc compile process. DO NOT EDIT!! +// It was created by running the code generator on the spec file for +// the module "${module.@name}" on the template file PythonSwig.template.cpp +// ************************************************************************ + +<% +Helper.getInsertNodes(module, 'begin').each { %>${Helper.unescape(it)}<% } +%> + +#include <Python.h> +#include <string> +#include "CompileInfo.h" +#include "interfaces/python/LanguageHook.h" +#include "interfaces/python/swig.h" +#include "interfaces/python/PyContext.h" + +<% +Helper.getInsertNodes(module, 'header').each { %>${Helper.unescape(it)}<% } +%> + +namespace PythonBindings +{ +<% + // initTypeCalls is the + List initTypeCalls = [] + List classNameAsVariables = [] + + classes.each { clazz -> doClassTypeInfo(clazz, classNameAsVariables) } + + // make sure known api types are declared as externs + + // first, find all of the declared known api types + Set<String> knownApiTypes = new HashSet<String>() + module.depthFirst().each + { + String attr = it.attribute('feature_knownapitypes') + if (attr != null) + { + attr.trim().split(',').each { knownApiTypes.add(it) } + } + } + + // now declare an extern for each one + knownApiTypes.each { doExternClassTypeInfo(it) } + +%> + +<% +//========================================================================= +// Do the directors. For every class that can be extended in python, we +// need to create a Director instance with bridging calls. This chunk of +// code will generate those classes. + classes.findAll({ it.@feature_director != null }).each { clazz -> + // find the constructor for this class + constructor = clazz.constructor[0] +%> + //========================================================================= + // This class is the Director for ${Helper.findFullClassName(clazz)}. + // It provides the "reverse bridge" from C++ to Python to support + // cross-language polymorphism. + //========================================================================= + class ${PythonTools.getClassNameAsVariable(clazz)}_Director : public Director, public ${clazz.@name} + { + public: +<% + if (constructor) + {%> + inline ${PythonTools.getClassNameAsVariable(clazz)}_Director(<% + List params = constructor?.parm + params.eachWithIndex { param, i -> %>${SwigTypeParser.SwigType_str(param.@type)} ${param.@name}${i < params.size() - 1 ? "," : ""} <% } + %>) : ${Helper.findFullClassName(constructor)}(<% + params.eachWithIndex { param, i -> %> ${param.@name}${i < params.size() - 1 ? "," : ""} <% } %>) { } <% + } +%> +<% + getAllVirtualMethods(clazz).each + { %> + virtual ${SwigTypeParser.SwigType_str(Helper.getReturnSwigType(it))} ${Helper.callingName(it)}( <% + List params = it?.parm + String paramFormatStr = '' + params.each { paramFormatStr += 'O' } + params.eachWithIndex { param, i -> %> ${SwigTypeParser.SwigType_str(param.@type)} ${param.@name}${i < params.size() - 1 ? "," : ""} <% } + %> ) + { <% + params.each + { param -> + %> + PyObject* py${param.@name} = NULL; + ${Helper.getOutConversion(param.@type,'result',it,['result' : 'py' + param.@name, 'api' : param.@name])}<% + } +%> + XBMCAddon::Python::PyContext pyContext; + PyObject_CallMethod(self,"${Helper.callingName(it)}","(${paramFormatStr})"<% + params.each { + %>, py${it.@name} <% + } + %>); + if (PyErr_Occurred()) + throw PythonBindings::PythonToCppException(); + } +<% } + +%> + }; +<% + } +//========================================================================= + + // types used as method parameter or return values need to be declared + // as extern if they are unknown types. + methods.each { if (it.name() != 'destructor') { doMethod(it, (it.name() == 'constructor' ? MethodType.constructor : MethodType.method)); println(); } } + classes.each { clazz -> doMethod(clazz, MethodType.destructor) } + + // now find any methods that have been added explicitly + classes.each { node -> + List tmpl = [] + tmpl.addAll(node.attributes().keySet()) + List newMethodKeys = tmpl.findAll { it.startsWith('feature_python_method_') } + newMethodKeys.each { key -> + String featureEntry = node.attribute(key) + String methodName = key.substring('feature_python_method_'.length()) %> + static PyObject* ${module.@name}_${PythonTools.getClassNameAsVariable(node)}_${methodName}(PyObject* self, PyObject *args, PyObject *kwds) + ${Helper.unescape(featureEntry)} +<% + } + } + + classes.each { clazz -> doClassMethodInfo(clazz, initTypeCalls) } + +%> + + static PyMethodDef ${module.@name}_methods[] = { <% + module.depthFirst().findAll({ it.name() == 'function' && Helper.parents(it, { Node lnode -> lnode.name() == 'class'}).size() == 0 }).each { %> + {"${it.@sym_name}", (PyCFunction)${module.@name}_${PythonTools.getPyMethodName(it,MethodType.method)}, METH_VARARGS|METH_KEYWORDS, ${Helper.hasDoc(it) ? PythonTools.getPyMethodName(it,MethodType.method) + '__doc__' : 'NULL'} }, <% } +%> + {NULL, NULL, 0, NULL} + }; + + // This is the call that will call all of the other initializes + // for all of the classes in this module + static void initTypes() + { + static bool typesAlreadyInitialized = false; + if (!typesAlreadyInitialized) + { + typesAlreadyInitialized = true; +<% + initTypeCalls.each { %> + ${it}();<% + } + + classNameAsVariables.each { %> + if (PyType_Ready(&(Ty${it}_Type.pythonType)) < 0) + return;<% + }%> + } + } + + static struct PyModuleDef createModule + { + PyModuleDef_HEAD_INIT, + "${module.@name}", + "", + -1, + ${module.@name}_methods, + nullptr, + nullptr, + nullptr, + nullptr, + }; + + PyObject *PyInit_Module_${module.@name}() + { + initTypes(); + + // init general ${module.@name} modules + PyObject* module; + +<% classNameAsVariables.each { %> + Py_INCREF(&(Ty${it}_Type.pythonType));<% + }%> + + module = PyModule_Create(&createModule); + if (module == NULL) return NULL; + +<% classes.each { clazz -> %> + PyModule_AddObject(module, "${clazz.@sym_name}", (PyObject*)(&(Ty${PythonTools.getClassNameAsVariable(clazz)}_Type.pythonType)));<% + }%> + + // constants + PyModule_AddStringConstant(module, "__author__", "Team Kodi <http://kodi.tv>"); + PyModule_AddStringConstant(module, "__date__", CCompileInfo::GetBuildDate().c_str()); + PyModule_AddStringConstant(module, "__version__", "3.0.1"); + PyModule_AddStringConstant(module, "__credits__", "Team Kodi"); + PyModule_AddStringConstant(module, "__platform__", "ALL"); + + // need to handle constants + // #define constants +<% module.depthFirst().findAll( { it.name() == 'constant'} ).each { + String pyCall = + (it.@type == 'int' || it.@type == 'long' || it.@type == 'unsigned int' || it.@type == 'unsigned long' || it.@type == 'bool') ? + 'PyModule_AddIntConstant' : 'PyModule_AddStringConstant' %> + ${pyCall}(module,"${it.@sym_name}",${it.@value}); <% + } %> + // constexpr constants +<% module.depthFirst().findAll( { it.name() == 'variable' && it.@storage && it.@storage == "constexpr" && !it.@error } ).each { + String pyCall = + ( it.@type == 'q(const).int' || it.@type == 'q(const).long' || it.@type == 'q(const).unsigned int' || it.@type == 'q(const).unsigned long' || it.@type == 'q(const).bool' ) ? + 'PyModule_AddIntConstant' : 'PyModule_AddStringConstant' %> + ${pyCall}(module,"${it.@sym_name}",${it.@value}); <% + } %> + return module; + } + +} // end PythonBindings namespace for python type definitions + +<% +Helper.getInsertNodes(module, 'footer').each { %>${Helper.unescape(it)}<% } +%> diff --git a/xbmc/interfaces/python/PythonTools.groovy b/xbmc/interfaces/python/PythonTools.groovy new file mode 100644 index 0000000..e41db6c --- /dev/null +++ b/xbmc/interfaces/python/PythonTools.groovy @@ -0,0 +1,140 @@ +/* + * 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. + */ + +import Helper +import SwigTypeParser + +public class PythonTools +{ + /** + * This array defines a mapping of the api spec type to the python parse format character. + * By default, if a lookup here results in 'null' then the format char is 'O' + */ + private static Map ltypeToFormatChar = [ + 'p.char':"s", bool:"b", + int:"i", 'unsigned int' : 'I', + long:"l", 'unsigned long' : 'k', + 'double':"d", 'float':"f", + 'long long' : "L" + ] + + /** + * if the parameter can be directly read from python then its type should be in the ltypeToFormatChar + * otherwise we need an intermediate pyobject + */ + public static boolean parameterCanBeUsedDirectly(Node param) { return ltypeToFormatChar[SwigTypeParser.convertTypeToLTypeForParam(param.@type)] != null } + + /** + * This method will take the parameter list from the method node passed + * and will convert it to a Python argument string for PyArg_ParseTupleAndKeywords + */ + public static String makeFormatStringFromParameters(Node method) + { + if (!method) + return '' + List params = method.parm + String format = "" + boolean previousDefaulted = false + params.eachWithIndex { param, i -> + String defaultValue = param.@value + String paramtype = SwigTypeParser.convertTypeToLTypeForParam(param.@type) + String curFormat = ltypeToFormatChar[paramtype]; + if (curFormat == null) // then we will assume it's an object + curFormat = "O"; + + if (defaultValue != null && !previousDefaulted) + { + format +="|" + previousDefaulted = true + } + format += curFormat + } + return format; + } + + /** + * This method gets the FULL class name as a variable including the + * namespace. If converts all of the '::' references to '_' so + * that the result can be used in part, or in whole, as a variable name + */ + public static String getClassNameAsVariable(Node clazz) { return Helper.findFullClassName(clazz).replaceAll('::','_') } + + public static String getPyMethodName(Node method, MethodType methodType) + { + String clazz = Helper.findFullClassName(method)?.replaceAll('::','_') + + // if we're not in a class then this must be a method node + assert (clazz != null || methodType == MethodType.method), 'Cannot use a non-class function as a constructor or destructor ' + method + + // it's ok to pass a 'class' node if the methodType is either constructor or destructor + assert (method.name() != 'class' || (methodType == MethodType.constructor || methodType == MethodType.destructor)) + + // if this is a constructor node then the methodtype best reflect that + assert (method.name() != 'constructor' || methodType == MethodType.constructor), 'Cannot use a constructor node and not identify the type as a constructor' + method + + // if this is a destructor node then the methodtype best reflect that + assert (method.name() != 'destructor' || methodType == MethodType.destructor), 'Cannot use a destructor node and not identify the type as a destructor' + method + + if (clazz == null) + return method.@sym_name + + if (methodType == MethodType.constructor) + return clazz + "_New" + + if (methodType == MethodType.destructor) + return clazz + "_Dealloc" + + if (method.@name.startsWith("operator ")) + { + if ("[]" == method.@name.substring(9)) + return clazz + "_operatorIndex_" + + if ("()" == method.@name.substring(9)) + return clazz + "_callable_" + } + + return clazz + "_" + method.@sym_name; + } + + public static String makeDocString(Node docnode) + { + if (docnode?.name() != 'doc') + throw new RuntimeException("Invalid doc Node passed to PythonTools.makeDocString (" + docnode + ")") + + String[] lines = (docnode.@value).split(Helper.newline) + def ret = '' + lines.eachWithIndex { val, index -> + val = ((val =~ /\\n/).replaceAll('')) // remove extraneous \n's + val = val.replaceAll("\\\\","\\\\\\\\") // escape backslash + val = ((val =~ /\"/).replaceAll("\\\\\"")) // escape quotes + ret += ('"' + val + '\\n"' + (index != lines.length - 1 ? Helper.newline : '')) + } + + return ret + } + + public static Node findValidBaseClass(Node clazz, Node module, boolean warn = false) + { + // I need to find the base type if there is a known class with it + assert clazz.baselist.size() < 2, "${clazz} has multiple baselists - need to write code to separate out the public one." + String baseclass = 'NULL' + List knownbases = [] + if (clazz.baselist) + { + if (clazz.baselist[0].base) clazz.baselist[0].base.each { + Node baseclassnode = Helper.findClassNodeByName(module,it.@name,clazz) + if (baseclassnode) knownbases.add(baseclassnode) + else if (warn && !Helper.isKnownBaseType(it.@name,clazz)) + System.out.println("WARNING: the base class ${it.@name} for ${Helper.findFullClassName(clazz)} is unrecognized within ${module.@name}.") + } + } + assert knownbases.size() < 2, + "The class ${Helper.findFullClassName(clazz)} has too many known base classes. Multiple inheritance isn't supported in the code generator. Please \"#ifdef SWIG\" out all but one." + return knownbases.size() > 0 ? knownbases[0] : null + } +} diff --git a/xbmc/interfaces/python/XBPython.cpp b/xbmc/interfaces/python/XBPython.cpp new file mode 100644 index 0000000..ee8ed93 --- /dev/null +++ b/xbmc/interfaces/python/XBPython.cpp @@ -0,0 +1,627 @@ +/* + * 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. + */ + +// clang-format off +// python.h should always be included first before any other includes +#include <mutex> +#include <Python.h> +// clang-format on + +#include "XBPython.h" + +#include "ServiceBroker.h" +#include "Util.h" +#include "cores/DllLoader/DllLoaderContainer.h" +#include "filesystem/SpecialProtocol.h" +#include "interfaces/AnnouncementManager.h" +#include "interfaces/legacy/AddonUtils.h" +#include "interfaces/legacy/Monitor.h" +#include "interfaces/python/AddonPythonInvoker.h" +#include "interfaces/python/PythonInvoker.h" +#include "settings/AdvancedSettings.h" +#include "settings/SettingsComponent.h" +#include "utils/JSONVariantWriter.h" +#include "utils/Variant.h" +#include "utils/log.h" +#include "utils/CharsetConverter.h" + +#ifdef TARGET_WINDOWS +#include "platform/Environment.h" +#endif + +#include <algorithm> + +// Only required for Py3 < 3.7 +PyThreadState* savestate; + +bool XBPython::m_bInitialized = false; + +XBPython::XBPython() +{ + CServiceBroker::GetAnnouncementManager()->AddAnnouncer(this); +} + +XBPython::~XBPython() +{ + XBMC_TRACE; + CServiceBroker::GetAnnouncementManager()->RemoveAnnouncer(this); +} + +#define LOCK_AND_COPY(type, dest, src) \ + if (!m_bInitialized) \ + return; \ + std::unique_lock<CCriticalSection> lock(src); \ + src.hadSomethingRemoved = false; \ + type dest; \ + dest = src + +#define CHECK_FOR_ENTRY(l, v) \ + (l.hadSomethingRemoved ? (std::find(l.begin(), l.end(), v) != l.end()) : true) + +void XBPython::Announce(ANNOUNCEMENT::AnnouncementFlag flag, + const std::string& sender, + const std::string& message, + const CVariant& data) +{ + if (flag & ANNOUNCEMENT::VideoLibrary) + { + if (message == "OnScanFinished") + OnScanFinished("video"); + else if (message == "OnScanStarted") + OnScanStarted("video"); + else if (message == "OnCleanStarted") + OnCleanStarted("video"); + else if (message == "OnCleanFinished") + OnCleanFinished("video"); + } + else if (flag & ANNOUNCEMENT::AudioLibrary) + { + if (message == "OnScanFinished") + OnScanFinished("music"); + else if (message == "OnScanStarted") + OnScanStarted("music"); + else if (message == "OnCleanStarted") + OnCleanStarted("music"); + else if (message == "OnCleanFinished") + OnCleanFinished("music"); + } + else if (flag & ANNOUNCEMENT::GUI) + { + if (message == "OnScreensaverDeactivated") + OnScreensaverDeactivated(); + else if (message == "OnScreensaverActivated") + OnScreensaverActivated(); + else if (message == "OnDPMSDeactivated") + OnDPMSDeactivated(); + else if (message == "OnDPMSActivated") + OnDPMSActivated(); + } + + std::string jsonData; + if (CJSONVariantWriter::Write( + data, jsonData, + CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_jsonOutputCompact)) + OnNotification(sender, + std::string(ANNOUNCEMENT::AnnouncementFlagToString(flag)) + "." + + std::string(message), + jsonData); +} + +// message all registered callbacks that we started playing +void XBPython::OnPlayBackStarted(const CFileItem& file) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnPlayBackStarted(file); + } +} + +// message all registered callbacks that we changed stream +void XBPython::OnAVStarted(const CFileItem& file) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnAVStarted(file); + } +} + +// message all registered callbacks that we changed stream +void XBPython::OnAVChange() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnAVChange(); + } +} + +// message all registered callbacks that we paused playing +void XBPython::OnPlayBackPaused() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnPlayBackPaused(); + } +} + +// message all registered callbacks that we resumed playing +void XBPython::OnPlayBackResumed() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnPlayBackResumed(); + } +} + +// message all registered callbacks that xbmc stopped playing +void XBPython::OnPlayBackEnded() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnPlayBackEnded(); + } +} + +// message all registered callbacks that user stopped playing +void XBPython::OnPlayBackStopped() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnPlayBackStopped(); + } +} + +// message all registered callbacks that playback stopped due to error +void XBPython::OnPlayBackError() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnPlayBackError(); + } +} + +// message all registered callbacks that playback speed changed (FF/RW) +void XBPython::OnPlayBackSpeedChanged(int iSpeed) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnPlayBackSpeedChanged(iSpeed); + } +} + +// message all registered callbacks that player is seeking +void XBPython::OnPlayBackSeek(int64_t iTime, int64_t seekOffset) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnPlayBackSeek(iTime, seekOffset); + } +} + +// message all registered callbacks that player chapter seeked +void XBPython::OnPlayBackSeekChapter(int iChapter) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnPlayBackSeekChapter(iChapter); + } +} + +// message all registered callbacks that next item has been queued +void XBPython::OnQueueNextItem() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<void*>, tmp, m_vecPlayerCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecPlayerCallbackList, it)) + ((IPlayerCallback*)it)->OnQueueNextItem(); + } +} + +void XBPython::RegisterPythonPlayerCallBack(IPlayerCallback* pCallback) +{ + XBMC_TRACE; + std::unique_lock<CCriticalSection> lock(m_vecPlayerCallbackList); + m_vecPlayerCallbackList.push_back(pCallback); +} + +void XBPython::UnregisterPythonPlayerCallBack(IPlayerCallback* pCallback) +{ + XBMC_TRACE; + std::unique_lock<CCriticalSection> lock(m_vecPlayerCallbackList); + PlayerCallbackList::iterator it = m_vecPlayerCallbackList.begin(); + while (it != m_vecPlayerCallbackList.end()) + { + if (*it == pCallback) + { + it = m_vecPlayerCallbackList.erase(it); + m_vecPlayerCallbackList.hadSomethingRemoved = true; + } + else + ++it; + } +} + +void XBPython::RegisterPythonMonitorCallBack(XBMCAddon::xbmc::Monitor* pCallback) +{ + XBMC_TRACE; + std::unique_lock<CCriticalSection> lock(m_vecMonitorCallbackList); + m_vecMonitorCallbackList.push_back(pCallback); +} + +void XBPython::UnregisterPythonMonitorCallBack(XBMCAddon::xbmc::Monitor* pCallback) +{ + XBMC_TRACE; + std::unique_lock<CCriticalSection> lock(m_vecMonitorCallbackList); + MonitorCallbackList::iterator it = m_vecMonitorCallbackList.begin(); + while (it != m_vecMonitorCallbackList.end()) + { + if (*it == pCallback) + { + it = m_vecMonitorCallbackList.erase(it); + m_vecMonitorCallbackList.hadSomethingRemoved = true; + } + else + ++it; + } +} + +void XBPython::OnSettingsChanged(const std::string& ID) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it) && (it->GetId() == ID)) + it->OnSettingsChanged(); + } +} + +void XBPython::OnScreensaverActivated() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it)) + it->OnScreensaverActivated(); + } +} + +void XBPython::OnScreensaverDeactivated() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it)) + it->OnScreensaverDeactivated(); + } +} + +void XBPython::OnDPMSActivated() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it)) + it->OnDPMSActivated(); + } +} + +void XBPython::OnDPMSDeactivated() +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it)) + it->OnDPMSDeactivated(); + } +} + +void XBPython::OnScanStarted(const std::string& library) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it)) + it->OnScanStarted(library); + } +} + +void XBPython::OnScanFinished(const std::string& library) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it)) + it->OnScanFinished(library); + } +} + +void XBPython::OnCleanStarted(const std::string& library) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it)) + it->OnCleanStarted(library); + } +} + +void XBPython::OnCleanFinished(const std::string& library) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it)) + it->OnCleanFinished(library); + } +} + +void XBPython::OnNotification(const std::string& sender, + const std::string& method, + const std::string& data) +{ + XBMC_TRACE; + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it)) + it->OnNotification(sender, method, data); + } +} + +void XBPython::Uninitialize() +{ + // don't handle any more announcements as most scripts are probably already + // stopped and executing a callback on one of their already destroyed classes + // would lead to a crash + CServiceBroker::GetAnnouncementManager()->RemoveAnnouncer(this); + + LOCK_AND_COPY(std::vector<PyElem>, tmpvec, m_vecPyList); + m_vecPyList.clear(); + m_vecPyList.hadSomethingRemoved = true; + + lock.unlock(); //unlock here because the python thread might lock when it exits + + // cleanup threads that are still running + tmpvec.clear(); +} + +void XBPython::Process() +{ + if (m_bInitialized) + { + PyList tmpvec; + std::unique_lock<CCriticalSection> lock(m_vecPyList); + for (PyList::iterator it = m_vecPyList.begin(); it != m_vecPyList.end();) + { + if (it->bDone) + { + tmpvec.push_back(*it); + it = m_vecPyList.erase(it); + m_vecPyList.hadSomethingRemoved = true; + } + else + ++it; + } + lock.unlock(); + + //delete scripts which are done + tmpvec.clear(); + } +} + +bool XBPython::OnScriptInitialized(ILanguageInvoker* invoker) +{ + if (invoker == NULL) + return false; + + XBMC_TRACE; + CLog::Log(LOGDEBUG, "initializing python engine."); + std::unique_lock<CCriticalSection> lock(m_critSection); + m_iDllScriptCounter++; + if (!m_bInitialized) + { + // Darwin packs .pyo files, we need PYTHONOPTIMIZE on in order to load them. + // linux built with unified builds only packages the pyo files so need it +#if defined(TARGET_DARWIN) || defined(TARGET_LINUX) + setenv("PYTHONOPTIMIZE", "1", 1); +#endif + // Info about interesting python envvars available + // at http://docs.python.org/using/cmdline.html#environment-variables + +#if !defined(TARGET_WINDOWS) && !defined(TARGET_ANDROID) + // check if we are running as real xbmc.app or just binary + if (!CUtil::GetFrameworksPath(true).empty()) + { + // using external python, it's build looking for xxx/lib/python3.8 + // so point it to frameworks which is where python3.8 is located + setenv("PYTHONHOME", CSpecialProtocol::TranslatePath("special://frameworks").c_str(), 1); + setenv("PYTHONPATH", CSpecialProtocol::TranslatePath("special://frameworks").c_str(), 1); + CLog::Log(LOGDEBUG, "PYTHONHOME -> {}", + CSpecialProtocol::TranslatePath("special://frameworks")); + CLog::Log(LOGDEBUG, "PYTHONPATH -> {}", + CSpecialProtocol::TranslatePath("special://frameworks")); + } +#elif defined(TARGET_WINDOWS) + +#ifdef TARGET_WINDOWS_STORE +#ifdef _DEBUG + CEnvironment::putenv("PYTHONCASEOK=1"); +#endif + CEnvironment::putenv("OS=win10"); +#else // TARGET_WINDOWS_DESKTOP + CEnvironment::putenv("OS=win32"); +#endif + + std::wstring pythonHomeW; + CCharsetConverter::utf8ToW(CSpecialProtocol::TranslatePath("special://xbmc/system/python"), + pythonHomeW); + Py_SetPythonHome(pythonHomeW.c_str()); + + std::string pythonPath = CSpecialProtocol::TranslatePath("special://xbmc/system/python/DLLs"); + pythonPath += ";"; + pythonPath += CSpecialProtocol::TranslatePath("special://xbmc/system/python/Lib"); + pythonPath += ";"; + pythonPath += CSpecialProtocol::TranslatePath("special://xbmc/system/python/Lib/site-packages"); + std::wstring pythonPathW; + CCharsetConverter::utf8ToW(pythonPath, pythonPathW); + + Py_SetPath(pythonPathW.c_str()); + + Py_OptimizeFlag = 1; +#endif + + Py_Initialize(); + +#if PY_VERSION_HEX < 0x03070000 + // Python >= 3.7 Py_Initialize implicitly calls PyEval_InitThreads + // Python < 3.7 we have to manually call initthreads. + // PyEval_InitThreads is a no-op on subsequent calls, No need to wrap in + // PyEval_ThreadsInitialized() check + PyEval_InitThreads(); +#endif + + // Acquire GIL if thread doesn't currently hold. + if (!PyGILState_Check()) + PyEval_RestoreThread((PyThreadState*)m_mainThreadState); + + if (!(m_mainThreadState = PyThreadState_Get())) + CLog::Log(LOGERROR, "Python threadstate is NULL."); + savestate = PyEval_SaveThread(); + + m_bInitialized = true; + } + + return m_bInitialized; +} + +void XBPython::OnScriptStarted(ILanguageInvoker* invoker) +{ + if (invoker == NULL) + return; + + if (!m_bInitialized) + return; + + PyElem inf; + inf.id = invoker->GetId(); + inf.bDone = false; + inf.pyThread = static_cast<CPythonInvoker*>(invoker); + std::unique_lock<CCriticalSection> lock(m_vecPyList); + m_vecPyList.push_back(inf); +} + +void XBPython::NotifyScriptAborting(ILanguageInvoker* invoker) +{ + XBMC_TRACE; + + long invokerId(-1); + if (invoker != NULL) + invokerId = invoker->GetId(); + + LOCK_AND_COPY(std::vector<XBMCAddon::xbmc::Monitor*>, tmp, m_vecMonitorCallbackList); + for (auto& it : tmp) + { + if (CHECK_FOR_ENTRY(m_vecMonitorCallbackList, it)) + { + if (invokerId < 0 || it->GetInvokerId() == invokerId) + it->AbortNotify(); + } + } +} + +void XBPython::OnExecutionEnded(ILanguageInvoker* invoker) +{ + std::unique_lock<CCriticalSection> lock(m_vecPyList); + PyList::iterator it = m_vecPyList.begin(); + while (it != m_vecPyList.end()) + { + if (it->id == invoker->GetId()) + { + if (it->pyThread->IsStopping()) + CLog::Log(LOGDEBUG, "Python interpreter interrupted by user"); + else + CLog::Log(LOGDEBUG, "Python interpreter stopped"); + it->bDone = true; + } + ++it; + } +} + +void XBPython::OnScriptFinalized(ILanguageInvoker* invoker) +{ + XBMC_TRACE; + std::unique_lock<CCriticalSection> lock(m_critSection); + // for linux - we never release the library. its loaded and stays in memory. + if (m_iDllScriptCounter) + m_iDllScriptCounter--; + else + CLog::Log(LOGERROR, "Python script counter attempted to become negative"); +} + +ILanguageInvoker* XBPython::CreateInvoker() +{ + return new CAddonPythonInvoker(this); +} + +void XBPython::PulseGlobalEvent() +{ + m_globalEvent.Set(); +} + +bool XBPython::WaitForEvent(CEvent& hEvent, unsigned int milliseconds) +{ + // wait for either this event our our global event + XbmcThreads::CEventGroup eventGroup{&hEvent, &m_globalEvent}; + CEvent* ret = eventGroup.wait(std::chrono::milliseconds(milliseconds)); + if (ret) + m_globalEvent.Reset(); + return ret != NULL; +} diff --git a/xbmc/interfaces/python/XBPython.h b/xbmc/interfaces/python/XBPython.h new file mode 100644 index 0000000..e54b4a2 --- /dev/null +++ b/xbmc/interfaces/python/XBPython.h @@ -0,0 +1,123 @@ +/* + * 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 "cores/IPlayerCallback.h" +#include "interfaces/IAnnouncer.h" +#include "interfaces/generic/ILanguageInvocationHandler.h" +#include "threads/CriticalSection.h" +#include "threads/Event.h" +#include "threads/Thread.h" + +#include <memory> +#include <vector> + +class CPythonInvoker; +class CVariant; + +typedef struct +{ + int id; + bool bDone; + CPythonInvoker* pyThread; +} PyElem; + +class LibraryLoader; + +namespace XBMCAddon +{ +namespace xbmc +{ +class Monitor; +} +} // namespace XBMCAddon + +template<class T> +struct LockableType : public T, public CCriticalSection +{ + bool hadSomethingRemoved; +}; + +typedef LockableType<std::vector<void*>> PlayerCallbackList; +typedef LockableType<std::vector<XBMCAddon::xbmc::Monitor*>> MonitorCallbackList; +typedef LockableType<std::vector<PyElem>> PyList; +typedef std::vector<LibraryLoader*> PythonExtensionLibraries; + +class XBPython : public IPlayerCallback, + public ANNOUNCEMENT::IAnnouncer, + public ILanguageInvocationHandler +{ +public: + XBPython(); + ~XBPython() override; + void OnPlayBackEnded() override; + void OnPlayBackStarted(const CFileItem& file) override; + void OnAVStarted(const CFileItem& file) override; + void OnAVChange() override; + void OnPlayBackPaused() override; + void OnPlayBackResumed() override; + void OnPlayBackStopped() override; + void OnPlayBackError() override; + void OnPlayBackSpeedChanged(int iSpeed) override; + void OnPlayBackSeek(int64_t iTime, int64_t seekOffset) override; + void OnPlayBackSeekChapter(int iChapter) override; + void OnQueueNextItem() override; + + void Announce(ANNOUNCEMENT::AnnouncementFlag flag, + const std::string& sender, + const std::string& message, + const CVariant& data) override; + void RegisterPythonPlayerCallBack(IPlayerCallback* pCallback); + void UnregisterPythonPlayerCallBack(IPlayerCallback* pCallback); + void RegisterPythonMonitorCallBack(XBMCAddon::xbmc::Monitor* pCallback); + void UnregisterPythonMonitorCallBack(XBMCAddon::xbmc::Monitor* pCallback); + void OnSettingsChanged(const std::string& strings); + void OnScreensaverActivated(); + void OnScreensaverDeactivated(); + void OnDPMSActivated(); + void OnDPMSDeactivated(); + void OnScanStarted(const std::string& library); + void OnScanFinished(const std::string& library); + void OnCleanStarted(const std::string& library); + void OnCleanFinished(const std::string& library); + void OnNotification(const std::string& sender, + const std::string& method, + const std::string& data); + + void Process() override; + void PulseGlobalEvent() override; + void Uninitialize() override; + bool OnScriptInitialized(ILanguageInvoker* invoker) override; + void OnScriptStarted(ILanguageInvoker* invoker) override; + void NotifyScriptAborting(ILanguageInvoker* invoker) override; + void OnExecutionEnded(ILanguageInvoker* invoker) override; + void OnScriptFinalized(ILanguageInvoker* invoker) override; + ILanguageInvoker* CreateInvoker() override; + + bool WaitForEvent(CEvent& hEvent, unsigned int milliseconds); + +private: + static bool m_bInitialized; // whether global python runtime was already initialized + + CCriticalSection m_critSection; + void* m_mainThreadState{nullptr}; + int m_iDllScriptCounter{0}; // to keep track of the total scripts running that need the dll + + //Vector with list of threads used for running scripts + PyList m_vecPyList; + PlayerCallbackList m_vecPlayerCallbackList; + MonitorCallbackList m_vecMonitorCallbackList; + + // any global events that scripts should be using + CEvent m_globalEvent; + + // in order to finalize and unload the python library, need to save all the extension libraries that are + // loaded by it and unload them first (not done by finalize) + PythonExtensionLibraries m_extensions; +}; diff --git a/xbmc/interfaces/python/preamble.h b/xbmc/interfaces/python/preamble.h new file mode 100644 index 0000000..080a4fb --- /dev/null +++ b/xbmc/interfaces/python/preamble.h @@ -0,0 +1,15 @@ +/* + * 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 + +#ifdef SWIGPYTHON + +#include <Python.h> + +#endif diff --git a/xbmc/interfaces/python/pythreadstate.h b/xbmc/interfaces/python/pythreadstate.h new file mode 100644 index 0000000..2cae5a7 --- /dev/null +++ b/xbmc/interfaces/python/pythreadstate.h @@ -0,0 +1,64 @@ +/* + * 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 + + +//WARNING: since this will unlock/lock the python global interpreter lock, +// it will not work recursively + +//this is basically a scoped version of a Py_BEGIN_ALLOW_THREADS .. Py_END_ALLOW_THREADS block +class CPyThreadState +{ + public: + explicit CPyThreadState(bool save = true) + { + m_threadState = NULL; + + if (save) + Save(); + } + + ~CPyThreadState() + { + Restore(); + } + + void Save() + { + if (!m_threadState) + m_threadState = PyEval_SaveThread(); //same as Py_BEGIN_ALLOW_THREADS + } + + void Restore() + { + if (m_threadState) + { + PyEval_RestoreThread(m_threadState); //same as Py_END_ALLOW_THREADS + m_threadState = NULL; + } + } + + private: + PyThreadState* m_threadState; +}; + +/** + * A std::unique_lock<CCriticalSection> that will relinquish the GIL during the time + * it takes to obtain the CriticalSection + */ +class GilSafeSingleLock : public CPyThreadState, public std::unique_lock<CCriticalSection> +{ +public: + explicit GilSafeSingleLock(CCriticalSection& critSec) + : CPyThreadState(true), std::unique_lock<CCriticalSection>(critSec) + { + CPyThreadState::Restore(); + } +}; + diff --git a/xbmc/interfaces/python/swig.cpp b/xbmc/interfaces/python/swig.cpp new file mode 100644 index 0000000..0c49f87 --- /dev/null +++ b/xbmc/interfaces/python/swig.cpp @@ -0,0 +1,443 @@ +/* + * 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 "swig.h" + +#include "LanguageHook.h" +#include "interfaces/legacy/AddonString.h" +#include "utils/StringUtils.h" + +#include <string> + +namespace PythonBindings +{ + TypeInfo::TypeInfo(const std::type_info& ti) : swigType(NULL), parentType(NULL), typeIndex(ti) + { + static PyTypeObject py_type_object_header = { + PyVarObject_HEAD_INIT(nullptr, 0) 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX > 0x03080000 + 0, + 0, +#endif +#if PY_VERSION_HEX < 0x03090000 + 0, +#endif +#if PY_VERSION_HEX >= 0x030C00A1 + 0, +#endif + }; + + static int size = (long*)&(py_type_object_header.tp_name) - (long*)&py_type_object_header; + memcpy(&(this->pythonType), &py_type_object_header, size); + } + + class PyObjectDecrementor + { + PyObject* obj; + public: + inline explicit PyObjectDecrementor(PyObject* pyobj) : obj(pyobj) {} + inline ~PyObjectDecrementor() { Py_XDECREF(obj); } + + inline PyObject* get() { return obj; } + }; + + void PyXBMCGetUnicodeString(std::string& buf, PyObject* pObject, bool coerceToString, + const char* argumentName, const char* methodname) + { + // It's okay for a string to be "None". In this case the buf returned + // will be the emptyString. + if (pObject == Py_None) + { + buf = XBMCAddon::emptyString; + return; + } + + //! @todo UTF-8: Does python use UTF-16? + //! Do we need to convert from the string charset to UTF-8 + //! for non-unicode data? + if (PyUnicode_Check(pObject)) + { + // Python unicode objects are UCS2 or UCS4 depending on compilation + // options, wchar_t is 16-bit or 32-bit depending on platform. + // Avoid the complexity by just letting python convert the string. + + buf = PyUnicode_AsUTF8(pObject); + return; + } + + if (PyBytes_Check(pObject)) // If pobject is of type Bytes + { + buf = PyBytes_AsString(pObject); + return; + } + + // if we got here then we need to coerce the value to a string + if (coerceToString) + { + PyObjectDecrementor dec(PyObject_Str(pObject)); + PyObject* pyStrCast = dec.get(); + if (pyStrCast) + { + PyXBMCGetUnicodeString(buf,pyStrCast,false,argumentName,methodname); + return; + } + } + + // Object is not a unicode or a normal string. + buf = ""; + throw XBMCAddon::WrongTypeException("argument \"%s\" for method \"%s\" must be unicode or str", argumentName, methodname); + } + + // need to compare the typestring + bool isParameterRightType(const char* passedType, const char* expectedType, const char* methodNamespacePrefix, bool tryReverse) + { + if (strcmp(expectedType,passedType) == 0) + return true; + + // well now things are a bit more complicated. We need to see if the passed type + // is a subset of the overall type + std::string et(expectedType); + bool isPointer = (et[0] == 'p' && et[1] == '.'); + std::string baseType(et,(isPointer ? 2 : 0)); // this may contain a namespace + + std::string ns(methodNamespacePrefix); + // cut off trailing '::' + if (ns.size() > 2 && ns[ns.size() - 1] == ':' && ns[ns.size() - 2] == ':') + ns = ns.substr(0,ns.size()-2); + + bool done = false; + while(! done) + { + done = true; + + // now we need to see if the expected type can be munged + // into the passed type by tacking on the namespace of + // of the method. + std::string check(isPointer ? "p." : ""); + check += ns; + check += "::"; + check += baseType; + + if (strcmp(check.c_str(),passedType) == 0) + return true; + + // see if the namespace is nested. + int posOfScopeOp = ns.find("::"); + if (posOfScopeOp >= 0) + { + done = false; + // cur off the outermost namespace + ns = ns.substr(posOfScopeOp + 2); + } + } + + // so far we applied the namespace to the expected type. Now lets try + // the reverse if we haven't already. + if (tryReverse) + return isParameterRightType(expectedType, passedType, methodNamespacePrefix, false); + + return false; + } + + PythonToCppException::PythonToCppException() : XbmcCommons::UncheckedException(" ") + { + setClassname("PythonToCppException"); + + std::string msg; + std::string type, value, traceback; + if (!ParsePythonException(type, value, traceback)) + UncheckedException::SetMessage("Strange: No Python exception occurred"); + else + SetMessage(type, value, traceback); + } + + PythonToCppException::PythonToCppException(const std::string &exceptionType, const std::string &exceptionValue, const std::string &exceptionTraceback) : XbmcCommons::UncheckedException(" ") + { + setClassname("PythonToCppException"); + + SetMessage(exceptionType, exceptionValue, exceptionTraceback); + } + + bool PythonToCppException::ParsePythonException(std::string &exceptionType, std::string &exceptionValue, std::string &exceptionTraceback) + { + PyObject* exc_type; + PyObject* exc_value; + PyObject* exc_traceback; + PyObject* pystring = NULL; + + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + if (exc_type == NULL && exc_value == NULL && exc_traceback == NULL) + return false; + + // See https://docs.python.org/3/c-api/exceptions.html#c.PyErr_NormalizeException + PyErr_NormalizeException(&exc_type, &exc_value, &exc_traceback); + if (exc_traceback != NULL) { + PyException_SetTraceback(exc_value, exc_traceback); + } + + exceptionType.clear(); + exceptionValue.clear(); + exceptionTraceback.clear(); + + if (exc_type != NULL && (pystring = PyObject_Str(exc_type)) != NULL && PyUnicode_Check(pystring)) + { + const char* str = PyUnicode_AsUTF8(pystring); + if (str != NULL) + exceptionType = str; + + pystring = PyObject_Str(exc_value); + if (pystring != NULL) + { + str = PyUnicode_AsUTF8(pystring); + exceptionValue = str; + } + + PyObject *tracebackModule = PyImport_ImportModule("traceback"); + if (tracebackModule != NULL) + { + char method[] = "format_exception"; + char format[] = "OOO"; + PyObject *tbList = PyObject_CallMethod(tracebackModule, method, format, exc_type, exc_value == NULL ? Py_None : exc_value, exc_traceback == NULL ? Py_None : exc_traceback); + + if (tbList) + { + PyObject* emptyString = PyUnicode_FromString(""); + char method[] = "join"; + char format[] = "O"; + PyObject *strRetval = PyObject_CallMethod(emptyString, method, format, tbList); + Py_DECREF(emptyString); + + if (strRetval) + { + str = PyUnicode_AsUTF8(strRetval); + if (str != NULL) + exceptionTraceback = str; + Py_DECREF(strRetval); + } + Py_DECREF(tbList); + } + Py_DECREF(tracebackModule); + + } + } + + Py_XDECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_traceback); + Py_XDECREF(pystring); + + return true; + } + + void PythonToCppException::SetMessage(const std::string &exceptionType, const std::string &exceptionValue, const std::string &exceptionTraceback) + { + std::string msg = "-->Python callback/script returned the following error<--\n"; + msg += " - NOTE: IGNORING THIS CAN LEAD TO MEMORY LEAKS!\n"; + + if (!exceptionType.empty()) + { + msg += StringUtils::Format("Error Type: {}\n", exceptionType); + + if (!exceptionValue.empty()) + msg += StringUtils::Format("Error Contents: {}\n", exceptionValue); + + if (!exceptionTraceback.empty()) + msg += exceptionTraceback; + + msg += "-->End of Python script error report<--\n"; + } + else + msg += "<unknown exception type>"; + + UncheckedException::SetMessage("%s", msg.c_str()); + } + + XBMCAddon::AddonClass* doretrieveApiInstance(const PyHolder* pythonObj, const TypeInfo* typeInfo, const char* expectedType, + const char* methodNamespacePrefix, const char* methodNameForErrorString) + { + if (pythonObj->magicNumber != XBMC_PYTHON_TYPE_MAGIC_NUMBER) + throw XBMCAddon::WrongTypeException("Non api type passed to \"%s\" in place of the expected type \"%s.\"", + methodNameForErrorString, expectedType); + if (!isParameterRightType(typeInfo->swigType,expectedType,methodNamespacePrefix)) + { + // maybe it's a child class + if (typeInfo->parentType) + return doretrieveApiInstance(pythonObj, typeInfo->parentType,expectedType, + methodNamespacePrefix, methodNameForErrorString); + else + throw XBMCAddon::WrongTypeException("Incorrect type passed to \"%s\", was expecting a \"%s\" but received a \"%s\"", + methodNameForErrorString,expectedType,typeInfo->swigType); + } + return const_cast<XBMCAddon::AddonClass*>(pythonObj->pSelf); + } + + /** + * This method is a helper for the generated API. It's called prior to any API + * class constructor being returned from the generated code to Python + */ + void prepareForReturn(XBMCAddon::AddonClass* c) + { + XBMC_TRACE; + if(c) { + c->Acquire(); + PyThreadState* state = PyThreadState_Get(); + XBMCAddon::Python::PythonLanguageHook::GetIfExists(state->interp)->RegisterAddonClassInstance(c); + } + } + + static bool handleInterpRegistrationForClean(XBMCAddon::AddonClass* c) + { + XBMC_TRACE; + if(c){ + XBMCAddon::AddonClass::Ref<XBMCAddon::Python::PythonLanguageHook> lh = + XBMCAddon::AddonClass::Ref<XBMCAddon::AddonClass>(c->GetLanguageHook()); + + if (lh.isNotNull()) + { + lh->UnregisterAddonClassInstance(c); + return true; + } + else + { + PyThreadState* state = PyThreadState_Get(); + lh = XBMCAddon::Python::PythonLanguageHook::GetIfExists(state->interp); + if (lh.isNotNull()) lh->UnregisterAddonClassInstance(c); + return true; + } + } + return false; + } + + /** + * This method is a helper for the generated API. It's called prior to any API + * class destructor being dealloc-ed from the generated code from Python + */ + void cleanForDealloc(XBMCAddon::AddonClass* c) + { + XBMC_TRACE; + if (handleInterpRegistrationForClean(c)) + c->Release(); + } + + /** + * This method is a helper for the generated API. It's called prior to any API + * class destructor being dealloc-ed from the generated code from Python + * + * There is a Catch-22 in the destruction of a Window. 'dispose' needs to be + * called on destruction but cannot be called from the destructor. + * This overrides the default cleanForDealloc to resolve that. + */ + void cleanForDealloc(XBMCAddon::xbmcgui::Window* c) + { + XBMC_TRACE; + if (handleInterpRegistrationForClean(c)) + { + c->dispose(); + c->Release(); + } + } + + /** + * This method allows for conversion of the native api Type to the Python type. + * + * When this form of the call is used (and pytype isn't NULL) then the + * passed type is used in the instance. This is for classes that extend API + * classes in python. The type passed may not be the same type that's stored + * in the class metadata of the AddonClass of which 'api' is an instance, + * it can be a subclass in python. + * + * if pytype is NULL then the type is inferred using the class metadata + * stored in the AddonClass instance 'api'. + */ + PyObject* makePythonInstance(XBMCAddon::AddonClass* api, PyTypeObject* pytype, bool incrementRefCount) + { + // null api types result in Py_None + if (!api) + { + Py_INCREF(Py_None); + return Py_None; + } + + // retrieve the TypeInfo from the api class + const TypeInfo* typeInfo = getTypeInfoForInstance(api); + PyTypeObject* typeObj = pytype == NULL ? const_cast<PyTypeObject*>(&(typeInfo->pythonType)) : pytype; + + PyHolder* self = reinterpret_cast<PyHolder*>(typeObj->tp_alloc(typeObj,0)); + if (!self) return NULL; + self->magicNumber = XBMC_PYTHON_TYPE_MAGIC_NUMBER; + self->typeInfo = typeInfo; + self->pSelf = api; + if (incrementRefCount) + Py_INCREF((PyObject*)self); + return (PyObject*)self; + } + + std::map<std::type_index, const TypeInfo*> typeInfoLookup; + + void registerAddonClassTypeInformation(const TypeInfo* classInfo) + { + typeInfoLookup[classInfo->typeIndex] = classInfo; + } + + const TypeInfo* getTypeInfoForInstance(XBMCAddon::AddonClass* obj) + { + std::type_index ti(typeid(*obj)); + return typeInfoLookup[ti]; + } + + int dummy_tp_init(PyObject* self, PyObject* args, PyObject* kwds) + { + return 0; + } +} + diff --git a/xbmc/interfaces/python/swig.h b/xbmc/interfaces/python/swig.h new file mode 100644 index 0000000..353d968 --- /dev/null +++ b/xbmc/interfaces/python/swig.h @@ -0,0 +1,202 @@ +/* + * 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 "interfaces/legacy/AddonClass.h" +#include "interfaces/legacy/Exception.h" +#include "interfaces/legacy/Window.h" + +#include <stdint.h> +#include <string> +#include <typeindex> + +#include <Python.h> + +namespace PythonBindings +{ + /** + * This call will convert the python object passed to a string. The object + * passed must be a python str or unicode object unless coerceToString is + * true. If coerceToString is true then the type must be castable to a string + * using the python call str(pObject). + * + * This method will handle a 'None' that's passed in. If 'None' is passed then + * the resulting buf will contain the value of XBMCAddon::emptyString (which + * is simply a std::string instantiated with the default constructor. + */ + void PyXBMCGetUnicodeString(std::string& buf, PyObject* pObject, bool coerceToString = false, + const char* pos = "unknown", + const char* methodname = "unknown"); + + struct TypeInfo + { + const char* swigType; + TypeInfo* parentType; + PyTypeObject pythonType; + const std::type_index typeIndex; + + explicit TypeInfo(const std::type_info& ti); + }; + + // This will hold the pointer to the api type, whether known or unknown + struct PyHolder + { + PyObject_HEAD + int32_t magicNumber; + const TypeInfo* typeInfo; + XBMCAddon::AddonClass* pSelf; + }; + +#define XBMC_PYTHON_TYPE_MAGIC_NUMBER 0x58626D63 + + /** + * This method retrieves the pointer from the PyHolder. The return value should + * be cast to the appropriate type. + * + * Since the calls to this are generated there's no NULL pointer checks + */ + inline XBMCAddon::AddonClass* retrieveApiInstance(PyObject* pythonObj, const TypeInfo* typeToCheck, + const char* methodNameForErrorString, + const char* typenameForErrorString) + { + if (pythonObj == NULL || pythonObj == Py_None) + return NULL; + if (reinterpret_cast<PyHolder*>(pythonObj)->magicNumber != XBMC_PYTHON_TYPE_MAGIC_NUMBER || !PyObject_TypeCheck(pythonObj, const_cast<PyTypeObject*>((&(typeToCheck->pythonType))))) + throw XBMCAddon::WrongTypeException("Incorrect type passed to \"%s\", was expecting a \"%s\".",methodNameForErrorString,typenameForErrorString); + return reinterpret_cast<PyHolder*>(pythonObj)->pSelf; + } + + bool isParameterRightType(const char* passedType, const char* expectedType, const char* methodNamespacePrefix, bool tryReverse = true); + + XBMCAddon::AddonClass* doretrieveApiInstance(const PyHolder* pythonObj, const TypeInfo* typeInfo, const char* expectedType, + const char* methodNamespacePrefix, const char* methodNameForErrorString); + + /** + * This method retrieves the pointer from the PyHolder. The return value should + * be cast to the appropriate type. + * + * Since the calls to this are generated there's no NULL pointer checks + * + * This method will return NULL if either the pythonObj is NULL or the + * pythonObj is Py_None. + */ + inline XBMCAddon::AddonClass* retrieveApiInstance(const PyObject* pythonObj, const char* expectedType, const char* methodNamespacePrefix, + const char* methodNameForErrorString) + { + return (pythonObj == NULL || pythonObj == Py_None) ? NULL : + doretrieveApiInstance(reinterpret_cast<const PyHolder*>(pythonObj),reinterpret_cast<const PyHolder*>(pythonObj)->typeInfo, expectedType, methodNamespacePrefix, methodNameForErrorString); + } + + /** + * This method is a helper for the generated API. It's called prior to any API + * class constructor being returned from the generated code to Python + */ + void prepareForReturn(XBMCAddon::AddonClass* c); + + /** + * This method is a helper for the generated API. It's called prior to any API + * class destructor being dealloc-ed from the generated code from Python + */ + void cleanForDealloc(XBMCAddon::AddonClass* c); + + /** + * This method is a helper for the generated API. It's called prior to any API + * class destructor being dealloc-ed from the generated code from Python + * + * There is a Catch-22 in the destruction of a Window. 'dispose' needs to be + * called on destruction but cannot be called from the destructor. + * This overrides the default cleanForDealloc to resolve that. + */ + void cleanForDealloc(XBMCAddon::xbmcgui::Window* c); + + /** + * This method allows for conversion of the native api Type to the Python type. + * + * When this form of the call is used (and pythonType isn't NULL) then the + * passed type is used in the instance. This is for classes that extend API + * classes in python. The type passed may not be the same type that's stored + * in the class metadata of the AddonClass of which 'api' is an instance, + * it can be a subclass in python. + * + * if pythonType is NULL then the type is inferred using the class metadata + * stored in the AddonClass instance 'api'. + */ + PyObject* makePythonInstance(XBMCAddon::AddonClass* api, PyTypeObject* pythonType, bool incrementRefCount); + + /** + * This method allows for conversion of the native api Type to the Python type. + * + * When this form of the call is used then the python type constructed will be the + * type given by the class metadata in the AddonClass instance 'api'. + * + * This is just a helper inline to call the other makePythonInstance with NULL as + * the pythonType. + */ + inline PyObject* makePythonInstance(XBMCAddon::AddonClass* api, bool incrementRefCount) + { + return makePythonInstance(api,NULL,incrementRefCount); + } + + void registerAddonClassTypeInformation(const TypeInfo* classInfo); + const TypeInfo* getTypeInfoForInstance(XBMCAddon::AddonClass* obj); + + int dummy_tp_init(PyObject* self, PyObject* args, PyObject* kwds); + + class Director + { + protected: + PyObject* self; + public: + inline Director() : self(NULL) {} + inline void setPyObjectForDirector(PyObject* pyargself) { self = pyargself; } + }; + + /** + * This exception is thrown from Director calls that call into python when the + * Python error is + */ + class PythonToCppException : public XbmcCommons::UncheckedException + { + public: + /** + * Assuming a PyErr_Occurred, this will fill the exception message with all + * of the appropriate information including the traceback if it can be + * obtained. It will also clear the python message. + */ + PythonToCppException(); + PythonToCppException(const std::string &exceptionType, const std::string &exceptionValue, const std::string &exceptionTraceback); + + static bool ParsePythonException(std::string &exceptionType, std::string &exceptionValue, std::string &exceptionTraceback); + + protected: + void SetMessage(const std::string &exceptionType, const std::string &exceptionValue, const std::string &exceptionTraceback); + }; + + template<class T> struct PythonCompare + { + static inline int compare(PyObject* obj1, PyObject* obj2, const char* swigType, const char* methodNamespacePrefix, const char* methodNameForErrorString) + { + XBMC_TRACE; + try + { + T* o1 = (T*)retrieveApiInstance(obj1, swigType, methodNamespacePrefix, methodNameForErrorString); + T* o2 = (T*)retrieveApiInstance(obj2, swigType, methodNamespacePrefix, methodNameForErrorString); + + return ((*o1) < (*o2) ? -1 : + ((*o1) > (*o2) ? 1 : 0)); + } + catch (const XBMCAddon::WrongTypeException& e) + { + CLog::Log(LOGERROR, "EXCEPTION: {}", e.GetExMessage()); + PyErr_SetString(PyExc_RuntimeError, e.GetExMessage()); + } + return -1; + } + }; +} diff --git a/xbmc/interfaces/python/test/CMakeLists.txt b/xbmc/interfaces/python/test/CMakeLists.txt new file mode 100644 index 0000000..ec38a51 --- /dev/null +++ b/xbmc/interfaces/python/test/CMakeLists.txt @@ -0,0 +1,5 @@ +if(PYTHON_FOUND) + set(SOURCES TestSwig.cpp) + + core_add_test_library(python_test) +endif() diff --git a/xbmc/interfaces/python/test/TestSwig.cpp b/xbmc/interfaces/python/test/TestSwig.cpp new file mode 100644 index 0000000..463bb98 --- /dev/null +++ b/xbmc/interfaces/python/test/TestSwig.cpp @@ -0,0 +1,21 @@ +/* + * 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 "../swig.h" + +#include <gtest/gtest.h> + +using namespace PythonBindings; + +TEST(TestSwig, TypeConversion) +{ + EXPECT_TRUE(isParameterRightType("p.XBMCAddon::xbmcgui::ListItem","p.XBMCAddon::xbmcgui::ListItem","XBMCAddon::xbmc::")); + EXPECT_TRUE(isParameterRightType("p.XBMCAddon::xbmc::PlayList","p.PlayList","XBMCAddon::xbmc::")); + EXPECT_TRUE(isParameterRightType("p.PlayList","p.XBMCAddon::xbmc::PlayList","XBMCAddon::xbmc::")); +} + diff --git a/xbmc/interfaces/python/typemaps/python.Alternative.intm b/xbmc/interfaces/python/typemaps/python.Alternative.intm new file mode 100644 index 0000000..12a5e65 --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.Alternative.intm @@ -0,0 +1,43 @@ +<% +/* + * 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. + */ + boolean ispointer = swigTypeParser.SwigType_ispointer(ltype) + String accessor = ispointer ? '->' : '.' + int seq = sequence.increment() + altAccess = [ 'former', 'later' ] + altSwitch = [ 'first', 'second' ] + + List types = swigTypeParser.SwigType_templateparmlist(ltype) +%> + { + // we need to check the parameter type and see if it matches + PyObject *pyentry_${seq} = ${slarg}; + try + { + ${swigTypeParser.SwigType_str(swigTypeParser.SwigType_ltype(types[0]))} entry0_${seq}; + ${helper.getInConversion(types[0], 'entry0' + '_' + seq, 'pyentry' + '_' + seq, method, + [ 'sequence' : sequence ])} + ${api}${accessor}${altAccess[0]}() = entry0_${seq}; + } + catch (const XBMCAddon::WrongTypeException&) + { + try + { + ${swigTypeParser.SwigType_str(swigTypeParser.SwigType_ltype(types[1]))} entry1_${seq}; + ${helper.getInConversion(types[1], 'entry1' + '_' + seq, 'pyentry' + '_' + seq, method, + [ 'sequence' : sequence ])} + ${api}${accessor}${altAccess[1]}() = entry1_${seq}; + } + catch (const XBMCAddon::WrongTypeException&) + { + throw XBMCAddon::WrongTypeException("Failed to convert to input type to either a " + "${swigTypeParser.SwigType_ltype(types[0])} or a " + "${swigTypeParser.SwigType_ltype(types[1])}" ); + } + } + }
\ No newline at end of file diff --git a/xbmc/interfaces/python/typemaps/python.Alternative.outtm b/xbmc/interfaces/python/typemaps/python.Alternative.outtm new file mode 100644 index 0000000..31f4205 --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.Alternative.outtm @@ -0,0 +1,34 @@ +<% +/* + * 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. + */ + List types = swigTypeParser.SwigType_templateparmlist(type) + boolean ispointer = swigTypeParser.SwigType_ispointer(type) + int seq = sequence.increment() + String accessor = ispointer ? '->' : '.' + altAccess = [ 'former', 'later' ] + altSwitch = [ 'first', 'second' ] +%> + WhichAlternative pos = ${api}${accessor}which(); + + if (<%if (ispointer) { %>${api} != NULL && <%}%>pos != XBMCAddon::none) + { <% + types.eachWithIndex { curType, entryIndex -> +%> + if (pos == XBMCAddon::${altSwitch[entryIndex]}) + { + ${swigTypeParser.SwigType_str(swigTypeParser.SwigType_lrtype(curType))} entry${seq} = ${api}${accessor}${altAccess[entryIndex]}(); + { + ${helper.getOutConversion(curType,result,method,[ 'api' : 'entry' + seq, 'sequence' : sequence ])} + } + } +<% + } +%> + } + else + ${result} = Py_None;
\ No newline at end of file diff --git a/xbmc/interfaces/python/typemaps/python.Tuple.intm b/xbmc/interfaces/python/typemaps/python.Tuple.intm new file mode 100644 index 0000000..c426856 --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.Tuple.intm @@ -0,0 +1,35 @@ +<% +/* + * 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. + */ + List types = swigTypeParser.SwigType_templateparmlist(ltype) + boolean ispointer = swigTypeParser.SwigType_ispointer(type) + String accessor = ispointer ? '->' : '.' + int seq = sequence.increment() + tupleAccess = [ 'first', 'second', 'third', 'fourth' ] +%> + if(${slarg}) + { + bool isTuple = PyObject_TypeCheck(${slarg},&PyTuple_Type); + if (!isTuple && !PyObject_TypeCheck(${slarg},&PyList_Type)) + throw WrongTypeException("The parameter \"${api}\" must be either a Tuple or a List."); + Py_ssize_t vecSize = (isTuple ? PyTuple_Size(${slarg}) : PyList_Size(${slarg})); +<% + types.eachWithIndex { curType, entryIndex -> +%> + if (vecSize > ${entryIndex}) + { + PyObject *pyentry${entryIndex}_${seq} = NULL; + pyentry${entryIndex}_${seq} = (isTuple ? PyTuple_GetItem(${slarg}, ${entryIndex}) : PyList_GetItem(${slarg}, ${entryIndex})); + ${swigTypeParser.SwigType_str(swigTypeParser.SwigType_ltype(curType))} entry${entryIndex}_${seq}; + ${helper.getInConversion(curType, 'entry' + entryIndex + '_' + seq, 'pyentry' + entryIndex + '_' + seq, method,[ 'sequence' : sequence ])} + ${api}${accessor}${tupleAccess[entryIndex]}() = entry${entryIndex}_${seq}; + } +<% + } +%> + } diff --git a/xbmc/interfaces/python/typemaps/python.Tuple.outtm b/xbmc/interfaces/python/typemaps/python.Tuple.outtm new file mode 100644 index 0000000..18655fe --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.Tuple.outtm @@ -0,0 +1,39 @@ +<% +/* + * 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. + */ + List types = swigTypeParser.SwigType_templateparmlist(type) + boolean ispointer = swigTypeParser.SwigType_ispointer(type) + int seq = sequence.increment() + String accessor = ispointer ? '->' : '.' + tupleAccess = [ 'first', 'second', 'third', 'fourth' ] +%> + int vecSize = ${api}${accessor}GetNumValuesSet(); + ${result} = PyTuple_New(vecSize); +<% + if (ispointer) + { +%> + if (${api} != NULL) +<% } // this ends the if (ispointer) +%> { + PyObject* pyentry${seq}; <% + types.eachWithIndex { curType, entryIndex -> +%> + + if (vecSize > ${entryIndex}) + { + ${swigTypeParser.SwigType_str(swigTypeParser.SwigType_lrtype(curType))} entry${seq} = ${api}${accessor}${tupleAccess[entryIndex]}(); + { + ${helper.getOutConversion(curType,'result',method,[ 'result' : 'pyentry' + seq, 'api' : 'entry' + seq, 'sequence' : sequence ])} + } + PyTuple_SetItem(${result}, ${entryIndex}, pyentry${seq}); + } +<% + } +%> + }
\ No newline at end of file diff --git a/xbmc/interfaces/python/typemaps/python.buffer.intm b/xbmc/interfaces/python/typemaps/python.buffer.intm new file mode 100644 index 0000000..f074b2b --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.buffer.intm @@ -0,0 +1,36 @@ +<% +/* + * 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. + */ +%> + if (PyUnicode_Check(${slarg})) + { + Py_ssize_t pysize; + const char* str = PyUnicode_AsUTF8AndSize(${slarg}, &pysize); + size_t size = static_cast<size_t>(pysize); + ${api}.allocate(size); + ${api}.put(str, size); + ${api}.flip(); // prepare the buffer for reading from + } + else if (PyBytes_Check(${slarg})) + { + Py_ssize_t pysize = PyBytes_GET_SIZE(${slarg}); + const char* str = PyBytes_AS_STRING(${slarg}); + size_t size = static_cast<size_t>(pysize); + ${api}.allocate(size); + ${api}.put(str, size); + ${api}.flip(); // prepare the buffer for reading from + } + else if (PyByteArray_Check(${slarg})) + { + size_t size = PyByteArray_Size(${slarg}); + ${api}.allocate(size); + ${api}.put(PyByteArray_AsString(${slarg}),size); + ${api}.flip(); // prepare the buffer for reading from + } + else + throw XBMCAddon::WrongTypeException("argument \"%s\" for \"%s\" must be a string, bytes or a bytearray", "${api}", "${method.@name}");
\ No newline at end of file diff --git a/xbmc/interfaces/python/typemaps/python.buffer.outtm b/xbmc/interfaces/python/typemaps/python.buffer.outtm new file mode 100644 index 0000000..8e38d81 --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.buffer.outtm @@ -0,0 +1,11 @@ +<% +/* + * 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. + */ + boolean ispointer = swigTypeParser.SwigType_ispointer(type) + String accessor = ispointer ? '->' : '.' +%>${result} = PyByteArray_FromStringAndSize((char*)${api}${accessor}curPosition(),${api}${accessor}remaining());
\ No newline at end of file diff --git a/xbmc/interfaces/python/typemaps/python.dict.intm b/xbmc/interfaces/python/typemaps/python.dict.intm new file mode 100644 index 0000000..ea3c78c --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.dict.intm @@ -0,0 +1,23 @@ +<% +/* + * 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. + */ + List templateArgs = swigTypeParser.SwigType_templateparmlist(ltype) + valtype = templateArgs[0] +%> + { + PyObject *pykey, *pyvalue; + Py_ssize_t pos = 0; + while(PyDict_Next(${slarg}, &pos, &pykey, &pyvalue)) + { + std::string key; + PyXBMCGetUnicodeString(key,pykey,false,"${api}","${method.@name}"); + ${swigTypeParser.SwigType_str(swigTypeParser.SwigType_ltype(valtype))} value; + ${helper.getInConversion(valtype, 'value', 'pyvalue' ,method)} + ${api}.emplace(std::move(key), std::move(value)); + } + }
\ No newline at end of file diff --git a/xbmc/interfaces/python/typemaps/python.map.intm b/xbmc/interfaces/python/typemaps/python.map.intm new file mode 100644 index 0000000..095d23b --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.map.intm @@ -0,0 +1,24 @@ +<% +/* + * 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. + */ + List templateArgs = swigTypeParser.SwigType_templateparmlist(ltype) + keytype = templateArgs[0] + valtype = templateArgs[1] +%> + { + PyObject *pykey, *pyvalue; + Py_ssize_t pos = 0; + while(PyDict_Next(${slarg}, &pos, &pykey, &pyvalue)) + { + ${swigTypeParser.SwigType_str(swigTypeParser.SwigType_ltype(keytype))} key; + ${swigTypeParser.SwigType_str(swigTypeParser.SwigType_ltype(valtype))} value; + ${helper.getInConversion(keytype, 'key', 'pykey', method)} + ${helper.getInConversion(valtype, 'value', 'pyvalue' ,method)} + ${api}.emplace(std::move(key), std::move(value)); + } + }
\ No newline at end of file diff --git a/xbmc/interfaces/python/typemaps/python.smart_ptr.outtm b/xbmc/interfaces/python/typemaps/python.smart_ptr.outtm new file mode 100644 index 0000000..0d7fa31 --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.smart_ptr.outtm @@ -0,0 +1,14 @@ +<% +/* + * 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. + */ + itype = swigTypeParser.SwigType_templateparmlist(type)[0] + pointertype = swigTypeParser.SwigType_makepointer(itype) + int seq = sequence.increment() +%> + ${swigTypeParser.SwigType_str(swigTypeParser.SwigType_ltype(pointertype))} entry${seq} = ${api}.get(); + ${helper.getOutConversion(pointertype,'result',method,[ 'api' : 'entry' + seq, 'sequence' : sequence ])} diff --git a/xbmc/interfaces/python/typemaps/python.string.outtm b/xbmc/interfaces/python/typemaps/python.string.outtm new file mode 100644 index 0000000..f9eb068 --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.string.outtm @@ -0,0 +1,11 @@ +<% +/* + * 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. + */ +%>${result} = <% + if(method.@feature_python_strictUnicode) { %>PyUnicode_DecodeUTF8(${api}.c_str(),${api}.size(),"strict");<% } + else { %>PyUnicode_DecodeUTF8(${api}.c_str(),${api}.size(),"surrogateescape");<% } %> diff --git a/xbmc/interfaces/python/typemaps/python.vector.intm b/xbmc/interfaces/python/typemaps/python.vector.intm new file mode 100644 index 0000000..6bc71ec --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.vector.intm @@ -0,0 +1,36 @@ +<% +/* + * 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. + */ + List templateArgs = swigTypeParser.SwigType_templateparmlist(ltype) + vectype = templateArgs[0] + boolean ispointer = swigTypeParser.SwigType_ispointer(type) + String accessor = ispointer ? '->' : '.' + int seq = sequence.increment() +%> + if (${slarg}) + { + bool isTuple = PyObject_TypeCheck(${slarg},&PyTuple_Type); + if (!isTuple && !PyObject_TypeCheck(${slarg},&PyList_Type)) + throw WrongTypeException("The parameter \"${api}\" must be either a Tuple or a List."); + + <% if (ispointer) print("${api} = new std::vector<${swigTypeParser.SwigType_str(vectype)}>();") %> + PyObject *pyentry${seq} = NULL; + Py_ssize_t vecSize = (isTuple ? PyTuple_Size(${slarg}) : PyList_Size(${slarg})); + ${api}${accessor}reserve(vecSize); + for(Py_ssize_t i = 0; i < vecSize; i++) + { + pyentry${seq} = (isTuple ? PyTuple_GetItem(${slarg}, i) : PyList_GetItem(${slarg}, i)); + ${swigTypeParser.SwigType_str(swigTypeParser.SwigType_ltype(vectype))} entry${seq}; + ${helper.getInConversion(vectype, 'entry' + seq, 'pyentry' + seq, method, + [ 'type' : vectype, + 'ltype' : swigTypeParser.SwigType_ltype(vectype), + 'sequence' : sequence + ])} + ${api}${accessor}push_back(<% if (swigTypeParser.SwigType_ispointer(vectype) || vectype in ["bool", "double", "int"]) { %>entry${seq}<% } else { %>std::move(entry${seq})<% } %>); + } + } diff --git a/xbmc/interfaces/python/typemaps/python.vector.outtm b/xbmc/interfaces/python/typemaps/python.vector.outtm new file mode 100644 index 0000000..c1c4c79 --- /dev/null +++ b/xbmc/interfaces/python/typemaps/python.vector.outtm @@ -0,0 +1,35 @@ +<% +/* + * 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. + */ + List templateArgs = swigTypeParser.SwigType_templateparmlist(type) + vectype = templateArgs[0] + boolean ispointer = swigTypeParser.SwigType_ispointer(type) + String accessor = ispointer ? '->' : '.' + seq = sequence.increment() + + if (ispointer) + { +%> + if (${api} != NULL) + { +<% } %> + ${result} = PyList_New(0); + + for (std::vector<${swigTypeParser.SwigType_str(vectype)}>::iterator iter = ${api}${accessor}begin(); iter != ${api}${accessor}end(); ++iter) + { + PyObject* pyentry${seq}; + ${helper.getOutConversion(vectype,'result',method,[ 'result' : 'pyentry' + seq, 'api' : '(*iter)', 'sequence' : sequence ])} + PyList_Append(${result}, pyentry${seq}); + Py_DECREF(pyentry${seq}); + } +<% + if (ispointer) + { +%> + } +<% } %> |