JSONRPC_STATUS CAddonsOperations::GetAddons(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
vector<TYPE> addonTypes;
TYPE addonType = TranslateType(parameterObject["type"].asString());
CVariant enabled = parameterObject["enabled"];
addonTypes.push_back(addonType);
VECADDONS addons;
for (vector<TYPE>::const_iterator typeIt = addonTypes.begin(); typeIt != addonTypes.end(); ++typeIt)
{
VECADDONS typeAddons;
if (*typeIt == ADDON_UNKNOWN)
{
if (!enabled.isBoolean())
{
CAddonMgr::GetInstance().GetAllAddons(typeAddons, false);
CAddonMgr::GetInstance().GetAllAddons(typeAddons, true);
}
else
CAddonMgr::GetInstance().GetAllAddons(typeAddons, enabled.asBoolean());
}
else
{
if (!enabled.isBoolean())
{
CAddonMgr::GetInstance().GetAddons(*typeIt, typeAddons, false);
VECADDONS enabledAddons;
CAddonMgr::GetInstance().GetAddons(*typeIt, enabledAddons, true);
typeAddons.insert(typeAddons.end(), enabledAddons.begin(), enabledAddons.end());
}
else
CAddonMgr::GetInstance().GetAddons(*typeIt, typeAddons, enabled.asBoolean());
}
addons.insert(addons.end(), typeAddons.begin(), typeAddons.end());
}
// remove library addons
for (int index = 0; index < (int)addons.size(); index++)
{
if ((addons.at(index)->Type() <= ADDON_UNKNOWN || addons.at(index)->Type() >= ADDON_MAX))
{
addons.erase(addons.begin() + index);
index--;
}
}
int start, end;
HandleLimits(parameterObject, result, addons.size(), start, end);
CAddonDatabase addondb;
for (int index = start; index < end; index++)
FillDetails(addons.at(index), parameterObject["properties"], result["addons"], addondb, true);
return OK;
}
bool CAddonMgr::GetAddons(const TYPE &type, VECADDONS &addons, bool enabled /* = true */)
{
CSingleLock lock(m_critSection);
addons.clear();
if (!m_cp_context)
return false;
cp_status_t status;
int num;
std::string ext_point(TranslateType(type));
cp_extension_t **exts = m_cpluff->get_extensions_info(m_cp_context, ext_point.c_str(), &status, &num);
for(int i=0; i <num; i++)
{
const cp_extension_t *props = exts[i];
if (IsAddonDisabled(props->plugin->identifier) != enabled)
{
AddonPtr addon(Factory(props));
if (addon)
{
if (enabled)
{
// if the addon has a running instance, grab that
AddonPtr runningAddon = addon->GetRunningInstance();
if (runningAddon)
addon = runningAddon;
}
addons.push_back(addon);
}
}
}
m_cpluff->release_info(m_cp_context, exts);
return addons.size() > 0;
}
bool CAddonsDirectory::GetScriptsAndPlugins(const CStdString &content, CFileItemList &items)
{
items.Clear();
VECADDONS addons;
if (!GetScriptsAndPlugins(content, addons))
return false;
for (unsigned i=0; i<addons.size(); i++)
{
CFileItemPtr item(FileItemFromAddon(addons[i],
addons[i]->Type()==ADDON_PLUGIN?"plugin://":"script://",
addons[i]->Type() == ADDON_PLUGIN));
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(addons[i]);
if (plugin->ProvidesSeveral())
{
CURL url = item->GetAsUrl();
CStdString opt;
opt.Format("?content_type=%s",content.c_str());
url.SetOptions(opt);
item->SetPath(url.Get());
}
items.Add(item);
}
items.Add(GetMoreItem(content));
items.SetContent("addons");
items.SetLabel(g_localizeStrings.Get(24001)); // Add-ons
return items.Size() > 0;
}
int CAddonDatabase::AddRepository(const std::string& id, const VECADDONS& addons, const std::string& checksum, const AddonVersion& version)
{
try
{
if (NULL == m_pDB.get()) return -1;
if (NULL == m_pDS.get()) return -1;
std::string sql;
int idRepo = GetRepoChecksum(id,sql);
if (idRepo > -1)
DeleteRepository(idRepo);
BeginTransaction();
CDateTime time = CDateTime::GetCurrentDateTime();
sql = PrepareSQL("insert into repo (id,addonID,checksum,lastcheck,version) values (NULL,'%s','%s','%s','%s')",
id.c_str(), checksum.c_str(), time.GetAsDBDateTime().c_str(), version.asString().c_str());
m_pDS->exec(sql.c_str());
idRepo = (int)m_pDS->lastinsertid();
for (unsigned int i=0;i<addons.size();++i)
AddAddon(addons[i],idRepo);
CommitTransaction();
return idRepo;
}
catch (...)
{
CLog::Log(LOGERROR, "%s failed on repo '%s'", __FUNCTION__, id.c_str());
RollbackTransaction();
}
return -1;
}
void CAddonsDirectory::GenerateListing(CURL &path, VECADDONS& addons, CFileItemList &items, bool reposAsFolders)
{
CStdString xbmcPath = CSpecialProtocol::TranslatePath("special://xbmc/addons");
items.ClearItems();
CAddonDatabase db;
db.Open();
for (unsigned i=0; i < addons.size(); i++)
{
AddonPtr addon = addons[i];
CFileItemPtr pItem;
if (reposAsFolders && addon->Type() == ADDON_REPOSITORY)
pItem = FileItemFromAddon(addon, "addons://", true);
else
pItem = FileItemFromAddon(addon, path.Get(), false);
AddonPtr addon2;
if (CAddonMgr::Get().GetAddon(addon->ID(),addon2))
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(305));
else if (db.IsOpen() && db.IsAddonDisabled(addon->ID()))
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(24023));
if (!addon->Props().broken.IsEmpty())
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(24098));
if (addon2 && addon2->Version() < addon->Version())
{
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(24068));
pItem->SetProperty("Addon.UpdateAvail", true);
}
CAddonDatabase::SetPropertiesFromAddon(addon,pItem);
items.Add(pItem);
}
db.Close();
}
bool CAddonMgr::GetAllOutdatedAddons(VECADDONS &addons, bool enabled /*= true*/)
{
CSingleLock lock(m_critSection);
for (int i = ADDON_UNKNOWN+1; i < ADDON_VIZ_LIBRARY; ++i)
{
VECADDONS temp;
if (CAddonMgr::Get().GetAddons((TYPE)i, temp, enabled))
{
AddonPtr repoAddon;
for (unsigned int j = 0; j < temp.size(); j++)
{
// Ignore duplicates due to add-ons with multiple extension points
bool found = false;
for (VECADDONS::const_iterator addonIt = addons.begin(); addonIt != addons.end(); addonIt++)
{
if ((*addonIt)->ID() == temp[j]->ID())
found = true;
}
if (found || !m_database.GetAddon(temp[j]->ID(), repoAddon))
continue;
if (temp[j]->Version() < repoAddon->Version() &&
!m_database.IsAddonBlacklisted(temp[j]->ID(),
repoAddon->Version().c_str()))
addons.push_back(repoAddon);
}
}
}
return !addons.empty();
}
bool CAddonMgr::GetAddons(const TYPE &type, VECADDONS &addons, bool enabled /* = true */)
{
CSingleLock lock(m_critSection);
addons.clear();
cp_status_t status;
int num;
CStdString ext_point(TranslateType(type));
cp_extension_t **exts = m_cpluff->get_extensions_info(m_cp_context, ext_point.c_str(), &status, &num);
for(int i=0; i <num; i++)
{
const cp_extension_t *props = exts[i];
if (m_database.IsAddonDisabled(props->plugin->identifier) != enabled)
{
// get a pointer to a running pvrclient if it's already started, or we won't be able to change settings
if (TranslateType(props->ext_point_id) == ADDON_PVRDLL &&
enabled &&
g_PVRManager.IsStarted())
{
AddonPtr pvrAddon;
if (g_PVRClients->GetClient(props->plugin->identifier, pvrAddon))
{
addons.push_back(pvrAddon);
continue;
}
}
AddonPtr addon(Factory(props));
if (addon)
addons.push_back(addon);
}
}
m_cpluff->release_info(m_cp_context, exts);
return addons.size() > 0;
}
bool CDVDInputStreamTV::Open(const char* strFile, const std::string& content)
{
if (!CDVDInputStream::Open(strFile, content)) return false;
CURL url(strFile);
std::string strProtocol = url.GetProtocol();
StringUtils::ToLower(strProtocol);
if (!strProtocol.empty())
{
VECADDONS addons;
CAddonMgr::Get().GetAddons(ADDON_VFS, addons);
for (size_t i=0;i<addons.size();++i)
{
VFSEntryPtr vfs(std::static_pointer_cast<CVFSEntry>(addons[i]));
if (vfs->HasLiveTV() && vfs->GetProtocols().find(strProtocol) != std::string::npos)
{
CVFSEntryILiveTVWrapper* wrap = new CVFSEntryILiveTVWrapper(CVFSEntryManager::Get().GetAddon(vfs->ID()));
m_pFile = wrap;
m_pLiveTV = wrap;
m_pRecordable = NULL;
}
}
}
// open file in binary mode
if (!m_pFile->Open(url))
{
delete m_pFile;
m_pFile = NULL;
return false;
}
m_eof = false;
return true;
}
void CRepositoryUpdater::OnJobComplete(unsigned int jobID, bool success, CJob* job)
{
CSingleLock lock(m_criticalSection);
m_jobs.erase(std::find(m_jobs.begin(), m_jobs.end(), job));
if (m_jobs.empty())
{
CLog::Log(LOGDEBUG, "CRepositoryUpdater: done.");
m_doneEvent.Set();
if (CSettings::GetInstance().GetInt(CSettings::SETTING_GENERAL_ADDONUPDATES) == AUTO_UPDATES_NOTIFY)
{
VECADDONS hasUpdate;
if (CAddonMgr::GetInstance().GetAllOutdatedAddons(hasUpdate) && !hasUpdate.empty())
{
if (hasUpdate.size() == 1)
CGUIDialogKaiToast::QueueNotification(
hasUpdate[0]->Icon(), hasUpdate[0]->Name(), g_localizeStrings.Get(24068),
TOAST_DISPLAY_TIME, false, TOAST_DISPLAY_TIME);
else
CGUIDialogKaiToast::QueueNotification(
"", g_localizeStrings.Get(24001), g_localizeStrings.Get(24061),
TOAST_DISPLAY_TIME, false, TOAST_DISPLAY_TIME);
}
}
if (CSettings::GetInstance().GetInt(CSettings::SETTING_GENERAL_ADDONUPDATES) == AUTO_UPDATES_ON)
CAddonInstaller::GetInstance().InstallUpdates();
ScheduleUpdate();
CGUIMessage msg(GUI_MSG_NOTIFY_ALL, 0, 0, GUI_MSG_UPDATE);
g_windowManager.SendThreadMessage(msg);
}
}
bool CAddonMgr::GetAddons(const TYPE &type, VECADDONS &addons, bool enabled /* = true */, bool bGetDisabledPVRAddons /* = true */)
{
CStdString xbmcPath = CSpecialProtocol::TranslatePath("special://xbmc/addons");
CSingleLock lock(m_critSection);
addons.clear();
cp_status_t status;
int num;
CStdString ext_point(TranslateType(type));
cp_extension_t **exts = m_cpluff->get_extensions_info(m_cp_context, ext_point.c_str(), &status, &num);
for(int i=0; i <num; i++)
{
const cp_extension_t *props = exts[i];
bool bIsPVRAddon(TranslateType(props->ext_point_id) == ADDON_PVRDLL);
if (((bGetDisabledPVRAddons && bIsPVRAddon) || m_database.IsAddonDisabled(props->plugin->identifier) != enabled))
{
if (bIsPVRAddon && g_PVRManager.IsStarted())
{
AddonPtr pvrAddon;
if (g_PVRClients->GetClient(props->plugin->identifier, pvrAddon))
{
addons.push_back(pvrAddon);
continue;
}
}
AddonPtr addon(Factory(props));
if (addon)
addons.push_back(addon);
}
}
m_cpluff->release_info(m_cp_context, exts);
return addons.size() > 0;
}
void CAddonsDirectory::GenerateListing(CURL &path, VECADDONS& addons, CFileItemList &items, bool reposAsFolders)
{
items.ClearItems();
for (unsigned i=0; i < addons.size(); i++)
{
AddonPtr addon = addons[i];
CFileItemPtr pItem;
if (reposAsFolders && addon->Type() == ADDON_REPOSITORY)
pItem = FileItemFromAddon(addon, "addons://", true);
else
pItem = FileItemFromAddon(addon, path.Get(), false);
AddonPtr addon2;
if (CAddonMgr::Get().GetAddon(addon->ID(),addon2))
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(305));
else if (CAddonMgr::Get().IsAddonDisabled(addon->ID()))
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(24023));
if (addon->Props().broken == "DEPSNOTMET")
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(24049));
else if (!addon->Props().broken.empty())
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(24098));
if (addon2 && addon2->Version() < addon->Version())
{
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(24068));
pItem->SetProperty("Addon.UpdateAvail", true);
}
CAddonDatabase::SetPropertiesFromAddon(addon,pItem);
items.Add(pItem);
}
}
void CAddonsDirectory::GenerateListing(CURL &path, VECADDONS& addons, CFileItemList &items, bool reposAsFolders)
{
CStdString xbmcPath = _P("special://xbmc/addons");
items.ClearItems();
for (unsigned i=0; i < addons.size(); i++)
{
AddonPtr addon = addons[i];
CFileItemPtr pItem;
if (reposAsFolders && addon->Type() == ADDON_REPOSITORY)
pItem = FileItemFromAddon(addon, "addons://", true);
else
pItem = FileItemFromAddon(addon, path.Get(), false);
AddonPtr addon2;
if (CAddonMgr::Get().GetAddon(addon->ID(),addon2))
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(305));
else if ((addon->Type() == ADDON_PVRDLL) && (CStdString(pItem->GetProperty("Addon.Path").asString()).Left(xbmcPath.size()).Equals(xbmcPath)))
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(24023));
if (!addon->Props().broken.IsEmpty())
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(24098));
if (addon2 && addon2->Version() < addon->Version())
{
pItem->SetProperty("Addon.Status",g_localizeStrings.Get(24068));
pItem->SetProperty("Addon.UpdateAvail", true);
}
CAddonDatabase::SetPropertiesFromAddon(addon,pItem);
items.Add(pItem);
}
}
bool CAddonsDirectory::GetScriptsAndPlugins(const CStdString &content, CFileItemList &items)
{
items.Clear();
CPluginSource::Content type = CPluginSource::Translate(content);
if (type == CPluginSource::UNKNOWN)
return false;
VECADDONS addons;
CAddonMgr::Get().GetAddons(ADDON_PLUGIN, addons);
for (unsigned i=0; i<addons.size(); i++)
{
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(addons[i]);
if (!plugin || !plugin->Provides(type))
continue;
items.Add(FileItemFromAddon(addons[i], "plugin://", true));
}
addons.clear();
CAddonMgr::Get().GetAddons(ADDON_SCRIPT, addons);
for (unsigned i=0; i<addons.size(); i++)
{
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(addons[i]);
if (!plugin || !plugin->Provides(type))
continue;
items.Add(FileItemFromAddon(addons[i], "script://", false));
}
CFileItemPtr item(new CFileItem("addons://more/"+content,false));
item->SetLabelPreformated(true);
item->SetLabel(g_localizeStrings.Get(21452));
item->SetIconImage("DefaultAddon.png");
item->SetSpecialSort(SORT_ON_BOTTOM);
items.Add(item);
items.SetContent("addons");
return items.Size() > 0;
}
CDateTime CAddonInstaller::LastRepoUpdate() const
{
CDateTime update;
VECADDONS addons;
CAddonMgr::Get().GetAddons(ADDON_REPOSITORY,addons);
for (unsigned int i=0;i<addons.size();++i)
{
CAddonDatabase database;
database.Open();
CDateTime lastUpdate = database.GetRepoTimestamp(addons[i]->ID());
if (lastUpdate.IsValid() && lastUpdate > update)
update = lastUpdate;
}
return update;
}
bool CAddonsDirectory::GetScriptsAndPlugins(const CStdString &content, VECADDONS &addons)
{
CPluginSource::Content type = CPluginSource::Translate(content);
if (type == CPluginSource::UNKNOWN)
return false;
VECADDONS tempAddons;
CAddonMgr::Get().GetAddons(ADDON_PLUGIN, tempAddons);
for (unsigned i=0; i<tempAddons.size(); i++)
{
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(tempAddons[i]);
if (plugin && plugin->Provides(type))
addons.push_back(tempAddons[i]);
}
tempAddons.clear();
CAddonMgr::Get().GetAddons(ADDON_SCRIPT, tempAddons);
for (unsigned i=0; i<tempAddons.size(); i++)
{
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(tempAddons[i]);
if (plugin && plugin->Provides(type))
addons.push_back(tempAddons[i]);
}
return true;
}
void CNfoFile::AddScrapers(VECADDONS& addons,
vector<ScraperPtr>& vecScrapers)
{
for (unsigned i=0;i<addons.size();++i)
{
ScraperPtr scraper = boost::dynamic_pointer_cast<CScraper>(addons[i]);
// skip if scraper requires settings and there's nothing set yet
if (scraper->RequiresSettings() && !scraper->HasUserSettings())
continue;
// add same language and multi-language
if (scraper->Language() == m_info->Language() || scraper->Language().Equals("multi"))
vecScrapers.push_back(scraper);
}
}
bool CAddonMgr::GetAddons(const TYPE &type, VECADDONS &addons, bool enabled /* = true */)
{
CSingleLock lock(m_critSection);
addons.clear();
cp_status_t status;
int num;
CStdString ext_point(TranslateType(type));
cp_extension_t **exts = m_cpluff->get_extensions_info(m_cp_context, ext_point.c_str(), &status, &num);
for(int i=0; i <num; i++)
{
AddonPtr addon(Factory(exts[i]));
if (addon && m_database.IsAddonDisabled(addon->ID()) != enabled)
addons.push_back(addon);
}
m_cpluff->release_info(m_cp_context, exts);
return addons.size() > 0;
}
void CRepositoryUpdater::OnJobComplete(unsigned int jobID, bool success, CJob* job)
{
CSingleLock lock(m_criticalSection);
m_jobs.erase(std::find(m_jobs.begin(), m_jobs.end(), job));
if (m_jobs.empty())
{
CLog::Log(LOGDEBUG, "CRepositoryUpdater: done.");
m_doneEvent.Set();
VECADDONS updates = CAddonMgr::GetInstance().GetAvailableUpdates();
if (CSettings::GetInstance().GetInt(CSettings::SETTING_ADDONS_AUTOUPDATES) == AUTO_UPDATES_NOTIFY)
{
if (!updates.empty())
{
if (updates.size() == 1)
CGUIDialogKaiToast::QueueNotification(
updates[0]->Icon(), updates[0]->Name(), g_localizeStrings.Get(24068),
TOAST_DISPLAY_TIME, false, TOAST_DISPLAY_TIME);
else
CGUIDialogKaiToast::QueueNotification(
"", g_localizeStrings.Get(24001), g_localizeStrings.Get(24061),
TOAST_DISPLAY_TIME, false, TOAST_DISPLAY_TIME);
for (const auto &addon : updates)
CEventLog::GetInstance().Add(EventPtr(new CAddonManagementEvent(addon, 24068)));
}
}
if (CSettings::GetInstance().GetInt(CSettings::SETTING_ADDONS_AUTOUPDATES) == AUTO_UPDATES_ON)
{
for (const auto& addon : updates)
{
if (!CAddonMgr::GetInstance().IsBlacklisted(addon->ID()))
CAddonInstaller::GetInstance().InstallOrUpdate(addon->ID());
}
}
ScheduleUpdate();
m_events.Publish(RepositoryUpdated{});
}
}
bool CGUIDialogAddonInfo::SetItem(const CFileItemPtr& item)
{
*m_item = *item;
m_rollbackVersions.clear();
// grab the local addon, if it's available
m_localAddon.reset();
m_addon.reset();
if (CAddonMgr::Get().GetAddon(item->GetProperty("Addon.ID").asString(), m_localAddon)) // sets m_addon if installed regardless of enabled state
m_item->SetProperty("Addon.Enabled", "true");
else
m_item->SetProperty("Addon.Enabled", "false");
m_item->SetProperty("Addon.Installed", m_addon ? "true" : "false");
CAddonDatabase database;
database.Open();
database.GetAddon(item->GetProperty("Addon.ID").asString(),m_addon);
if (TranslateType(item->GetProperty("Addon.intType").asString()) == ADDON_REPOSITORY)
{
CAddonDatabase database;
database.Open();
VECADDONS addons;
if (m_addon)
database.GetRepository(m_addon->ID(), addons);
else if (m_localAddon) // sanity
database.GetRepository(m_localAddon->ID(), addons);
int tot=0;
for (int i = ADDON_UNKNOWN+1;i<ADDON_VIZ_LIBRARY;++i)
{
int num=0;
for (unsigned int j=0;j<addons.size();++j)
{
if (addons[j]->Type() == (TYPE)i)
++num;
}
m_item->SetProperty(CStdString("Repo.") + TranslateType((TYPE)i), num);
tot += num;
}
m_item->SetProperty("Repo.Addons", tot);
}
return true;
}
void CAddonMgr::UpdateRepos(bool force)
{
CSingleLock lock(m_critSection);
if (!force && m_watch.IsRunning() && m_watch.GetElapsedSeconds() < 600)
return;
m_watch.StartZero();
VECADDONS addons;
GetAddons(ADDON_REPOSITORY,addons);
for (unsigned int i=0;i<addons.size();++i)
{
RepositoryPtr repo = boost::dynamic_pointer_cast<CRepository>(addons[i]);
CDateTime lastUpdate = m_database.GetRepoTimestamp(repo->ID());
if (force || !lastUpdate.IsValid() || lastUpdate + CDateTimeSpan(0,6,0,0) < CDateTime::GetCurrentDateTime())
{
CLog::Log(LOGDEBUG,"Checking repository %s for updates",repo->Name().c_str());
CJobManager::GetInstance().AddJob(new CRepositoryUpdateJob(repo), NULL);
}
}
}
ICodec* CodecFactory::CreateCodec(const CStdString& strFileType)
{
VECADDONS codecs;
CAddonMgr::Get().GetAddons(ADDON_AUDIODECODER, codecs);
for (size_t i=0;i<codecs.size();++i)
{
boost::shared_ptr<CAudioDecoder> dec(boost::static_pointer_cast<CAudioDecoder>(codecs[i]));
if (dec->GetExtensions().find("."+strFileType) != std::string::npos)
{
CAudioDecoder* result = new CAudioDecoder(*dec);
static_cast<AudioDecoderDll&>(*result).Create();
return result;
}
}
if (strFileType.Equals("pcm") || strFileType.Equals("l16"))
return new PCMCodec();
return new DVDPlayerCodec();
}
bool CAddonMgr::GetAllOutdatedAddons(VECADDONS &addons, bool enabled /*= true*/)
{
CSingleLock lock(m_critSection);
for (int i = ADDON_UNKNOWN+1; i < ADDON_VIZ_LIBRARY; ++i)
{
VECADDONS temp;
if (CAddonMgr::Get().GetAddons((TYPE)i, temp, enabled))
{
AddonPtr repoAddon;
for (unsigned int j = 0; j < temp.size(); j++)
{
if (!m_database.GetAddon(temp[j]->ID(), repoAddon))
continue;
if (temp[j]->Version() < repoAddon->Version())
addons.push_back(repoAddon);
}
}
}
return !addons.empty();
}
ICodec* CodecFactory::CreateCodec(const std::string &strFileType)
{
std::string fileType = strFileType;
StringUtils::ToLower(fileType);
VECADDONS codecs;
CAddonMgr::GetInstance().GetAddons(ADDON_AUDIODECODER, codecs);
for (size_t i=0;i<codecs.size();++i)
{
std::shared_ptr<CAudioDecoder> dec(std::static_pointer_cast<CAudioDecoder>(codecs[i]));
std::vector<std::string> exts = StringUtils::Split(dec->GetExtensions(), "|");
if (std::find(exts.begin(), exts.end(), "."+fileType) != exts.end())
{
CAudioDecoder* result = new CAudioDecoder(*dec);
static_cast<AudioDecoderDll&>(*result).Create();
return result;
}
}
VideoPlayerCodec *dvdcodec = new VideoPlayerCodec();
return dvdcodec;
}
void CAddonInstaller::UpdateRepos(bool force, bool wait)
{
CSingleLock lock(m_critSection);
if (m_repoUpdateJob)
{
if (wait)
{ // wait for our job to complete
lock.Leave();
CLog::Log(LOGDEBUG, "%s - waiting for repository update job to finish...", __FUNCTION__);
m_repoUpdateDone.Wait();
}
return;
}
// don't run repo update jobs while on the login screen which runs under the master profile
if((g_windowManager.GetActiveWindow() & WINDOW_ID_MASK) == WINDOW_LOGIN_SCREEN)
return;
if (!force && m_repoUpdateWatch.IsRunning() && m_repoUpdateWatch.GetElapsedSeconds() < 600)
return;
m_repoUpdateWatch.StartZero();
VECADDONS addons;
CAddonMgr::Get().GetAddons(ADDON_REPOSITORY,addons);
for (unsigned int i=0;i<addons.size();++i)
{
CAddonDatabase database;
database.Open();
CDateTime lastUpdate = database.GetRepoTimestamp(addons[i]->ID());
if (force || !lastUpdate.IsValid() || lastUpdate + CDateTimeSpan(0,6,0,0) < CDateTime::GetCurrentDateTime())
{
CLog::Log(LOGDEBUG,"Checking repositories for updates (triggered by %s)",addons[i]->Name().c_str());
m_repoUpdateJob = CJobManager::GetInstance().AddJob(new CRepositoryUpdateJob(addons), this);
if (wait)
{ // wait for our job to complete
lock.Leave();
CLog::Log(LOGDEBUG, "%s - waiting for this repository update job to finish...", __FUNCTION__);
m_repoUpdateDone.Wait();
}
return;
}
}
}
bool CAddonsDirectory::GetScriptsAndPlugins(const CStdString &content, CFileItemList &items)
{
items.Clear();
VECADDONS addons;
if (!GetScriptsAndPlugins(content, addons))
return false;
for (unsigned i=0; i<addons.size(); i++)
{
if (addons[i]->Type() == ADDON_PLUGIN)
items.Add(FileItemFromAddon(addons[i], "plugin://", true));
else
items.Add(FileItemFromAddon(addons[i], "script://", false));
}
items.Add(GetMoreItem(content));
items.SetContent("addons");
items.SetLabel(g_localizeStrings.Get(24001)); // Add-ons
return items.Size() > 0;
}
bool CAddonMgr::GetAddons(const TYPE &type, VECADDONS &addons, bool enabled /* = true */)
{
CStdString xbmcPath = _P("special://xbmc/addons");
CSingleLock lock(m_critSection);
addons.clear();
cp_status_t status;
int num;
CStdString ext_point(TranslateType(type));
cp_extension_t **exts = m_cpluff->get_extensions_info(m_cp_context, ext_point.c_str(), &status, &num);
for(int i=0; i <num; i++)
{
AddonPtr addon(Factory(exts[i]));
if (addon && addon->Type() == ADDON_PVRDLL && addon->Path().Left(xbmcPath.size()).Equals(xbmcPath))
{
if (m_database.IsSystemPVRAddonEnabled(addon->ID()) != enabled)
addon->Disable();
}
if (addon && m_database.IsAddonDisabled(addon->ID()) != enabled)
addons.push_back(addon);
}
m_cpluff->release_info(m_cp_context, exts);
return addons.size() > 0;
}
bool CPVRClients::LoadClients(void)
{
if (m_bAllClientsLoaded)
return !m_clientMap.empty();
CAddonMgr::Get().RegisterAddonMgrCallback(ADDON_PVRDLL, this);
/* get all PVR addons */
VECADDONS addons;
if (!CAddonMgr::Get().GetAddons(ADDON_PVRDLL, addons, true))
return false;
/* load and initialise the clients */
CPVRDatabase *database = CPVRManager::Get()->GetTVDatabase();
if (!database || !database->Open())
{
CLog::Log(LOGERROR, "PVR - %s - cannot open the database", __FUNCTION__);
return false;
}
m_bAllClientsLoaded = true;
for (unsigned iClientPtr = 0; iClientPtr < addons.size(); iClientPtr++)
{
const AddonPtr clientAddon = addons.at(iClientPtr);
if (!clientAddon->Enabled())
continue;
int iClientId = AddClientToDb(clientAddon->ID(), clientAddon->Name());
if (iClientId == -1)
continue; // don't set "m_bAllClientsLoaded = false;" here because this will enter a neverending loop
/* check if this client isn't active already */
if (ClientLoaded(clientAddon->ID()))
continue;
/* load and initialise the client libraries */
boost::shared_ptr<CPVRClient> addon = boost::dynamic_pointer_cast<CPVRClient>(clientAddon);
if (addon && addon->Create(iClientId, this))
{
/* get the client's properties */
PVR_SERVERPROPS props;
if (addon->GetProperties(&props) == PVR_ERROR_NO_ERROR)
{
m_clientMap.insert(std::make_pair(iClientId, addon));
m_clientsProps.insert(std::make_pair(iClientId, props));
}
else
{
CLog::Log(LOGERROR, "PVR - %s - can't get client properties from addon '%s'",
__FUNCTION__, clientAddon->Name().c_str());
m_bAllClientsLoaded = false;
}
}
else
{
CLog::Log(LOGERROR, "PVR - %s - can't initialise client '%s'",
__FUNCTION__, clientAddon->Name().c_str());
m_bAllClientsLoaded = false;
}
}
database->Close();
return !m_clientMap.empty();
}
ICodec* CodecFactory::CreateCodecDemux(const std::string& strFile, const std::string& strContent, unsigned int filecache)
{
CURL urlFile(strFile);
std::string content = strContent;
StringUtils::ToLower(content);
if (!content.empty())
{
VECADDONS codecs;
CAddonMgr::GetInstance().GetAddons(ADDON_AUDIODECODER, codecs);
for (size_t i=0;i<codecs.size();++i)
{
std::shared_ptr<CAudioDecoder> dec(std::static_pointer_cast<CAudioDecoder>(codecs[i]));
std::vector<std::string> mime = StringUtils::Split(dec->GetMimetypes(), "|");
if (std::find(mime.begin(), mime.end(), content) != mime.end())
{
CAudioDecoder* result = new CAudioDecoder(*dec);
static_cast<AudioDecoderDll&>(*result).Create();
return result;
}
}
}
if( content == "audio/mpeg" ||
content == "audio/mpeg3" ||
content == "audio/mp3" ||
content == "audio/aac" ||
content == "audio/aacp" ||
content == "audio/x-ms-wma" ||
content == "audio/x-ape" ||
content == "audio/ape" ||
content == "application/ogg" ||
content == "audio/ogg" ||
content == "audio/x-xbmc-pcm" ||
content == "audio/flac" ||
content == "audio/x-flac" ||
content == "application/x-flac"
)
{
VideoPlayerCodec *dvdcodec = new VideoPlayerCodec();
dvdcodec->SetContentType(content);
return dvdcodec;
}
else if (urlFile.IsProtocol("shout"))
{
VideoPlayerCodec *dvdcodec = new VideoPlayerCodec();
dvdcodec->SetContentType("audio/mp3");
return dvdcodec; // if we got this far with internet radio - content-type was wrong. gamble on mp3.
}
else if (urlFile.IsFileType("wav") ||
content == "audio/wav" ||
content == "audio/x-wav")
{
VideoPlayerCodec *dvdcodec = new VideoPlayerCodec();
dvdcodec->SetContentType("audio/x-spdif-compressed");
if (dvdcodec->Init(strFile, filecache))
{
return dvdcodec;
}
dvdcodec = new VideoPlayerCodec();
dvdcodec->SetContentType(content);
return dvdcodec;
}
else
return CreateCodec(urlFile.GetFileType());
}
/*!
\brief Create a IDirectory object of the share type specified in \e strPath .
\param strPath Specifies the share type to access, can be a share or share with path.
\return IDirectory object to access the directories on the share.
\sa IDirectory
*/
IDirectory* CDirectoryFactory::Create(const CStdString& strPath)
{
CURL url(strPath);
if (!CWakeOnAccess::Get().WakeUpHost(url))
return NULL;
CFileItem item(strPath, false);
IFileDirectory* pDir=CFileDirectoryFactory::Create(strPath, &item);
if (pDir)
return pDir;
CStdString strProtocol = url.GetProtocol();
if (!strProtocol.empty())
{
VECADDONS addons;
CAddonMgr::Get().GetAddons(ADDON_VFS, addons);
for (size_t i=0;i<addons.size();++i)
{
VFSEntryPtr vfs(boost::static_pointer_cast<CVFSEntry>(addons[i]));
if (vfs->HasDirectories() && vfs->GetProtocols().find(strProtocol) != std::string::npos)
return new CVFSEntryIDirectoryWrapper(CVFSEntryManager::Get().GetAddon(vfs->ID()));
}
}
if (strProtocol.size() == 0 || strProtocol == "file") return new CHDDirectory();
if (strProtocol == "special") return new CSpecialProtocolDirectory();
if (strProtocol == "sources") return new CSourcesDirectory();
if (strProtocol == "addons") return new CAddonsDirectory();
#if defined(HAS_FILESYSTEM_CDDA) && defined(HAS_DVD_DRIVE)
if (strProtocol == "cdda") return new CCDDADirectory();
#endif
#ifdef HAS_FILESYSTEM
if (strProtocol == "iso9660") return new CISO9660Directory();
#endif
if (strProtocol == "udf") return new CUDFDirectory();
if (strProtocol == "plugin") return new CPluginDirectory();
#if defined(TARGET_ANDROID)
if (strProtocol == "apk") return new CAPKDirectory();
#endif
if (strProtocol == "zip") return new CZipDirectory();
if (strProtocol == "multipath") return new CMultiPathDirectory();
if (strProtocol == "stack") return new CStackDirectory();
if (strProtocol == "playlistmusic") return new CPlaylistDirectory();
if (strProtocol == "playlistvideo") return new CPlaylistDirectory();
if (strProtocol == "musicdb") return new CMusicDatabaseDirectory();
if (strProtocol == "musicsearch") return new CMusicSearchDirectory();
if (strProtocol == "videodb") return new CVideoDatabaseDirectory();
if (strProtocol == "library") return new CLibraryDirectory();
if (strProtocol == "favourites") return new CFavouritesDirectory();
if (strProtocol == "filereader")
return CDirectoryFactory::Create(url.GetFileName());
#if defined(TARGET_ANDROID)
if (strProtocol == "androidapp") return new CAndroidAppDirectory();
#endif
if( g_application.getNetwork().IsAvailable(true) ) // true to wait for the network (if possible)
{
if (strProtocol == "tuxbox") return new CTuxBoxDirectory();
if (strProtocol == "ftp" || strProtocol == "ftps") return new CFTPDirectory();
if (strProtocol == "http" || strProtocol == "https") return new CHTTPDirectory();
if (strProtocol == "dav" || strProtocol == "davs") return new CDAVDirectory();
#ifdef HAS_FILESYSTEM_SMB
#ifdef TARGET_WINDOWS
if (strProtocol == "smb") return new CWINSMBDirectory();
#else
if (strProtocol == "smb") return new CSMBDirectory();
#endif
#endif
#ifdef HAS_FILESYSTEM
#ifdef HAS_FILESYSTEM_DAAP
if (strProtocol == "daap") return new CDAAPDirectory();
#endif
#endif
#ifdef HAS_UPNP
if (strProtocol == "upnp") return new CUPnPDirectory();
#endif
if (strProtocol == "myth") return new CMythDirectory();
if (strProtocol == "cmyth") return new CMythDirectory();
if (strProtocol == "rss") return new CRSSDirectory();
#ifdef HAS_FILESYSTEM_SAP
if (strProtocol == "sap") return new CSAPDirectory();
#endif
#ifdef HAS_FILESYSTEM_HTSP
if (strProtocol == "htsp") return new CHTSPDirectory();
#endif
#ifdef HAS_PVRCLIENTS
if (strProtocol == "pvr") return new CPVRDirectory();
#endif
#ifdef HAS_ZEROCONF
if (strProtocol == "zeroconf") return new CZeroconfDirectory();
#endif
#ifdef HAVE_LIBBLURAY
if (strProtocol == "bluray") return new CBlurayDirectory();
#endif
}
CLog::Log(LOGWARNING, "%s - Unsupported protocol(%s) in %s", __FUNCTION__, strProtocol.c_str(), url.Get().c_str() );
return NULL;
}
ICodec* CodecFactory::CreateCodecDemux(const CStdString& strFile, const CStdString& strContent, unsigned int filecache)
{
CURL urlFile(strFile);
if (!strContent.empty())
{
VECADDONS codecs;
CAddonMgr::Get().GetAddons(ADDON_AUDIODECODER, codecs);
for (size_t i=0;i<codecs.size();++i)
{
boost::shared_ptr<CAudioDecoder> dec(boost::static_pointer_cast<CAudioDecoder>(codecs[i]));
if (dec->GetMimetypes().find(strContent) != std::string::npos)
{
CAudioDecoder* result = new CAudioDecoder(*dec);
static_cast<AudioDecoderDll&>(*result).Create();
return result;
}
}
}
if (StringUtils::StartsWithNoCase(strContent, "audio/l16"))
{
PCMCodec * pcm_codec = new PCMCodec();
pcm_codec->SetMimeParams(strContent);
return pcm_codec;
}
else if( strContent.Equals("audio/aac") || strContent.Equals("audio/aacp") ||
strContent.Equals("audio/x-ms-wma") ||
strContent.Equals("audio/x-ape") || strContent.Equals("audio/ape"))
{
DVDPlayerCodec *pCodec = new DVDPlayerCodec;
pCodec->SetContentType(strContent);
return pCodec;
}
else if (strContent.Equals("audio/x-xbmc-pcm"))
{
// audio/x-xbmc-pcm this is the used codec for AirTunes
// (apples audio only streaming)
DVDPlayerCodec *dvdcodec = new DVDPlayerCodec();
dvdcodec->SetContentType(strContent);
return dvdcodec;
}
if (urlFile.GetFileType().Equals("wav") || strContent.Equals("audio/wav") || strContent.Equals("audio/x-wav"))
{
//lets see what it contains...
//this kinda sucks 'cause if it's a plain wav file the file
//will be opened, sniffed and closed 2 times before it is opened *again* for wav
//would be better if the papcodecs could work with bitstreams instead of filenames.
DVDPlayerCodec *dvdcodec = new DVDPlayerCodec();
dvdcodec->SetContentType("audio/x-spdif-compressed");
if (dvdcodec->Init(strFile, filecache))
{
return dvdcodec;
}
delete dvdcodec;
dvdcodec = new DVDPlayerCodec();
dvdcodec->SetContentType(strContent);
return dvdcodec;
}
//default
return CreateCodec(urlFile.GetFileType());
}
