void DialogProgress::update(int percent, const String& line1,
const String& line2,
const String& line3)
{
DelayedCallGuard dcguard(languageHook);
CGUIDialogProgress* pDialog = dlg;
if (pDialog == NULL)
throw WindowException("Dialog not created.");
if (percent >= 0 && percent <= 100)
{
pDialog->SetPercentage(percent);
pDialog->ShowProgressBar(true);
}
else
{
pDialog->ShowProgressBar(false);
}
if (!line1.empty())
pDialog->SetLine(0, CVariant{line1});
if (!line2.empty())
pDialog->SetLine(1, CVariant{line2});
if (!line3.empty())
pDialog->SetLine(2, CVariant{line3});
}
bool CGUIMediaWindow::WaitForNetwork() const
{
if (g_application.getNetwork().IsAvailable())
return true;
CGUIDialogProgress *progress = (CGUIDialogProgress *)g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (!progress)
return true;
CURL url(m_vecItems->GetPath());
progress->SetHeading(1040); // Loading Directory
progress->SetLine(1, url.GetWithoutUserDetails());
progress->ShowProgressBar(false);
progress->StartModal();
while (!g_application.getNetwork().IsAvailable())
{
progress->Progress();
if (progress->IsCanceled())
{
progress->Close();
return false;
}
}
progress->Close();
return true;
}
/*! \brief Progress callback from rar manager.
\return true to continue processing, false to cancel.
*/
bool progress(int progress, const char *text)
{
bool cont(true);
if ((shown || showTime.IsTimePast()) && g_application.IsCurrentThread())
{
// grab the busy and show it
CGUIDialogProgress* dlg = (CGUIDialogProgress*)g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (dlg)
{
if (!shown)
{
dlg->SetHeading(CVariant{heading});
dlg->Open();
}
if (progress >= 0)
{
dlg->ShowProgressBar(true);
dlg->SetPercentage(progress);
}
if (text)
dlg->SetLine(1, CVariant{text});
cont = !dlg->IsCanceled();
shown = true;
// tell render loop to spin
dlg->Progress();
}
}
return cont;
};
void CGUIWindowPVRBase::OnInitWindow(void)
{
if (!g_PVRManager.IsStarted() || !g_PVRClients->HasConnectedClients())
{
// wait until the PVR manager has been started
CGUIDialogProgress* dialog = static_cast<CGUIDialogProgress*>(g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS));
if (dialog)
{
dialog->SetHeading(CVariant{19235});
dialog->SetText(CVariant{19045});
dialog->ShowProgressBar(false);
dialog->Open();
// do not block the gfx context while waiting
CSingleExit exit(g_graphicsContext);
CEvent event(true);
while(!event.WaitMSec(1))
{
if (g_PVRManager.IsStarted() && g_PVRClients->HasConnectedClients())
event.Set();
if (dialog->IsCanceled())
{
// return to previous window if canceled
dialog->Close();
g_windowManager.PreviousWindow();
return;
}
g_windowManager.ProcessRenderLoop(false);
}
dialog->Close();
}
}
{
// set window group to playing group
CPVRChannelGroupPtr group = g_PVRManager.GetPlayingGroup(m_bRadio);
CSingleLock lock(m_critSection);
if (m_group != group)
m_viewControl.SetSelectedItem(0);
m_group = group;
}
SetProperty("IsRadio", m_bRadio ? "true" : "");
m_vecItems->SetPath(GetDirectoryPath());
CGUIMediaWindow::OnInitWindow();
// mark item as selected by channel path
m_viewControl.SetSelectedItem(GetSelectedItemPath(m_bRadio));
}
void CMusicLibraryQueue::CleanLibrary(bool showDialog /* = false */)
{
CGUIDialogProgress* progress = NULL;
if (showDialog)
{
progress = g_windowManager.GetWindow<CGUIDialogProgress>(WINDOW_DIALOG_PROGRESS);
if (progress)
{
progress->SetHeading(CVariant{ 700 });
progress->SetPercentage(0);
progress->Open();
progress->ShowProgressBar(true);
}
}
CMusicLibraryCleaningJob* cleaningJob = new CMusicLibraryCleaningJob(progress);
AddJob(cleaningJob);
// Wait for cleaning to complete or be canceled, but render every 20ms so that the
// pointer movements work on dialog even when cleaning is reporting progress infrequently
if (progress)
progress->Wait(20);
}
void CMusicLibraryQueue::CleanLibraryModal()
{
// We can't perform a modal library cleaning if other jobs are running
if (IsRunning())
return;
CGUIDialogProgress* progress = nullptr;
progress = g_windowManager.GetWindow<CGUIDialogProgress>(WINDOW_DIALOG_PROGRESS);
if (progress)
{
progress->SetHeading(CVariant{ 700 });
progress->SetPercentage(0);
progress->Open();
progress->ShowProgressBar(true);
}
m_modal = true;
m_cleaning = true;
CMusicLibraryCleaningJob cleaningJob(progress);
cleaningJob.DoWork();
m_cleaning = false;
m_modal = false;
Refresh();
}
void CMusicLibraryQueue::ExportLibrary(const CLibExportSettings& settings, bool showDialog /* = false */)
{
CGUIDialogProgress* progress = NULL;
if (showDialog)
{
progress = g_windowManager.GetWindow<CGUIDialogProgress>(WINDOW_DIALOG_PROGRESS);
if (progress)
{
progress->SetHeading(CVariant{ 20196 }); //"Export music library"
progress->SetText(CVariant{ 650 }); //"Exporting"
progress->SetPercentage(0);
progress->Open();
progress->ShowProgressBar(true);
}
}
CMusicLibraryExportJob* exportJob = new CMusicLibraryExportJob(settings, progress);
if (showDialog)
{
AddJob(exportJob);
// Wait for export to complete or be canceled, but render every 10ms so that the
// pointer movements work on dialog even when export is reporting progress infrequently
if (progress)
progress->Wait();
}
else
{
m_modal = true;
exportJob->DoWork();
delete exportJob;
m_modal = false;
Refresh();
}
}
bool CMultiPathDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CLog::Log(LOGDEBUG,"CMultiPathDirectory::GetDirectory(%s)", strPath.c_str());
vector<CStdString> vecPaths;
if (!GetPaths(strPath, vecPaths))
return false;
unsigned int progressTime = CTimeUtils::GetTimeMS() + 3000L; // 3 seconds before showing progress bar
CGUIDialogProgress* dlgProgress = NULL;
unsigned int iFailures = 0;
for (unsigned int i = 0; i < vecPaths.size(); ++i)
{
// show the progress dialog if we have passed our time limit
if (CTimeUtils::GetTimeMS() > progressTime && !dlgProgress)
{
dlgProgress = (CGUIDialogProgress *)g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (dlgProgress)
{
dlgProgress->SetHeading(15310);
dlgProgress->SetLine(0, 15311);
dlgProgress->SetLine(1, "");
dlgProgress->SetLine(2, "");
dlgProgress->StartModal();
dlgProgress->ShowProgressBar(true);
dlgProgress->SetProgressMax((int)vecPaths.size()*2);
dlgProgress->Progress();
}
}
if (dlgProgress)
{
CURL url(vecPaths[i]);
dlgProgress->SetLine(1, url.GetWithoutUserDetails());
dlgProgress->SetProgressAdvance();
dlgProgress->Progress();
}
CFileItemList tempItems;
CLog::Log(LOGDEBUG,"Getting Directory (%s)", vecPaths[i].c_str());
if (CDirectory::GetDirectory(vecPaths[i], tempItems, m_strFileMask, m_useFileDirectories, m_allowPrompting, m_cacheDirectory, m_extFileInfo))
items.Append(tempItems);
else
{
CLog::Log(LOGERROR,"Error Getting Directory (%s)", vecPaths[i].c_str());
iFailures++;
}
if (dlgProgress)
{
dlgProgress->SetProgressAdvance();
dlgProgress->Progress();
}
}
if (dlgProgress)
dlgProgress->Close();
if (iFailures == vecPaths.size())
return false;
// merge like-named folders into a sub multipath:// style url
MergeItems(items);
return true;
}
bool CPlexDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CStdString strRoot = strPath;
if (CUtil::HasSlashAtEnd(strRoot) && strRoot != "plex://")
strRoot.Delete(strRoot.size() - 1);
strRoot.Replace(" ", "%20");
// Start the download thread running.
printf("PlexDirectory::GetDirectory(%s)\n", strRoot.c_str());
m_url = strRoot;
CThread::Create(false, 0);
// Now display progress, look for cancel.
CGUIDialogProgress* dlgProgress = 0;
int time = GetTickCount();
while (m_downloadEvent.WaitMSec(100) == false)
{
// If enough time has passed, display the dialog.
if (GetTickCount() - time > 1000 && m_allowPrompting == true)
{
dlgProgress = (CGUIDialogProgress*)m_gWindowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (dlgProgress)
{
dlgProgress->ShowProgressBar(false);
dlgProgress->SetHeading(40203);
dlgProgress->SetLine(0, 40204);
dlgProgress->SetLine(1, "");
dlgProgress->SetLine(2, "");
dlgProgress->StartModal();
}
}
if (dlgProgress)
{
dlgProgress->Progress();
if (dlgProgress->IsCanceled())
{
items.m_wasListingCancelled = true;
m_http.Cancel();
StopThread();
}
}
}
if (dlgProgress)
dlgProgress->Close();
// Wait for the thread to exit.
WaitForThreadExit(INFINITE);
// See if we suceeded.
if (m_bSuccess == false)
return false;
// See if we're supposed to parse the results or not.
if (m_bParseResults == false)
return true;
// Parse returned xml.
TiXmlDocument doc;
doc.Parse(m_data.c_str());
TiXmlElement* root = doc.RootElement();
if (root == 0)
{
CLog::Log(LOGERROR, "%s - Unable to parse XML\n%s", __FUNCTION__, m_data.c_str());
return false;
}
// Get the fanart.
const char* fanart = root->Attribute("art");
string strFanart;
if (fanart && strlen(fanart) > 0)
strFanart = ProcessUrl(strPath, fanart, false);
// Walk the parsed tree.
string strFileLabel = "%N - %T";
string strDirLabel = "%B";
string strSecondDirLabel = "%Y";
Parse(m_url, root, items, strFileLabel, strDirLabel, strSecondDirLabel);
// Set the window titles
const char* title1 = root->Attribute("title1");
const char* title2 = root->Attribute("title2");
if (title1 && strlen(title1) > 0)
items.SetFirstTitle(title1);
if (title2 && strlen(title2) > 0)
items.SetSecondTitle(title2);
// Set fanart on items if they don't have their own.
for (int i=0; i<items.Size(); i++)
{
CFileItemPtr pItem = items[i];
if (strFanart.size() > 0 && pItem->GetQuickFanart().size() == 0)
pItem->SetQuickFanart(strFanart);
// Make sure sort label is lower case.
string sortLabel = pItem->GetLabel();
boost::to_lower(sortLabel);
pItem->SetSortLabel(sortLabel);
}
// Set fanart on directory.
if (strFanart.size() > 0)
items.SetQuickFanart(strFanart);
// Set the view mode.
const char* viewmode = root->Attribute("viewmode");
if (viewmode && strlen(viewmode) > 0)
{
CGUIViewState* viewState = CGUIViewState::GetViewState(0, items);
viewState->SaveViewAsControl(atoi(viewmode));
}
// Override labels.
const char* fileLabel = root->Attribute("filelabel");
if (fileLabel && strlen(fileLabel) > 0)
strFileLabel = fileLabel;
const char* dirLabel = root->Attribute("dirlabel");
if (dirLabel && strlen(dirLabel) > 0)
strDirLabel = dirLabel;
// Add the sort method.
items.AddSortMethod(SORT_METHOD_NONE, 552, LABEL_MASKS(strFileLabel, "%D", strDirLabel, strSecondDirLabel));
// Set the content label.
const char* content = root->Attribute("content");
if (content && strlen(content) > 0)
{
items.SetContent(content);
}
// Check for dialog message attributes
CStdString strMessage = "";
const char* header = root->Attribute("header");
if (header && strlen(header) > 0)
{
const char* message = root->Attribute("message");
if (message && strlen(message) > 0)
strMessage = message;
items.m_displayMessage = true;
items.m_displayMessageTitle = header;
items.m_displayMessageContents = root->Attribute("message");
// Don't cache these.
m_dirCacheType = DIR_CACHE_NEVER;
}
// See if this directory replaces the parent.
const char* replace = root->Attribute("replaceParent");
if (replace && strcmp(replace, "1") == 0)
items.SetReplaceListing(true);
// See if we're saving this into the history or not.
const char* noHistory = root->Attribute("noHistory");
if (noHistory && strcmp(noHistory, "1") == 0)
items.SetSaveInHistory(false);
// See if we're not supposed to cache this directory.
const char* noCache = root->Attribute("nocache");
if (noCache && strcmp(noCache, "1") == 0)
m_dirCacheType = DIR_CACHE_NEVER;
return true;
}
bool CPluginDirectory::WaitOnScriptResult(const CStdString &scriptPath, int scriptId, const CStdString &scriptName, bool retrievingDir)
{
const unsigned int timeBeforeProgressBar = 1500;
const unsigned int timeToKillScript = 1000;
unsigned int startTime = XbmcThreads::SystemClockMillis();
CGUIDialogProgress *progressBar = NULL;
bool cancelled = false;
bool inMainAppThread = g_application.IsCurrentThread();
CLog::Log(LOGDEBUG, "%s - waiting on the %s (id=%d) plugin...", __FUNCTION__, scriptName.c_str(), scriptId);
while (true)
{
{
CSingleExit ex(g_graphicsContext);
// check if the python script is finished
if (m_fetchComplete.WaitMSec(20))
{ // python has returned
CLog::Log(LOGDEBUG, "%s- plugin returned %s", __FUNCTION__, m_success ? "successfully" : "failure");
break;
}
}
// check our script is still running
if (!CScriptInvocationManager::Get().IsRunning(scriptId))
{ // check whether we exited normally
if (!m_fetchComplete.WaitMSec(0))
{ // python didn't return correctly
CLog::Log(LOGDEBUG, " %s - plugin exited prematurely - terminating", __FUNCTION__);
m_success = false;
}
break;
}
// check whether we should pop up the progress dialog
if (!retrievingDir && !progressBar && XbmcThreads::SystemClockMillis() - startTime > timeBeforeProgressBar)
{ // loading takes more then 1.5 secs, show a progress dialog
progressBar = (CGUIDialogProgress *)g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
// if script has shown progressbar don't override it
if (progressBar && progressBar->IsActive())
{
startTime = XbmcThreads::SystemClockMillis();
progressBar = NULL;
}
if (progressBar)
{
progressBar->SetHeading(scriptName);
progressBar->SetLine(0, retrievingDir ? 1040 : 10214);
progressBar->SetLine(1, "");
progressBar->SetLine(2, "");
progressBar->ShowProgressBar(retrievingDir);
progressBar->StartModal();
}
}
if (progressBar)
{ // update the progress bar and check for user cancel
progressBar->Progress();
if (progressBar->IsCanceled())
{ // user has cancelled our process - cancel our process
m_cancelled = true;
}
}
else // if the progressBar exists and we call StartModal or Progress we get the
// ProcessRenderLoop call anyway.
if (inMainAppThread)
g_windowManager.ProcessRenderLoop();
if (!cancelled && m_cancelled)
{
cancelled = true;
startTime = XbmcThreads::SystemClockMillis();
}
if (cancelled && XbmcThreads::SystemClockMillis() - startTime > timeToKillScript)
{ // cancel our script
if (scriptId != -1 && CScriptInvocationManager::Get().IsRunning(scriptId))
{
CLog::Log(LOGDEBUG, "%s- cancelling plugin %s (id=%d)", __FUNCTION__, scriptName.c_str(), scriptId);
CScriptInvocationManager::Get().Stop(scriptId);
break;
}
}
}
if (progressBar)
CApplicationMessenger::Get().Close(progressBar, false, false);
return !cancelled && m_success;
}
bool CMultiPathDirectory::GetDirectory(const CURL& url, CFileItemList &items)
{
CLog::Log(LOGDEBUG,"CMultiPathDirectory::GetDirectory(%s)", url.GetRedacted().c_str());
std::vector<std::string> vecPaths;
if (!GetPaths(url, vecPaths))
return false;
XbmcThreads::EndTime progressTime(3000); // 3 seconds before showing progress bar
CGUIDialogProgress* dlgProgress = NULL;
unsigned int iFailures = 0;
for (unsigned int i = 0; i < vecPaths.size(); ++i)
{
// show the progress dialog if we have passed our time limit
if (progressTime.IsTimePast() && !dlgProgress)
{
dlgProgress = g_windowManager.GetWindow<CGUIDialogProgress>(WINDOW_DIALOG_PROGRESS);
if (dlgProgress)
{
dlgProgress->SetHeading(CVariant{15310});
dlgProgress->SetLine(0, CVariant{15311});
dlgProgress->SetLine(1, CVariant{""});
dlgProgress->SetLine(2, CVariant{""});
dlgProgress->Open();
dlgProgress->ShowProgressBar(true);
dlgProgress->SetProgressMax((int)vecPaths.size()*2);
dlgProgress->Progress();
}
}
if (dlgProgress)
{
CURL url(vecPaths[i]);
dlgProgress->SetLine(1, CVariant{url.GetWithoutUserDetails()});
dlgProgress->SetProgressAdvance();
dlgProgress->Progress();
}
CFileItemList tempItems;
CLog::Log(LOGDEBUG,"Getting Directory (%s)", vecPaths[i].c_str());
if (CDirectory::GetDirectory(vecPaths[i], tempItems, m_strFileMask, m_flags))
items.Append(tempItems);
else
{
CLog::Log(LOGERROR,"Error Getting Directory (%s)", vecPaths[i].c_str());
iFailures++;
}
if (dlgProgress)
{
dlgProgress->SetProgressAdvance();
dlgProgress->Progress();
}
}
if (dlgProgress)
dlgProgress->Close();
if (iFailures == vecPaths.size())
return false;
// merge like-named folders into a sub multipath:// style url
MergeItems(items);
return true;
}
bool CShoutcastDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CStdString strRoot = strPath;
if (CUtil::HasSlashAtEnd(strRoot))
strRoot.Delete(strRoot.size() - 1);
/* for old users wich doesn't have the full url */
if( strRoot.Equals("shout://www.shoutcast.com") )
strRoot = "shout://www.shoutcast.com/sbin/newxml.phtml";
if (g_directoryCache.GetDirectory(strRoot, items))
return true;
CGUIDialogProgress* dlgProgress = (CGUIDialogProgress*)m_gWindowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (dlgProgress)
{
dlgProgress->ShowProgressBar(false);
dlgProgress->SetHeading(260);
dlgProgress->SetLine(0, 14003);
dlgProgress->SetLine(1, "");
dlgProgress->SetLine(2, "");
dlgProgress->StartModal();
}
CURL url(strRoot);
CStdString protocol = url.GetProtocol();
url.SetProtocol("http");
CFileCurl http;
//CURL doesn't seem to understand that data is encoded.. odd
// opening as text for now
//http.SetContentEncoding("deflate");
if( !http.Open(url, false) )
{
CLog::Log(LOGERROR, "%s - Unable to get shoutcast dir", __FUNCTION__);
if (dlgProgress) dlgProgress->Close();
return false;
}
/* restore protocol */
url.SetProtocol(protocol);
CStdString content = http.GetContent();
if( !(content.Equals("text/html") || content.Equals("text/xml")
|| content.Equals("text/html;charset=utf-8") || content.Equals("text/xml;charset=utf-8") ))
{
CLog::Log(LOGERROR, "%s - Invalid content type %s", __FUNCTION__, content.c_str());
if (dlgProgress) dlgProgress->Close();
return false;
}
int size_read = 0;
int size_total = (int)http.GetLength();
int data_size = 0;
CStdString data;
data.reserve(size_total);
/* read response from server into string buffer */
char buffer[16384];
while( (size_read = http.Read(buffer, sizeof(buffer)-1)) > 0 )
{
buffer[size_read] = 0;
data += buffer;
data_size += size_read;
dlgProgress->Progress();
if (dlgProgress->IsCanceled())
{
dlgProgress->Close();
return false;
}
}
/* parse returned xml */
TiXmlDocument doc;
doc.Parse(data.c_str());
TiXmlElement *root = doc.RootElement();
if(root == NULL)
{
CLog::Log(LOGERROR, "%s - Unable to parse xml", __FUNCTION__);
CLog::Log(LOGDEBUG, "%s - Sample follows...\n%s", __FUNCTION__, data.c_str());
dlgProgress->Close();
return false;
}
/* clear data to keep memusage down, not needed anymore */
data.Empty();
bool result = false;
if( strcmp(root->Value(), "genrelist") == 0 )
result = ParseGenres(root, items, url);
else if( strcmp(root->Value(), "stationlist") == 0 )
result = ParseStations(root, items, url);
else
{
CLog::Log(LOGERROR, "%s - Invalid root xml element for shoutcast",__FUNCTION__);
CLog::Log(LOGDEBUG, "%s - Sample follows...\n%s", __FUNCTION__, data.c_str());
}
CFileItemList vecCacheItems;
g_directoryCache.ClearDirectory(strRoot);
for( int i = 0; i <items.Size(); i++ )
{
CFileItem* pItem=items[i];
if (!pItem->IsParentFolder())
vecCacheItems.Add(new CFileItem( *pItem ));
}
g_directoryCache.SetDirectory(strRoot, vecCacheItems);
if (dlgProgress) dlgProgress->Close();
return result;
}
bool CCDDARipJob::DoWork()
{
CLog::Log(LOGINFO, "Start ripping track %s to %s", m_input.c_str(),
m_output.c_str());
// if we are ripping to a samba share, rip it to hd first and then copy it it the share
CFileItem file(m_output, false);
if (file.IsRemote())
m_output = SetupTempFile();
if (m_output.IsEmpty())
{
CLog::Log(LOGERROR, "CCDDARipper: Error opening file");
return false;
}
// init ripper
CFile reader;
CEncoder* encoder;
if (!reader.Open(m_input,READ_CACHED) || !(encoder=SetupEncoder(reader)))
{
CLog::Log(LOGERROR, "Error: CCDDARipper::Init failed");
return false;
}
// setup the progress dialog
CGUIDialogProgress* pDlgProgress = (CGUIDialogProgress*)g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
CStdString strLine0, strLine1;
int iTrack = atoi(m_input.substr(13, m_input.size() - 13 - 5).c_str());
strLine0.Format("%s %i", g_localizeStrings.Get(606).c_str(), iTrack); // Track Number: %i
strLine1.Format("%s %s", g_localizeStrings.Get(607).c_str(), m_output.c_str()); // To: %s
pDlgProgress->SetHeading(605); // Ripping
pDlgProgress->SetLine(0, strLine0);
pDlgProgress->SetLine(1, strLine1);
pDlgProgress->SetLine(2, "");
pDlgProgress->StartModal();
pDlgProgress->ShowProgressBar(true);
// show progress dialog
pDlgProgress->Progress();
// start ripping
int percent=0;
int oldpercent=0;
bool cancelled(false);
int result;
while (!cancelled && (result=RipChunk(reader, encoder, percent)) == 0)
{
cancelled = ShouldCancel(percent,100);
cancelled |= pDlgProgress->IsCanceled();
if (percent > oldpercent)
{
oldpercent = percent;
pDlgProgress->SetPercentage(percent);
pDlgProgress->Progress();
}
}
pDlgProgress->Close();
// close encoder ripper
encoder->Close();
delete encoder;
reader.Close();
if (file.IsRemote() && !cancelled && result == 2)
{
// copy the ripped track to the share
if (!CFile::Cache(m_output, file.GetPath()))
{
CLog::Log(LOGERROR, "CDDARipper: Error copying file from %s to %s",
m_output.c_str(), file.GetPath().c_str());
CFile::Delete(m_output);
return false;
}
// delete cached file
CFile::Delete(m_output);
}
if (cancelled)
{
CLog::Log(LOGWARNING, "User Cancelled CDDA Rip");
CFile::Delete(m_output);
}
else if (result == 1)
CLog::Log(LOGERROR, "CDDARipper: Error ripping %s", m_input.c_str());
else if (result < 0)
CLog::Log(LOGERROR, "CDDARipper: Error encoding %s", m_input.c_str());
else
{
CLog::Log(LOGINFO, "Finished ripping %s", m_input.c_str());
if (m_eject)
{
CLog::Log(LOGINFO, "Ejecting CD");
g_mediaManager.EjectTray();
}
}
return !cancelled && result == 2;
}
bool CVirtualPathDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CLog::Log(LOGDEBUG,"CVirtualPathDirectory::GetDirectory(%s)", strPath.c_str());
CMediaSource share;
if (!GetMatchingSource(strPath, share))
return false;
DWORD progressTime = timeGetTime() + 3000L; // 3 seconds before showing progress bar
CGUIDialogProgress* dlgProgress = NULL;
unsigned int iFailures = 0;
for (int i = 0; i < (int)share.vecPaths.size(); ++i)
{
// show the progress dialog if we have passed our time limit
if (timeGetTime() > progressTime && !dlgProgress)
{
dlgProgress = (CGUIDialogProgress *)m_gWindowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (dlgProgress)
{
dlgProgress->SetHeading(15310);
dlgProgress->SetLine(0, 15311);
dlgProgress->SetLine(1, "");
dlgProgress->SetLine(2, "");
dlgProgress->StartModal();
dlgProgress->ShowProgressBar(true);
dlgProgress->SetProgressMax((int)share.vecPaths.size()*2);
dlgProgress->Progress();
}
}
if (dlgProgress)
{
CURL url(share.vecPaths[i]);
CStdString strStripped;
url.GetURLWithoutUserDetails(strStripped);
dlgProgress->SetLine(1, strStripped);
dlgProgress->SetProgressAdvance();
dlgProgress->Progress();
}
CFileItemList tempItems;
CLog::Log(LOGDEBUG,"Getting Directory (%s)", share.vecPaths[i].c_str());
if (CDirectory::GetDirectory(share.vecPaths[i], tempItems, m_strFileMask, m_useFileDirectories, m_allowPrompting, m_cacheDirectory, m_extFileInfo))
items.Append(tempItems);
else
{
CLog::Log(LOGERROR,"Error Getting Directory (%s)", share.vecPaths[i].c_str());
iFailures++;
}
if (dlgProgress)
{
dlgProgress->SetProgressAdvance();
dlgProgress->Progress();
}
}
if (dlgProgress)
dlgProgress->Close();
if (iFailures == share.vecPaths.size())
return false;
return true;
}
bool CPluginDirectory::WaitOnScriptResult(const CStdString &scriptPath, const CStdString &scriptName, bool retrievingDir)
{
const unsigned int timeBeforeProgressBar = 1500;
const unsigned int timeToKillScript = 1000;
unsigned int startTime = XbmcThreads::SystemClockMillis();
CGUIDialogProgress *progressBar = NULL;
CLog::Log(LOGDEBUG, "%s - waiting on the %s plugin...", __FUNCTION__, scriptName.c_str());
while (true)
{
{
CSingleExit ex(g_graphicsContext);
// check if the python script is finished
if (m_fetchComplete.WaitMSec(20))
{ // python has returned
CLog::Log(LOGDEBUG, "%s- plugin returned %s", __FUNCTION__, m_success ? "successfully" : "failure");
break;
}
}
// check our script is still running
#ifdef HAS_PYTHON
if (!g_pythonParser.isRunning(g_pythonParser.getScriptId(scriptPath.c_str())))
#endif
{ // check whether we exited normally
if (!m_fetchComplete.WaitMSec(0))
{ // python didn't return correctly
CLog::Log(LOGDEBUG, " %s - plugin exited prematurely - terminating", __FUNCTION__);
m_success = false;
}
break;
}
// check whether we should pop up the progress dialog
if (!progressBar && XbmcThreads::SystemClockMillis() - startTime > timeBeforeProgressBar)
{ // loading takes more then 1.5 secs, show a progress dialog
progressBar = (CGUIDialogProgress *)g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
// if script has shown progressbar don't override it
if (progressBar && progressBar->IsActive())
{
startTime = XbmcThreads::SystemClockMillis();
progressBar = NULL;
}
if (progressBar)
{
progressBar->SetHeading(scriptName);
progressBar->SetLine(0, retrievingDir ? 1040 : 10214);
progressBar->SetLine(1, "");
progressBar->SetLine(2, "");
progressBar->ShowProgressBar(retrievingDir);
progressBar->StartModal();
}
}
if (progressBar)
{ // update the progress bar and check for user cancel
if (retrievingDir)
{
CStdString label;
if (m_totalItems > 0)
{
label.Format(g_localizeStrings.Get(1042).c_str(), m_listItems->Size(), m_totalItems);
progressBar->SetPercentage((int)((m_listItems->Size() * 100 ) / m_totalItems));
progressBar->ShowProgressBar(true);
}
else
label.Format(g_localizeStrings.Get(1041).c_str(), m_listItems->Size());
progressBar->SetLine(2, label);
}
progressBar->Progress();
if (progressBar->IsCanceled())
{ // user has cancelled our process - cancel our process
if (!m_cancelled)
{
m_cancelled = true;
startTime = XbmcThreads::SystemClockMillis();
}
if (m_cancelled && XbmcThreads::SystemClockMillis() - startTime > timeToKillScript)
{ // cancel our script
#ifdef HAS_PYTHON
int id = g_pythonParser.getScriptId(scriptPath.c_str());
if (id != -1 && g_pythonParser.isRunning(id))
{
CLog::Log(LOGDEBUG, "%s- cancelling plugin %s", __FUNCTION__, scriptName.c_str());
g_pythonParser.stopScript(id);
break;
}
#endif
}
}
}
}
if (progressBar)
CApplicationMessenger::Get().Close(progressBar, false, false);
return !m_cancelled && m_success;
}
bool CPluginDirectory::WaitOnScriptResult(const CStdString &scriptPath, const CStdString &scriptName)
{
const unsigned int timeBeforeProgressBar = 1500;
const unsigned int timeToKillScript = 1000;
DWORD startTime = timeGetTime();
CGUIDialogProgress *progressBar = NULL;
CLog::Log(LOGDEBUG, "%s - waiting on the %s plugin...", __FUNCTION__, scriptName.c_str());
while (true)
{
// check if the python script is finished
if (WaitForSingleObject(m_directoryFetched, 20) == WAIT_OBJECT_0)
{ // python has returned
CLog::Log(LOGDEBUG, "%s- plugin returned %s", __FUNCTION__, m_success ? "successfully" : "failure");
break;
}
// check our script is still running
int id = g_pythonParser.getScriptId(scriptPath.c_str());
if (id == -1)
{ // nope - bail
CLog::Log(LOGDEBUG, " %s - plugin exited prematurely - terminating", __FUNCTION__);
m_success = false;
break;
}
// check whether we should pop up the progress dialog
if (!progressBar && timeGetTime() - startTime > timeBeforeProgressBar)
{ // loading takes more then 1.5 secs, show a progress dialog
progressBar = (CGUIDialogProgress *)m_gWindowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (progressBar)
{
progressBar->SetHeading(scriptName);
progressBar->SetLine(0, 1040);
progressBar->SetLine(1, "");
progressBar->SetLine(2, "");
progressBar->StartModal();
}
}
if (progressBar)
{ // update the progress bar and check for user cancel
CStdString label;
if (m_totalItems > 0)
{
label.Format(g_localizeStrings.Get(1042).c_str(), m_listItems->Size(), m_totalItems);
progressBar->SetPercentage((int)((m_listItems->Size() * 100 ) / m_totalItems));
progressBar->ShowProgressBar(true);
}
else
label.Format(g_localizeStrings.Get(1041).c_str(), m_listItems->Size());
progressBar->SetLine(2, label);
progressBar->Progress();
if (progressBar->IsCanceled())
{ // user has cancelled our process - cancel our process
if (!m_cancelled)
{
m_cancelled = true;
startTime = timeGetTime();
}
if (m_cancelled && timeGetTime() - startTime > timeToKillScript)
{ // cancel our script
int id = g_pythonParser.getScriptId(scriptPath.c_str());
if (id != -1 && g_pythonParser.isRunning(id))
{
CLog::Log(LOGDEBUG, "%s- cancelling plugin %s", __FUNCTION__, scriptName.c_str());
g_pythonParser.stopScript(id);
break;
}
}
}
}
}
if (progressBar)
progressBar->Close();
return !m_cancelled && m_success;
}
/*----------------------------------------------------------------------
| CUPnPDirectory::GetDirectory
+---------------------------------------------------------------------*/
bool
CUPnPDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CGUIDialogProgress* dlgProgress = NULL;
CUPnP* upnp = CUPnP::GetInstance();
/* upnp should never be cached, it has internal cache */
items.SetCacheToDisc(CFileItemList::CACHE_NEVER);
// start client if it hasn't been done yet
bool client_started = upnp->IsClientStarted();
upnp->StartClient();
// We accept upnp://devuuid/[item_id/]
NPT_String path = strPath.c_str();
if (!path.StartsWith("upnp://", true)) {
return false;
}
if (path.Compare("upnp://", true) == 0) {
// root -> get list of devices
const NPT_Lock<PLT_DeviceMap>& devices = upnp->m_MediaBrowser->GetMediaServers();
const NPT_List<PLT_DeviceMapEntry*>& entries = devices.GetEntries();
NPT_List<PLT_DeviceMapEntry*>::Iterator entry = entries.GetFirstItem();
while (entry) {
PLT_DeviceDataReference device = (*entry)->GetValue();
NPT_String name = device->GetFriendlyName();
NPT_String uuid = (*entry)->GetKey();
CFileItemPtr pItem(new CFileItem((const char*)name));
pItem->m_strPath = (const char*) "upnp://" + uuid + "/";
pItem->m_bIsFolder = true;
pItem->SetThumbnailImage((const char*)device->GetIconUrl("image/jpeg"));
items.Add(pItem);
++entry;
}
} else {
if (!path.EndsWith("/")) path += "/";
// look for nextslash
int next_slash = path.Find('/', 7);
NPT_String uuid = (next_slash==-1)?path.SubString(7):path.SubString(7, next_slash-7);
NPT_String object_id = (next_slash==-1)?"":path.SubString(next_slash+1);
object_id.TrimRight("/");
if (object_id.GetLength()) {
CStdString tmp = (char*) object_id;
CUtil::UrlDecode(tmp);
object_id = tmp;
}
// look for device in our list
// (and wait for it to respond for 5 secs if we're just starting upnp client)
NPT_TimeStamp watchdog;
NPT_System::GetCurrentTimeStamp(watchdog);
watchdog += 5.f;
PLT_DeviceDataReference* device;
for (;;) {
const NPT_Lock<PLT_DeviceMap>& devices = upnp->m_MediaBrowser->GetMediaServers();
if (NPT_SUCCEEDED(devices.Get(uuid, device)) && device)
break;
// fail right away if device not found and upnp client was already running
if (client_started)
goto failure;
// otherwise check if we've waited long enough without success
NPT_TimeStamp now;
NPT_System::GetCurrentTimeStamp(now);
if (now > watchdog)
goto failure;
// sleep a bit and try again
NPT_System::Sleep(NPT_TimeInterval(1, 0));
}
// issue a browse request with object_id
// if object_id is empty use "0" for root
object_id = object_id.IsEmpty()?"0":object_id;
// just a guess as to what types of files we want
bool video = true;
bool audio = true;
bool image = true;
m_strFileMask.TrimLeft("/");
if (!m_strFileMask.IsEmpty()) {
video = m_strFileMask.Find(".wmv") >= 0;
audio = m_strFileMask.Find(".wma") >= 0;
image = m_strFileMask.Find(".jpg") >= 0;
}
// special case for Windows Media Connect and WMP11 when looking for root
// We can target which root subfolder we want based on directory mask
if (object_id == "0" && (((*device)->GetFriendlyName().Find("Windows Media Connect", 0, true) >= 0) ||
((*device)->m_ModelName == "Windows Media Player Sharing"))) {
// look for a specific type to differentiate which folder we want
if (audio && !video && !image) {
// music
object_id = "1";
} else if (!audio && video && !image) {
// video
object_id = "2";
} else if (!audio && !video && image) {
// pictures
object_id = "3";
}
}
#ifdef DISABLE_SPECIALCASE
// same thing but special case for XBMC
if (object_id == "0" && (((*device)->m_ModelName.Find("XBMC", 0, true) >= 0) ||
((*device)->m_ModelName.Find("Xbox Media Center", 0, true) >= 0))) {
// look for a specific type to differentiate which folder we want
if (audio && !video && !image) {
// music
object_id = "virtualpath://upnpmusic";
} else if (!audio && video && !image) {
// video
object_id = "virtualpath://upnpvideo";
} else if (!audio && !video && image) {
// pictures
object_id = "virtualpath://upnppictures";
}
}
#endif
// bring up dialog if object is not cached
if (!upnp->m_MediaBrowser->IsCached(uuid, object_id)) {
dlgProgress = (CGUIDialogProgress*)m_gWindowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (dlgProgress) {
dlgProgress->ShowProgressBar(false);
dlgProgress->SetCanCancel(false);
dlgProgress->SetHeading(20334);
dlgProgress->SetLine(0, 194);
dlgProgress->SetLine(1, "");
dlgProgress->SetLine(2, "");
dlgProgress->StartModal();
}
}
// if error, return now, the device could have gone away
// this will make us go back to the sources list
PLT_MediaObjectListReference list;
NPT_Result res = upnp->m_MediaBrowser->Browse(*device, object_id, list);
if (NPT_FAILED(res)) goto failure;
// empty list is ok
if (list.IsNull()) goto cleanup;
PLT_MediaObjectList::Iterator entry = list->GetFirstItem();
while (entry) {
// disregard items with wrong class/type
if( (!video && (*entry)->m_ObjectClass.type.CompareN("object.item.videoitem", 21,true) == 0)
|| (!audio && (*entry)->m_ObjectClass.type.CompareN("object.item.audioitem", 21,true) == 0)
|| (!image && (*entry)->m_ObjectClass.type.CompareN("object.item.imageitem", 21,true) == 0) )
{
++entry;
continue;
}
// never show empty containers in media views
if((*entry)->IsContainer()) {
if( (audio || video || image)
&& ((PLT_MediaContainer*)(*entry))->m_ChildrenCount == 0) {
++entry;
continue;
}
}
CFileItemPtr pItem(new CFileItem((const char*)(*entry)->m_Title));
pItem->SetLabelPreformated(true);
pItem->m_bIsFolder = (*entry)->IsContainer();
// if it's a container, format a string as upnp://uuid/object_id
if (pItem->m_bIsFolder) {
CStdString id = (char*) (*entry)->m_ObjectID;
CUtil::URLEncode(id);
pItem->m_strPath = (const char*) "upnp://" + uuid + "/" + id.c_str() + "/";
} else {
if ((*entry)->m_Resources.GetItemCount()) {
PLT_MediaItemResource& resource = (*entry)->m_Resources[0];
// look for a resource with "xbmc-get" protocol
// if we can't find one, keep the first resource
NPT_ContainerFind((*entry)->m_Resources,
CProtocolFinder("xbmc-get"),
resource);
CLog::Log(LOGDEBUG, "CUPnPDirectory::GetDirectory - resource protocol info '%s'", (const char*)(resource.m_ProtocolInfo));
// if it's an item, path is the first url to the item
// we hope the server made the first one reachable for us
// (it could be a format we dont know how to play however)
pItem->m_strPath = (const char*) resource.m_Uri;
// set metadata
if (resource.m_Size > 0) {
pItem->m_dwSize = resource.m_Size;
}
// set a general content type
CStdString type = (const char*)(*entry)->m_ObjectClass.type.Left(21);
if (type.Equals("object.item.videoitem"))
pItem->SetContentType("video/octet-stream");
else if(type.Equals("object.item.audioitem"))
pItem->SetContentType("audio/octet-stream");
else if(type.Equals("object.item.imageitem"))
pItem->SetContentType("image/octet-stream");
// look for content type in protocol info
if (resource.m_ProtocolInfo.GetLength()) {
char proto[1024];
char dummy1[1024];
char ct[1204];
char dummy2[1024];
int fields = sscanf(resource.m_ProtocolInfo, "%[^:]:%[^:]:%[^:]:%[^:]", proto, dummy1, ct, dummy2);
if (fields == 4) {
if (strcmp(ct, "application/octet-stream") != 0) {
pItem->SetContentType(ct);
}
} else {
CLog::Log(LOGERROR, "CUPnPDirectory::GetDirectory - invalid protocol info '%s'", (const char*)(resource.m_ProtocolInfo));
}
}
// look for date?
if((*entry)->m_Description.date.GetLength()) {
SYSTEMTIME time = {};
sscanf((*entry)->m_Description.date, "%hu-%hu-%huT%hu:%hu:%hu",
&time.wYear, &time.wMonth, &time.wDay, &time.wHour, &time.wMinute, &time.wSecond);
pItem->m_dateTime = time;
}
// look for metadata
if( (*entry)->m_ObjectClass.type.CompareN("object.item.videoitem", 21,true) == 0 ) {
pItem->SetLabelPreformated(false);
CUPnP::PopulateTagFromObject(*pItem->GetVideoInfoTag(), *(*entry), &resource);
} else if( (*entry)->m_ObjectClass.type.CompareN("object.item.audioitem", 21,true) == 0 ) {
pItem->SetLabelPreformated(false);
CUPnP::PopulateTagFromObject(*pItem->GetMusicInfoTag(), *(*entry), &resource);
} else if( (*entry)->m_ObjectClass.type.CompareN("object.item.imageitem", 21,true) == 0 ) {
//CPictureInfoTag* tag = pItem->GetPictureInfoTag();
}
}
}
// if there is a thumbnail available set it here
if((*entry)->m_ExtraInfo.album_art_uri.GetLength())
pItem->SetThumbnailImage((const char*) (*entry)->m_ExtraInfo.album_art_uri);
else if((*entry)->m_Description.icon_uri.GetLength())
pItem->SetThumbnailImage((const char*) (*entry)->m_Description.icon_uri);
items.Add(pItem);
++entry;
}
}
cleanup:
if (dlgProgress) dlgProgress->Close();
return true;
failure:
if (dlgProgress) dlgProgress->Close();
return false;
}