bool CGUIDialogAddonSettings::ShowForAddon(const ADDON::AddonPtr &addon, bool saveToDisk /* = true */)
{
if (addon == nullptr)
return false;
if (!g_passwordManager.CheckMenuLock(WINDOW_ADDON_BROWSER))
return false;
if (!addon->HasSettings())
{
// addon does not support settings, inform user
CGUIDialogOK::ShowAndGetInput(CVariant{ 24000 }, CVariant{ 24030 });
return false;
}
// Create the dialog
CGUIDialogAddonSettings* dialog = g_windowManager.GetWindow<CGUIDialogAddonSettings>(WINDOW_DIALOG_ADDON_SETTINGS);
if (dialog == nullptr)
return false;
dialog->m_addon = addon;
dialog->Open();
if (!dialog->IsConfirmed())
return false;
if (saveToDisk)
addon->SaveSettings();
return true;
}
void CGUIControlButtonSetting::Update()
{
if (m_pButton == NULL)
return;
CGUIControlBaseSetting::Update();
if (m_pSetting->GetType() == SettingTypeString &&
!static_cast<const CSettingControlButton*>(m_pSetting->GetControl())->HideValue())
{
std::string strText = ((CSettingString *)m_pSetting)->GetValue();
const std::string &controlFormat = m_pSetting->GetControl()->GetFormat();
if (controlFormat == "addon")
{
ADDON::AddonPtr addon;
if (ADDON::CAddonMgr::Get().GetAddon(strText, addon))
strText = addon->Name();
if (strText.empty())
strText = g_localizeStrings.Get(231); // None
}
else if (controlFormat == "path")
{
CStdString shortPath;
if (CUtil::MakeShortenPath(strText, shortPath, 30))
strText = shortPath;
}
m_pButton->SetLabel2(strText);
}
}
bool AddonHasSettings(const std::string &condition, const std::string &value, const std::string &settingId)
{
if (settingId.empty())
return false;
CSettingAddon *setting = (CSettingAddon*)CSettings::Get().GetSetting(settingId);
if (setting == NULL)
return false;
ADDON::AddonPtr addon;
if (!ADDON::CAddonMgr::Get().GetAddon(setting->GetValue(), addon, setting->GetAddonType()) || addon == NULL)
return false;
return addon->HasSettings();
}
bool CAddonInstaller::InstallModal(const std::string &addonID, ADDON::AddonPtr &addon, bool promptForInstall /* = true */)
{
if (!g_passwordManager.CheckMenuLock(WINDOW_ADDON_BROWSER))
return false;
// we assume that addons that are enabled don't get to this routine (i.e. that GetAddon() has been called)
if (CAddonMgr::GetInstance().GetAddon(addonID, addon, ADDON_UNKNOWN, false))
return false; // addon is installed but disabled, and the user has specifically activated something that needs
// the addon - should we enable it?
// check we have it available
CAddonDatabase database;
database.Open();
if (!database.GetAddon(addonID, addon))
return false;
// if specified ask the user if he wants it installed
if (promptForInstall)
{
if (HELPERS::ShowYesNoDialogLines(CVariant{24076}, CVariant{24100}, CVariant{addon->Name()}, CVariant{24101}) !=
DialogResponse::YES)
{
return false;
}
}
if (!InstallOrUpdate(addonID, false, true))
return false;
return CAddonMgr::GetInstance().GetAddon(addonID, addon);
}
bool CHTTPPythonHandler::CanHandleRequest(const HTTPRequest &request)
{
ADDON::AddonPtr addon;
std::string path;
// try to resolve the addon as any python script must be part of a webinterface
if (!CHTTPWebinterfaceHandler::ResolveAddon(request.pathUrl, addon, path) ||
addon == NULL || addon->Type() != ADDON::ADDON_WEB_INTERFACE)
return false;
// static webinterfaces aren't allowed to run python scripts
ADDON::CWebinterface* webinterface = static_cast<ADDON::CWebinterface*>(addon.get());
if (webinterface->GetType() != ADDON::WebinterfaceTypeWsgi)
return false;
return true;
}
void XBPython::InitializeInterpreter(ADDON::AddonPtr addon)
{
/*
歌方:
1、
卦指:
1、
傍苧:
1、
*/
InitXBMCModule(); // init xbmc modules
InitPluginModule(); // init xbmcplugin modules
InitGUIModule(); // init xbmcgui modules
InitAddonModule(); // init xbmcaddon modules
InitVFSModule(); // init xbmcvfs modules
CStdString addonVer = ADDON::GetXbmcApiVersionDependency(addon);
bool bwcompatMode = (addon.get() == NULL || (ADDON::AddonVersion(addonVer) <= ADDON::AddonVersion("1.0")));
const char* runscript = bwcompatMode ? RUNSCRIPT_BWCOMPATIBLE : RUNSCRIPT_COMPLIANT;
// redirecting default output to debug console
if (PyRun_SimpleString(runscript) == -1)
{
CLog::Log(LOGFATAL, "Python Initialize Error");
}
}
int CHTTPWebinterfaceHandler::ResolveUrl(const std::string &url, std::string &path, ADDON::AddonPtr &addon)
{
// determine the addon and addon's path
if (!ResolveAddon(url, addon, path))
return MHD_HTTP_NOT_FOUND;
if (XFILE::CDirectory::Exists(path))
{
if (URIUtils::GetFileName(path).empty())
{
// determine the actual file path using the default entry point
if (addon != NULL && addon->Type() == ADDON::ADDON_WEB_INTERFACE)
path = std::dynamic_pointer_cast<ADDON::CWebinterface>(addon)->GetEntryPoint(path);
}
else
{
URIUtils::AddSlashAtEnd(path);
return MHD_HTTP_FOUND;
}
}
if (!XFILE::CFile::Exists(path))
return MHD_HTTP_NOT_FOUND;
// white/black list access check
if (!CFileUtils::ZebraListAccessCheck(path))
return MHD_HTTP_NOT_FOUND;
return MHD_HTTP_OK;
}
bool CHTTPWebinterfaceHandler::ResolveAddon(const std::string &url, ADDON::AddonPtr &addon, std::string &addonPath)
{
std::string path = url;
// check if the URL references a specific addon
if (url.find("/addons/") == 0 && url.size() > 8)
{
std::vector<std::string> components;
StringUtils::Tokenize(path, components, WEBSERVER_DIRECTORY_SEPARATOR);
if (components.size() <= 1)
return false;
if (!ADDON::CAddonMgr::GetInstance().GetAddon(components.at(1), addon) || addon == NULL)
return false;
addonPath = addon->Path();
if (addon->Type() != ADDON::ADDON_WEB_INTERFACE) // No need to append /htdocs for web interfaces
addonPath = URIUtils::AddFileToFolder(addonPath, "/htdocs/");
// remove /addons/<addon-id> from the path
components.erase(components.begin(), components.begin() + 2);
// determine the path within the addon
path = StringUtils::Join(components, WEBSERVER_DIRECTORY_SEPARATOR);
}
else if (!ADDON::CAddonMgr::GetInstance().GetDefault(ADDON::ADDON_WEB_INTERFACE, addon) || addon == NULL)
return false;
// get the path of the addon
addonPath = addon->Path();
// add /htdocs/ to the addon's path if it's not a webinterface
if (addon->Type() != ADDON::ADDON_WEB_INTERFACE)
addonPath = URIUtils::AddFileToFolder(addonPath, "/htdocs/");
// append the path within the addon to the path of the addon
addonPath = URIUtils::AddFileToFolder(addonPath, path);
// ensure that we don't have a directory traversal hack here
// by checking if the resolved absolute path is inside the addon path
std::string realPath = URIUtils::GetRealPath(addonPath);
std::string realAddonPath = URIUtils::GetRealPath(addon->Path());
if (!URIUtils::IsInPath(realPath, realAddonPath))
return false;
return true;
}
bool AddonHasSettings(const std::string &condition, const std::string &value, SettingConstPtr setting, void *data)
{
if (setting == NULL)
return false;
std::shared_ptr<const CSettingAddon> settingAddon = std::dynamic_pointer_cast<const CSettingAddon>(setting);
if (settingAddon == NULL)
return false;
ADDON::AddonPtr addon;
if (!CServiceBroker::GetAddonMgr().GetAddon(settingAddon->GetValue(), addon, settingAddon->GetAddonType()) || addon == NULL)
return false;
if (addon->Type() == ADDON::ADDON_SKIN)
return ((ADDON::CSkinInfo*)addon.get())->HasSkinFile("SkinSettings.xml");
return addon->HasSettings();
}
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::ADDON_SCRIPT_MODULE))
{
std::string path = CSpecialProtocol::TranslatePath(dependency->LibPath());
if (paths.find(path) == paths.end())
{
// add it and its dependencies
paths.insert(path);
getAddonModuleDeps(dependency, paths);
}
}
}
}
void CAddonDatabase::OnDisable(const ADDON::AddonPtr &addon)
{
if (!addon)
return;
IAddonDatabaseCallback *cb = GetCallbackForType(addon->Type());
if (cb)
cb->AddonDisabled(addon);
}
CStdString GetXbmcApiVersionDependency(ADDON::AddonPtr addon)
{
CStdString version("1.0");
if (addon.get() != NULL)
{
const ADDON::ADDONDEPS &deps = addon->GetDeps();
ADDON::ADDONDEPS::const_iterator it;
CStdString key("xbmc.python");
it = deps.find(key);
if (!(it == deps.end()))
{
const ADDON::AddonVersion * xbmcApiVersion = &(it->second.first);
version = xbmcApiVersion->c_str();
}
}
return version;
}
bool AddonHasSettings(const std::string &condition, const std::string &value, const CSetting *setting, void *data)
{
if (setting == NULL)
return false;
const CSettingAddon *settingAddon = dynamic_cast<const CSettingAddon*>(setting);
if (settingAddon == NULL)
return false;
ADDON::AddonPtr addon;
if (!ADDON::CAddonMgr::GetInstance().GetAddon(settingAddon->GetValue(), addon, settingAddon->GetAddonType()) || addon == NULL)
return false;
if (addon->Type() == ADDON::ADDON_SKIN)
return ((ADDON::CSkinInfo*)addon.get())->HasSkinFile("SkinSettings.xml");
return addon->HasSettings();
}
bool AddonHasSettings(const std::string &condition, const std::string &value, const std::string &settingId)
{
if (settingId.empty())
return false;
CSettingAddon *setting = (CSettingAddon*)CSettings::Get().GetSetting(settingId);
if (setting == NULL)
return false;
ADDON::AddonPtr addon;
if (!ADDON::CAddonMgr::Get().GetAddon(setting->GetValue(), addon, setting->GetAddonType()) || addon == NULL)
return false;
if (addon->Type() == ADDON::ADDON_SKIN)
return ((ADDON::CSkinInfo*)addon.get())->HasSkinFile("SkinSettings.xml");
return addon->HasSettings();
}
void CPythonInvoker::getAddonModuleDeps(const ADDON::AddonPtr& addon, std::set<std::string>& paths)
{
ADDON::ADDONDEPS deps = addon->GetDeps();
for (ADDON::ADDONDEPS::const_iterator it = deps.begin(); it != deps.end(); ++it)
{
//Check if dependency is a module addon
ADDON::AddonPtr dependency;
if (ADDON::CAddonMgr::Get().GetAddon(it->first, dependency, ADDON::ADDON_SCRIPT_MODULE))
{
std::string path = CSpecialProtocol::TranslatePath(dependency->LibPath());
if (paths.find(path) == paths.end())
{
// add it and its dependencies
paths.insert(path);
getAddonModuleDeps(dependency, paths);
}
}
}
}
bool CAddonDatabase::OnEnable(const ADDON::AddonPtr &addon, bool bDisabled)
{
if (!addon)
return false;
IAddonDatabaseCallback *cb = GetCallbackForType(addon->Type());
if (cb)
return cb->AddonEnabled(addon, bDisabled);
return true;
}
bool CGameUtils::IsStandaloneGame(const ADDON::AddonPtr& addon)
{
using namespace ADDON;
switch (addon->Type())
{
case ADDON_GAMEDLL:
{
return std::static_pointer_cast<GAME::CGameClient>(addon)->SupportsStandalone();
}
case ADDON_SCRIPT:
{
return addon->IsType(ADDON_GAME);
}
default:
break;
}
return false;
}
void CGUIButtonSettingControl::Update()
{
CStdString strText = ((CSettingString *)m_pSetting)->GetData();
if (m_pSetting->GetType() == SETTINGS_TYPE_ADDON)
{
ADDON::AddonPtr addon;
if (ADDON::CAddonMgr::Get().GetAddon(strText, addon))
strText = addon->Name();
if (strText.IsEmpty())
strText = g_localizeStrings.Get(231); // None
}
else if (m_pSetting->GetControlType() == BUTTON_CONTROL_PATH_INPUT)
{
CStdString shortPath;
if (CUtil::MakeShortenPath(strText, shortPath, 30 ))
strText = shortPath;
}
else if (m_pSetting->GetControlType() == BUTTON_CONTROL_STANDARD)
return;
if (m_pButton)
m_pButton->SetLabel2(strText);
}
bool CAddonInstallJob::GetAddonWithHash(const std::string& addonID, RepositoryPtr& repo,
ADDON::AddonPtr& addon, std::string& hash)
{
if (!CAddonMgr::GetInstance().FindInstallableById(addonID, addon))
return false;
AddonPtr tmp;
if (!CAddonMgr::GetInstance().GetAddon(addon->Origin(), tmp, ADDON_REPOSITORY))
return false;
repo = std::static_pointer_cast<CRepository>(tmp);
return repo->GetAddonHash(addon, hash);
}
void CGUIControlButtonSetting::Update()
{
if (m_pButton == NULL)
return;
CGUIControlBaseSetting::Update();
if (m_pSetting->GetType() == SettingTypeString)
{
std::string strText = ((CSettingString *)m_pSetting)->GetValue();
switch (m_pSetting->GetControl().GetFormat())
{
case SettingControlFormatAddon:
{
ADDON::AddonPtr addon;
if (ADDON::CAddonMgr::Get().GetAddon(strText, addon))
strText = addon->Name();
if (strText.empty())
strText = g_localizeStrings.Get(231); // None
break;
}
case SettingControlFormatPath:
{
CStdString shortPath;
if (CUtil::MakeShortenPath(strText, shortPath, 30))
strText = shortPath;
break;
}
default:
return;
}
m_pButton->SetLabel2(strText);
}
}
void XBPython::InitializeInterpreter(ADDON::AddonPtr addon)
{
{
GilSafeSingleLock lock(m_critSection);
initModule_xbmcgui();
initModule_xbmc();
initModule_xbmcplugin();
initModule_xbmcaddon();
initModule_xbmcvfs();
}
CStdString addonVer = ADDON::GetXbmcApiVersionDependency(addon);
bool bwcompatMode = (addon.get() == NULL || (ADDON::AddonVersion(addonVer) <= ADDON::AddonVersion("1.0")));
const char* runscript = bwcompatMode ? RUNSCRIPT_BWCOMPATIBLE : RUNSCRIPT_COMPLIANT;
// redirecting default output to debug console
if (PyRun_SimpleString(runscript) == -1)
{
CLog::Log(LOGFATAL, "Python Initialize Error");
}
}
bool CGUIWindowMusicNav::OnContextButton(int itemNumber, CONTEXT_BUTTON button)
{
CFileItemPtr item;
if (itemNumber >= 0 && itemNumber < m_vecItems->Size())
item = m_vecItems->Get(itemNumber);
switch (button)
{
case CONTEXT_BUTTON_INFO:
{
if (!item->IsVideoDb())
return CGUIWindowMusicBase::OnContextButton(itemNumber,button);
// music videos - artists
if (item->GetPath().Left(14).Equals("videodb://3/4/"))
{
long idArtist = m_musicdatabase.GetArtistByName(item->GetLabel());
if (idArtist == -1)
return false;
CStdString path; path.Format("musicdb://2/%ld/", idArtist);
item->SetPath(path);
CGUIWindowMusicBase::OnContextButton(itemNumber,button);
Update(m_vecItems->GetPath());
m_viewControl.SetSelectedItem(itemNumber);
return true;
}
// music videos - albums
if (item->GetPath().Left(14).Equals("videodb://3/5/"))
{
long idAlbum = m_musicdatabase.GetAlbumByName(item->GetLabel());
if (idAlbum == -1)
return false;
CStdString path; path.Format("musicdb://3/%ld/", idAlbum);
item->SetPath(path);
CGUIWindowMusicBase::OnContextButton(itemNumber,button);
Update(m_vecItems->GetPath());
m_viewControl.SetSelectedItem(itemNumber);
return true;
}
if (item->HasVideoInfoTag() && !item->GetVideoInfoTag()->m_strTitle.IsEmpty())
{
CGUIWindowVideoNav* pWindow = (CGUIWindowVideoNav*)g_windowManager.GetWindow(WINDOW_VIDEO_NAV);
if (pWindow)
{
ADDON::ScraperPtr info;
pWindow->OnInfo(item.get(),info);
Update(m_vecItems->GetPath());
}
}
return true;
}
case CONTEXT_BUTTON_INFO_ALL:
OnInfoAll(itemNumber);
return true;
case CONTEXT_BUTTON_UPDATE_LIBRARY:
{
CGUIDialogMusicScan *scanner = (CGUIDialogMusicScan *)g_windowManager.GetWindow(WINDOW_DIALOG_MUSIC_SCAN);
if (scanner)
scanner->StartScanning("");
return true;
}
case CONTEXT_BUTTON_SET_DEFAULT:
g_settings.m_defaultMusicLibSource = GetQuickpathName(item->GetPath());
g_settings.Save();
return true;
case CONTEXT_BUTTON_CLEAR_DEFAULT:
g_settings.m_defaultMusicLibSource.Empty();
g_settings.Save();
return true;
case CONTEXT_BUTTON_GO_TO_ARTIST:
{
CStdString strPath;
CVideoDatabase database;
database.Open();
strPath.Format("videodb://3/4/%ld/",database.GetMatchingMusicVideo(item->GetMusicInfoTag()->GetArtist()));
g_windowManager.ActivateWindow(WINDOW_VIDEO_NAV,strPath);
return true;
}
case CONTEXT_BUTTON_PLAY_OTHER:
{
CVideoDatabase database;
database.Open();
CVideoInfoTag details;
database.GetMusicVideoInfo("",details,database.GetMatchingMusicVideo(item->GetMusicInfoTag()->GetArtist(),item->GetMusicInfoTag()->GetAlbum(),item->GetMusicInfoTag()->GetTitle()));
g_application.getApplicationMessenger().PlayFile(CFileItem(details));
return true;
}
case CONTEXT_BUTTON_MARK_WATCHED:
CGUIWindowVideoBase::MarkWatched(item,true);
CUtil::DeleteVideoDatabaseDirectoryCache();
Update(m_vecItems->GetPath());
return true;
case CONTEXT_BUTTON_MARK_UNWATCHED:
CGUIWindowVideoBase::MarkWatched(item,false);
CUtil::DeleteVideoDatabaseDirectoryCache();
Update(m_vecItems->GetPath());
return true;
case CONTEXT_BUTTON_RENAME:
CGUIWindowVideoBase::UpdateVideoTitle(item.get());
CUtil::DeleteVideoDatabaseDirectoryCache();
Update(m_vecItems->GetPath());
return true;
case CONTEXT_BUTTON_DELETE:
if (item->IsPlayList() || item->IsSmartPlayList())
{
item->m_bIsFolder = false;
CFileUtils::DeleteItem(item);
}
else
{
CGUIWindowVideoNav::DeleteItem(item.get());
CUtil::DeleteVideoDatabaseDirectoryCache();
}
Update(m_vecItems->GetPath());
return true;
case CONTEXT_BUTTON_SET_CONTENT:
{
bool bScan=false;
ADDON::ScraperPtr scraper;
CStdString path(item->GetPath());
CQueryParams params;
CDirectoryNode::GetDatabaseInfo(item->GetPath(), params);
CONTENT_TYPE content = CONTENT_ALBUMS;
if (params.GetAlbumId() != -1)
path.Format("musicdb://3/%i/",params.GetAlbumId());
else if (params.GetArtistId() != -1)
{
path.Format("musicdb://2/%i/",params.GetArtistId());
content = CONTENT_ARTISTS;
}
if (m_vecItems->GetPath().Equals("musicdb://1/") || item->GetPath().Equals("musicdb://2/"))
{
content = CONTENT_ARTISTS;
}
if (!m_musicdatabase.GetScraperForPath(path, scraper, ADDON::ScraperTypeFromContent(content)))
{
ADDON::AddonPtr defaultScraper;
if (ADDON::CAddonMgr::Get().GetDefault(ADDON::ScraperTypeFromContent(content), defaultScraper))
{
scraper = boost::dynamic_pointer_cast<ADDON::CScraper>(defaultScraper->Clone(defaultScraper));
}
}
if (CGUIDialogContentSettings::Show(scraper, bScan, content))
{
m_musicdatabase.SetScraperForPath(path,scraper);
if (bScan)
OnInfoAll(itemNumber,true);
}
return true;
}
default:
break;
}
return CGUIWindowMusicBase::OnContextButton(itemNumber, button);
}
bool CGUIWindowMusicNav::OnContextButton(int itemNumber, CONTEXT_BUTTON button)
{
CFileItemPtr item;
if (itemNumber >= 0 && itemNumber < m_vecItems->Size())
item = m_vecItems->Get(itemNumber);
switch (button)
{
case CONTEXT_BUTTON_INFO:
{
if (!item->IsVideoDb())
return CGUIWindowMusicBase::OnContextButton(itemNumber,button);
// music videos - artists
if (StringUtils::StartsWithNoCase(item->GetPath(), "videodb://musicvideos/artists/"))
{
long idArtist = m_musicdatabase.GetArtistByName(item->GetLabel());
if (idArtist == -1)
return false;
CStdString path = StringUtils::Format("musicdb://artists/%ld/", idArtist);
CArtist artist;
m_musicdatabase.GetArtistInfo(idArtist,artist,false);
*item = CFileItem(artist);
item->SetPath(path);
CGUIWindowMusicBase::OnContextButton(itemNumber,button);
Refresh();
m_viewControl.SetSelectedItem(itemNumber);
return true;
}
// music videos - albums
if (StringUtils::StartsWithNoCase(item->GetPath(), "videodb://musicvideos/albums/"))
{
long idAlbum = m_musicdatabase.GetAlbumByName(item->GetLabel());
if (idAlbum == -1)
return false;
CStdString path = StringUtils::Format("musicdb://albums/%ld/", idAlbum);
CAlbum album;
m_musicdatabase.GetAlbumInfo(idAlbum,album,NULL);
*item = CFileItem(path,album);
item->SetPath(path);
CGUIWindowMusicBase::OnContextButton(itemNumber,button);
Refresh();
m_viewControl.SetSelectedItem(itemNumber);
return true;
}
if (item->HasVideoInfoTag() && !item->GetVideoInfoTag()->m_strTitle.empty())
{
CGUIWindowVideoNav* pWindow = (CGUIWindowVideoNav*)g_windowManager.GetWindow(WINDOW_VIDEO_NAV);
if (pWindow)
{
ADDON::ScraperPtr info;
pWindow->OnInfo(item.get(),info);
Refresh();
}
}
return true;
}
case CONTEXT_BUTTON_INFO_ALL:
OnInfoAll(itemNumber);
return true;
case CONTEXT_BUTTON_SET_DEFAULT:
CSettings::Get().SetString("mymusic.defaultlibview", GetQuickpathName(item->GetPath()));
CSettings::Get().Save();
return true;
case CONTEXT_BUTTON_CLEAR_DEFAULT:
CSettings::Get().SetString("mymusic.defaultlibview", "");
CSettings::Get().Save();
return true;
case CONTEXT_BUTTON_GO_TO_ARTIST:
{
CStdString strPath;
CVideoDatabase database;
database.Open();
strPath = StringUtils::Format("videodb://musicvideos/artists/%ld/",
database.GetMatchingMusicVideo(StringUtils::Join(item->GetMusicInfoTag()->GetArtist(), g_advancedSettings.m_musicItemSeparator)));
g_windowManager.ActivateWindow(WINDOW_VIDEO_NAV,strPath);
return true;
}
case CONTEXT_BUTTON_PLAY_OTHER:
{
CVideoDatabase database;
database.Open();
CVideoInfoTag details;
database.GetMusicVideoInfo("",details,database.GetMatchingMusicVideo(StringUtils::Join(item->GetMusicInfoTag()->GetArtist(), g_advancedSettings.m_musicItemSeparator),item->GetMusicInfoTag()->GetAlbum(),item->GetMusicInfoTag()->GetTitle()));
CApplicationMessenger::Get().PlayFile(CFileItem(details));
return true;
}
case CONTEXT_BUTTON_MARK_WATCHED:
CGUIDialogVideoInfo::MarkWatched(item, true);
CUtil::DeleteVideoDatabaseDirectoryCache();
Refresh();
return true;
case CONTEXT_BUTTON_MARK_UNWATCHED:
CGUIDialogVideoInfo::MarkWatched(item, false);
CUtil::DeleteVideoDatabaseDirectoryCache();
Refresh();
return true;
case CONTEXT_BUTTON_RENAME:
CGUIDialogVideoInfo::UpdateVideoItemTitle(item);
CUtil::DeleteVideoDatabaseDirectoryCache();
Refresh();
return true;
case CONTEXT_BUTTON_DELETE:
if (item->IsPlayList() || item->IsSmartPlayList())
{
item->m_bIsFolder = false;
CFileUtils::DeleteItem(item);
}
else
{
CGUIDialogVideoInfo::DeleteVideoItemFromDatabase(item);
CUtil::DeleteVideoDatabaseDirectoryCache();
}
Refresh();
return true;
case CONTEXT_BUTTON_SET_CONTENT:
{
ADDON::ScraperPtr scraper;
CStdString path(item->GetPath());
CQueryParams params;
CDirectoryNode::GetDatabaseInfo(item->GetPath(), params);
CONTENT_TYPE content = CONTENT_ALBUMS;
if (params.GetAlbumId() != -1)
path = StringUtils::Format("musicdb://albums/%i/",params.GetAlbumId());
else if (params.GetArtistId() != -1)
{
path = StringUtils::Format("musicdb://artists/%i/",params.GetArtistId());
content = CONTENT_ARTISTS;
}
if (m_vecItems->GetPath().Equals("musicdb://genres/") || item->GetPath().Equals("musicdb://artists/"))
{
content = CONTENT_ARTISTS;
}
if (!m_musicdatabase.GetScraperForPath(path, scraper, ADDON::ScraperTypeFromContent(content)))
{
ADDON::AddonPtr defaultScraper;
if (ADDON::CAddonMgr::Get().GetDefault(ADDON::ScraperTypeFromContent(content), defaultScraper))
{
scraper = boost::dynamic_pointer_cast<ADDON::CScraper>(defaultScraper->Clone());
}
}
if (CGUIDialogContentSettings::Show(scraper, content))
{
m_musicdatabase.SetScraperForPath(path,scraper);
if (CGUIDialogYesNo::ShowAndGetInput(20442,20443,20444,20022))
{
OnInfoAll(itemNumber,true,true);
}
}
return true;
}
default:
break;
}
return CGUIWindowMusicBase::OnContextButton(itemNumber, button);
}
void CGUIDialogContextMenu::GetContextButtons(const std::string &type, const CFileItemPtr& item, CContextButtons &buttons)
{
// Add buttons to the ContextMenu that should be visible for both sources and autosourced items
if (item && item->IsRemovable())
{
if (item->IsDVD() || item->IsCDDA())
{
// We need to check if there is a detected is inserted!
buttons.Add(CONTEXT_BUTTON_PLAY_DISC, 341); // Play CD/DVD!
if (CGUIWindowVideoBase::HasResumeItemOffset(item.get()))
buttons.Add(CONTEXT_BUTTON_RESUME_DISC, CGUIWindowVideoBase::GetResumeString(*(item.get()))); // Resume Disc
buttons.Add(CONTEXT_BUTTON_EJECT_DISC, 13391); // Eject/Load CD/DVD!
}
else // Must be HDD
{
buttons.Add(CONTEXT_BUTTON_EJECT_DRIVE, 13420); // Eject Removable HDD!
}
}
// Next, Add buttons to the ContextMenu that should ONLY be visible for sources and not autosourced items
CMediaSource *share = GetShare(type, item.get());
if (CProfilesManager::Get().GetCurrentProfile().canWriteSources() || g_passwordManager.bMasterUser)
{
if (share)
{
// Note. from now on, remove source & disable plugin should mean the same thing
//TODO might be smart to also combine editing source & plugin settings into one concept/dialog
// Note. Temporarily disabled ability to remove plugin sources until installer is operational
CURL url(share->strPath);
bool isAddon = ADDON::TranslateContent(url.GetProtocol()) != CONTENT_NONE;
if (!share->m_ignore && !isAddon)
buttons.Add(CONTEXT_BUTTON_EDIT_SOURCE, 1027); // Edit Source
else
{
ADDON::AddonPtr plugin;
if (ADDON::CAddonMgr::Get().GetAddon(url.GetHostName(), plugin))
if (plugin->HasSettings())
buttons.Add(CONTEXT_BUTTON_PLUGIN_SETTINGS, 1045); // Plugin Settings
}
if (type != "video")
buttons.Add(CONTEXT_BUTTON_SET_DEFAULT, 13335); // Set as Default
if (!share->m_ignore && !isAddon)
buttons.Add(CONTEXT_BUTTON_REMOVE_SOURCE, 522); // Remove Source
buttons.Add(CONTEXT_BUTTON_SET_THUMB, 20019);
}
if (!GetDefaultShareNameByType(type).empty())
buttons.Add(CONTEXT_BUTTON_CLEAR_DEFAULT, 13403); // Clear Default
}
if (share && LOCK_MODE_EVERYONE != CProfilesManager::Get().GetMasterProfile().getLockMode())
{
if (share->m_iHasLock == 0 && (CProfilesManager::Get().GetCurrentProfile().canWriteSources() || g_passwordManager.bMasterUser))
buttons.Add(CONTEXT_BUTTON_ADD_LOCK, 12332);
else if (share->m_iHasLock == 1)
buttons.Add(CONTEXT_BUTTON_REMOVE_LOCK, 12335);
else if (share->m_iHasLock == 2)
{
buttons.Add(CONTEXT_BUTTON_REMOVE_LOCK, 12335);
bool maxRetryExceeded = false;
if (CSettings::Get().GetInt("masterlock.maxretries") != 0)
maxRetryExceeded = (share->m_iBadPwdCount >= CSettings::Get().GetInt("masterlock.maxretries"));
if (maxRetryExceeded)
buttons.Add(CONTEXT_BUTTON_RESET_LOCK, 12334);
else
buttons.Add(CONTEXT_BUTTON_CHANGE_LOCK, 12356);
}
}
if (share && !g_passwordManager.bMasterUser && item->m_iHasLock == 1)
buttons.Add(CONTEXT_BUTTON_REACTIVATE_LOCK, 12353);
}
bool CAddonsGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const
{
const std::shared_ptr<const ADDON::IAddon> addonInfo = item->GetAddonInfo();
if (addonInfo)
{
switch (info.m_info)
{
///////////////////////////////////////////////////////////////////////////////////////////////
// LISTITEM_*
///////////////////////////////////////////////////////////////////////////////////////////////
case LISTITEM_ADDON_NAME:
value = addonInfo->Name();
return true;
case LISTITEM_ADDON_VERSION:
value = addonInfo->Version().asString();
return true;
case LISTITEM_ADDON_CREATOR:
value = addonInfo->Author();
return true;
case LISTITEM_ADDON_SUMMARY:
value = addonInfo->Summary();
return true;
case LISTITEM_ADDON_DESCRIPTION:
value = addonInfo->Description();
return true;
case LISTITEM_ADDON_DISCLAIMER:
value = addonInfo->Disclaimer();
return true;
case LISTITEM_ADDON_NEWS:
value = addonInfo->ChangeLog();
return true;
case LISTITEM_ADDON_BROKEN:
value = addonInfo->Broken();
return true;
case LISTITEM_ADDON_TYPE:
value = ADDON::CAddonInfo::TranslateType(addonInfo->Type(), true);
return true;
case LISTITEM_ADDON_INSTALL_DATE:
value = addonInfo->InstallDate().GetAsLocalizedDateTime();
return true;
case LISTITEM_ADDON_LAST_UPDATED:
if (addonInfo->LastUpdated().IsValid())
{
value = addonInfo->LastUpdated().GetAsLocalizedDateTime();
return true;
}
break;
case LISTITEM_ADDON_LAST_USED:
if (addonInfo->LastUsed().IsValid())
{
value = addonInfo->LastUsed().GetAsLocalizedDateTime();
return true;
}
break;
case LISTITEM_ADDON_ORIGIN:
{
if (item->GetAddonInfo()->Origin() == ADDON::ORIGIN_SYSTEM)
{
value = g_localizeStrings.Get(24992);
return true;
}
ADDON::AddonPtr origin;
if (CServiceBroker::GetAddonMgr().GetAddon(item->GetAddonInfo()->Origin(), origin, ADDON::ADDON_UNKNOWN, false))
{
value = origin->Name();
return true;
}
value = g_localizeStrings.Get(13205);
return true;
}
case LISTITEM_ADDON_SIZE:
{
uint64_t packageSize = item->GetAddonInfo()->PackageSize();
if (packageSize > 0)
{
value = StringUtils::FormatFileSize(packageSize);
return true;
}
break;
}
}
}
switch (info.m_info)
{
///////////////////////////////////////////////////////////////////////////////////////////////
// SYSTEM_*
///////////////////////////////////////////////////////////////////////////////////////////////
case SYSTEM_ADDON_TITLE:
case SYSTEM_ADDON_ICON:
case SYSTEM_ADDON_VERSION:
{
// This logic does not check/care whether an addon has been disabled/marked as broken,
// it simply retrieves it's name or icon that means if an addon is placed on the home screen it
// will stay there even if it's disabled/marked as broken. This might need to be changed/fixed
// in the future.
ADDON::AddonPtr addon;
if (!info.GetData3().empty())
{
CServiceBroker::GetAddonMgr().GetAddon(info.GetData3(), addon, ADDON::ADDON_UNKNOWN, false);
if (!addon)
break;
if (info.m_info == SYSTEM_ADDON_TITLE)
{
value = addon->Name();
return true;
}
if (info.m_info == SYSTEM_ADDON_ICON)
{
value = addon->Icon();
return true;
}
if (info.m_info == SYSTEM_ADDON_VERSION)
{
value = addon->Version().asString();
return true;
}
}
break;
}
}
return false;
}
int CAddonDatabase::GetAddonId(const ADDON::AddonPtr& item)
{
std::string value = GetSingleValue("addon", "id", StringUtils::Format("name = '%s'", item->Name().c_str()), "id desc");
return value.empty() || !StringUtils::IsInteger(value) ? -1 : atoi(value.c_str());
}
bool CRetroPlayer::OpenFile(const CFileItem& file, const CPlayerOptions& options)
{
CFileItem fileCopy(file);
// When playing a game, set the game client that we'll use to open the game
// Currently this may prompt the user, the goal is to figure this out silently
if (!GAME::CGameUtils::FillInGameClient(fileCopy, true))
{
CLog::Log(LOGINFO, "RetroPlayer: No compatible game client selected, aborting playback");
return false;
}
// Check if we should open in standalone mode
const bool bStandalone = fileCopy.GetPath().empty();
m_processInfo.reset(CRPProcessInfo::CreateInstance());
if (!m_processInfo)
{
CLog::Log(LOGERROR, "Failed to create RetroPlayer - no process info registered");
return false;
}
m_processInfo->SetDataCache(&CServiceBroker::GetDataCacheCore());
m_processInfo->ResetInfo();
m_renderManager.reset(new CRPRenderManager(*m_processInfo));
CSingleLock lock(m_mutex);
if (IsPlaying())
CloseFile();
PrintGameInfo(fileCopy);
bool bSuccess = false;
std::string gameClientId = fileCopy.GetGameInfoTag()->GetGameClient();
ADDON::AddonPtr addon;
if (gameClientId.empty())
{
CLog::Log(LOGERROR, "Can't play game, no game client was passed to RetroPlayer!");
}
else if (!CServiceBroker::GetAddonMgr().GetAddon(gameClientId, addon, ADDON::ADDON_GAMEDLL))
{
CLog::Log(LOGERROR, "Can't find add-on %s for game file!", gameClientId.c_str());
}
else
{
m_gameClient = std::static_pointer_cast<CGameClient>(addon);
if (m_gameClient->Initialize())
{
m_audio.reset(new CRetroPlayerAudio(*m_processInfo));
m_video.reset(new CRetroPlayerVideo(*m_renderManager, *m_processInfo));
m_input.reset(new CRetroPlayerInput(CServiceBroker::GetPeripherals()));
if (!bStandalone)
{
std::string redactedPath = CURL::GetRedacted(fileCopy.GetPath());
CLog::Log(LOGINFO, "RetroPlayer: Opening: %s", redactedPath.c_str());
bSuccess = m_gameClient->OpenFile(fileCopy, m_audio.get(), m_video.get(), m_input.get());
}
else
{
CLog::Log(LOGINFO, "RetroPlayer: Opening standalone");
bSuccess = m_gameClient->OpenStandalone(m_audio.get(), m_video.get(), m_input.get());
}
if (bSuccess)
CLog::Log(LOGDEBUG, "RetroPlayer: Using game client %s", gameClientId.c_str());
else
CLog::Log(LOGERROR, "RetroPlayer: Failed to open file using %s", gameClientId.c_str());
}
else
CLog::Log(LOGERROR, "RetroPlayer: Failed to initialize %s", gameClientId.c_str());
}
if (bSuccess && !bStandalone)
{
std::string savestatePath = CSavestateUtils::MakeMetadataPath(fileCopy.GetPath());
CSavestate save;
if (save.Deserialize(savestatePath))
{
// Check if game client is the same
if (save.GameClient() != m_gameClient->ID())
{
ADDON::AddonPtr addon;
if (CServiceBroker::GetAddonMgr().GetAddon(save.GameClient(), addon))
{
// Warn the user that continuing with a different game client will
// overwrite the save
bool dummy;
if (!CGUIDialogYesNo::ShowAndGetInput(438, StringUtils::Format(g_localizeStrings.Get(35217), addon->Name()), dummy, 222, 35218, 0))
bSuccess = false;
}
}
}
if (bSuccess)
{
std::string redactedSavestatePath = CURL::GetRedacted(savestatePath);
CLog::Log(LOGDEBUG, "RetroPlayer: Loading savestate %s", redactedSavestatePath.c_str());
if (!SetPlayerState(savestatePath))
CLog::Log(LOGERROR, "RetroPlayer: Failed to load savestate");
}
}
if (bSuccess)
{
RegisterWindowCallbacks();
SetSpeedInternal(1.0);
m_callback.OnPlayBackStarted(fileCopy);
if (!bStandalone)
m_autoSave.reset(new CRetroPlayerAutoSave(*m_gameClient));
m_processInfo->SetVideoFps(static_cast<float>(m_gameClient->Timing().GetFrameRate()));
}
else
{
m_gameClient.reset();
m_audio.reset();
m_video.reset();
}
return bSuccess;
}
void CGUIControlButtonSetting::Update(bool updateDisplayOnly /* = false */)
{
if (updateDisplayOnly || m_pButton == NULL)
return;
CGUIControlBaseSetting::Update();
std::string strText;
const ISettingControl *control = m_pSetting->GetControl();
const std::string &controlType = control->GetType();
const std::string &controlFormat = control->GetFormat();
if (controlType == "button")
{
if (m_pSetting->GetType() == SettingTypeString &&
!static_cast<const CSettingControlButton*>(control)->HideValue())
{
std::string strValue = ((CSettingString *)m_pSetting)->GetValue();
if (controlFormat == "addon")
{
ADDON::AddonPtr addon;
if (ADDON::CAddonMgr::Get().GetAddon(strValue, addon))
strText = addon->Name();
if (strText.empty())
strText = g_localizeStrings.Get(231); // None
}
else if (controlFormat == "path")
{
std::string shortPath;
if (CUtil::MakeShortenPath(strValue, shortPath, 30))
strText = shortPath;
}
else if (controlFormat == "infolabel")
{
strText = strValue;
if (strText.empty())
strText = g_localizeStrings.Get(231); // None
}
}
else if (m_pSetting->GetType() == SettingTypeAction &&
!static_cast<const CSettingControlButton*>(control)->HideValue())
{
// CSettingAction.
// Note: This can be removed once all settings use a proper control & format combination.
// CSettingAction is strictly speaking not designed to have a label2, it does not even have a value.
strText = m_pButton->GetLabel2();
}
}
else if (controlType == "slider")
{
switch (m_pSetting->GetType())
{
case SettingTypeInteger:
{
const CSettingInt *settingInt = static_cast<CSettingInt*>(m_pSetting);
strText = CGUIControlSliderSetting::GetText(static_cast<const CSettingControlSlider*>(m_pSetting->GetControl()),
settingInt->GetValue(), settingInt->GetMinimum(), settingInt->GetStep(), settingInt->GetMaximum());
break;
}
case SettingTypeNumber:
{
const CSettingNumber *settingNumber = static_cast<CSettingNumber*>(m_pSetting);
strText = CGUIControlSliderSetting::GetText(static_cast<const CSettingControlSlider*>(m_pSetting->GetControl()),
settingNumber->GetValue(), settingNumber->GetMinimum(), settingNumber->GetStep(), settingNumber->GetMaximum());
break;
}
default:
break;
}
}
m_pButton->SetLabel2(strText);
}
void CGUIControlButtonSetting::Update(bool updateDisplayOnly /* = false */)
{
if (updateDisplayOnly || m_pButton == NULL)
return;
CGUIControlBaseSetting::Update();
std::string strText;
const ISettingControl *control = m_pSetting->GetControl();
const std::string &controlType = control->GetType();
const std::string &controlFormat = control->GetFormat();
if (controlType == "button")
{
if (m_pSetting->GetType() == SettingTypeString &&
!static_cast<const CSettingControlButton*>(control)->HideValue())
{
std::string strValue = ((CSettingString *)m_pSetting)->GetValue();
if (controlFormat == "addon")
{
ADDON::AddonPtr addon;
if (ADDON::CAddonMgr::Get().GetAddon(strValue, addon))
strText = addon->Name();
if (strText.empty())
strText = g_localizeStrings.Get(231); // None
}
else if (controlFormat == "path")
{
std::string shortPath;
if (CUtil::MakeShortenPath(strValue, shortPath, 30))
strText = shortPath;
}
}
}
else if (controlType == "slider")
{
switch (m_pSetting->GetType())
{
case SettingTypeInteger:
{
const CSettingInt *settingInt = static_cast<CSettingInt*>(m_pSetting);
strText = CGUIControlSliderSetting::GetText(static_cast<const CSettingControlSlider*>(m_pSetting->GetControl()),
settingInt->GetValue(), settingInt->GetMinimum(), settingInt->GetStep(), settingInt->GetMaximum());
break;
}
case SettingTypeNumber:
{
const CSettingNumber *settingNumber = static_cast<CSettingNumber*>(m_pSetting);
strText = CGUIControlSliderSetting::GetText(static_cast<const CSettingControlSlider*>(m_pSetting->GetControl()),
settingNumber->GetValue(), settingNumber->GetMinimum(), settingNumber->GetStep(), settingNumber->GetMaximum());
break;
}
default:
break;
}
}
m_pButton->SetLabel2(strText);
}
