This repository has been archived by the owner on Apr 15, 2023. It is now read-only.
/
AddonManager.h
179 lines (159 loc) · 6.95 KB
/
AddonManager.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
#pragma once
/*
* Copyright (C) 2005-2009 Team XBMC
* http://www.xbmc.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with XBMC; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#include "Addon.h"
#include "include/xbmc_addon_dll.h"
#include "tinyXML/tinyxml.h"
#include "utils/CriticalSection.h"
#include "StdString.h"
#include "utils/Job.h"
#include "utils/Stopwatch.h"
#include <vector>
#include <map>
#include <deque>
#include "AddonDatabase.h"
class DllLibCPluff;
extern "C"
{
#include "lib/cpluff/libcpluff/cpluff.h"
}
namespace ADDON
{
typedef std::map<TYPE, VECADDONS> MAPADDONS;
typedef std::map<TYPE, VECADDONS>::iterator IMAPADDONS;
typedef std::deque<cp_cfg_element_t*> DEQUEELEMENTS;
typedef std::deque<cp_cfg_element_t*>::iterator IDEQUEELEMENTS;
const CStdString ADDON_METAFILE = "description.xml";
const CStdString ADDON_VIS_EXT = "*.vis";
const CStdString ADDON_PYTHON_EXT = "*.py";
const CStdString ADDON_SCRAPER_EXT = "*.xml";
const CStdString ADDON_SCREENSAVER_EXT = "*.xbs";
const CStdString ADDON_DSP_AUDIO_EXT = "*.adsp";
const CStdString ADDON_VERSION_RE = "(?<Major>\\d*)\\.?(?<Minor>\\d*)?\\.?(?<Build>\\d*)?\\.?(?<Revision>\\d*)?";
/**
* Class - IAddonCallback
* This callback should be inherited by any class which manages
* specific addon types. Could be mostly used for Dll addon types to handle
* cleanup before restart/removal
*/
class IAddonMgrCallback
{
public:
virtual ~IAddonMgrCallback() {};
virtual bool RequestRestart(AddonPtr addon, bool datachanged)=0;
virtual bool RequestRemoval(AddonPtr addon)=0;
};
/**
* Class - CAddonMgr
* Holds references to all addons, enabled or
* otherwise. Services the generic callbacks available
* to all addon variants.
*/
class CAddonMgr
{
public:
static CAddonMgr &Get();
bool Init();
void DeInit();
IAddonMgrCallback* GetCallbackForType(TYPE type);
bool RegisterAddonMgrCallback(TYPE type, IAddonMgrCallback* cb);
void UnregisterAddonMgrCallback(TYPE type);
/* Addon access */
bool GetDefault(const TYPE &type, AddonPtr &addon);
bool SetDefault(const TYPE &type, const CStdString &addonID);
bool GetAddon(const CStdString &str, AddonPtr &addon, const TYPE &type = ADDON_UNKNOWN, bool enabled = true);
bool HasAddons(const TYPE &type, bool enabled = true);
bool GetAddons(const TYPE &type, VECADDONS &addons, bool enabled = true);
bool GetAllAddons(VECADDONS &addons, bool enabled = true, bool allowRepos = false);
/*! \brief Get all addons with available updates
\param addons List to fill with all outdated addons
\param enabled Whether to get only enabled or disabled addons
\return True if there are outdated addons otherwise false
*/
bool GetAllOutdatedAddons(VECADDONS &addons, bool enabled = true);
/*! \brief Checks if there is any addon with available updates
\param enabled Whether to check only enabled or disabled addons
\return True if there are outdated addons otherwise false
*/
bool HasOutdatedAddons(bool enabled = true);
CStdString GetString(const CStdString &id, const int number);
const char *GetTranslatedString(const cp_cfg_element_t *root, const char *tag);
static AddonPtr AddonFromProps(AddonProps& props);
void UpdateRepos();
void FindAddons();
void RemoveAddon(const CStdString& ID);
/* libcpluff */
CStdString GetExtValue(cp_cfg_element_t *base, const char *path);
/*! \brief Retrieve a list of strings from a given configuration element
Assumes the configuration element or attribute contains a whitespace separated list of values (eg xs:list schema).
\param base the base configuration element.
\param path the path to the configuration element or attribute from the base element.
\param result [out] returned list of strings.
\return true if the configuration element is present and the list of strings is non-empty
*/
bool GetExtList(cp_cfg_element_t *base, const char *path, std::vector<CStdString> &result) const;
const cp_extension_t *GetExtension(const cp_plugin_info_t *props, const char *extension) const;
/*! \brief Load the addon in the given path
This loads the addon using c-pluff which parses the addon descriptor file.
\param path folder that contains the addon.
\param addon [out] returned addon.
\return true if addon is set, false otherwise.
*/
bool LoadAddonDescription(const CStdString &path, AddonPtr &addon);
/*! \brief Parse a repository XML file for addons and load their descriptors
A repository XML is essentially a concatenated list of addon descriptors.
\param root Root element of an XML document.
\param addons [out] returned list of addons.
\return true if the repository XML file is parsed, false otherwise.
*/
bool AddonsFromRepoXML(const TiXmlElement *root, VECADDONS &addons);
ADDONDEPS GetDeps(const CStdString& id);
private:
void LoadAddons(const CStdString &path,
std::map<CStdString, AddonPtr>& unresolved);
/* libcpluff */
const cp_cfg_element_t *GetExtElement(cp_cfg_element_t *base, const char *path);
cp_context_t *m_cp_context;
DllLibCPluff *m_cpluff;
/*! \brief Fetch a (single) addon from a plugin descriptor.
Assumes that there is a single (non-trivial) extension point per addon.
\param info the plugin descriptor
\return an AddonPtr based on the descriptor. May be NULL if no suitable extension point is found.
*/
AddonPtr GetAddonFromDescriptor(const cp_plugin_info_t *info);
/*! \brief Check whether this addon is supported on the current platform
\param info the plugin descriptor
\return true if the addon is supported, false otherwise.
*/
bool PlatformSupportsAddon(const cp_plugin_info_t *info) const;
AddonPtr Factory(const cp_extension_t *props);
bool CheckUserDirs(const cp_cfg_element_t *element);
// private construction, and no assignements; use the provided singleton methods
CAddonMgr();
CAddonMgr(const CAddonMgr&);
CAddonMgr const& operator=(CAddonMgr const&);
virtual ~CAddonMgr();
static std::map<TYPE, IAddonMgrCallback*> m_managers;
CStopWatch m_watch;
CCriticalSection m_critSection;
CAddonDatabase m_database;
};
}; /* namespace ADDON */