CStdString CMusicDatabaseFile::TranslateUrl(const CURL& url)
{
CMusicDatabase musicDatabase;
if (!musicDatabase.Open())
return "";
CStdString strFileName=URIUtils::GetFileName(url.Get());
CStdString strExtension = URIUtils::GetExtension(strFileName);
URIUtils::RemoveExtension(strFileName);
if (!StringUtils::IsNaturalNumber(strFileName))
return "";
long idSong=atol(strFileName.c_str());
CSong song;
if (!musicDatabase.GetSong(idSong, song))
return "";
if (!URIUtils::HasExtension(song.strFileName, strExtension))
return "";
return song.strFileName;
}
bool CFile::OpenForWrite(const CURL& file, bool bOverWrite)
{
try
{
CURL url = URIUtils::SubstitutePath(file);
m_pFile = CFileFactory::CreateLoader(url);
if (m_pFile && m_pFile->OpenForWrite(url, bOverWrite))
{
// add this file to our directory cache (if it's stored)
g_directoryCache.AddFile(url.Get());
return true;
}
return false;
}
XBMCCOMMONS_HANDLE_UNCHECKED
catch(...)
{
CLog::Log(LOGERROR, "%s - Unhandled exception opening %s", __FUNCTION__, file.GetRedacted().c_str());
}
CLog::Log(LOGERROR, "%s - Error opening %s", __FUNCTION__, file.GetRedacted().c_str());
return false;
}
bool CAndroidAppDirectory::GetDirectory(const CURL& url, CFileItemList &items)
{
std::string dirname = url.GetFileName();
URIUtils::RemoveSlashAtEnd(dirname);
CLog::Log(LOGDEBUG, "CAndroidAppDirectory::GetDirectory: %s",dirname.c_str());
std::string appName = CCompileInfo::GetAppName();
StringUtils::ToLower(appName);
std::string className = CCompileInfo::GetPackage();
if (dirname == "apps")
{
std::vector<androidPackage> applications = CXBMCApp::GetApplications();
if (applications.empty())
{
CLog::Log(LOGERROR, "CAndroidAppDirectory::GetDirectory Application lookup listing failed");
return false;
}
for(std::vector<androidPackage>::iterator i = applications.begin(); i != applications.end(); ++i)
{
if ((*i).packageName == className.c_str())
continue;
CFileItemPtr pItem(new CFileItem((*i).packageName));
pItem->m_bIsFolder = false;
std::string path = StringUtils::Format("androidapp://%s/%s/%s", url.GetHostName().c_str(), dirname.c_str(), (*i).packageName.c_str());
pItem->SetPath(path);
pItem->SetLabel((*i).packageLabel);
pItem->SetArt("thumb", path+".png");
pItem->m_dwSize = -1; // No size
items.Add(pItem);
}
return true;
}
CLog::Log(LOGERROR, "CAndroidAppDirectory::GetDirectory Failed to open %s", url.Get().c_str());
return false;
}
void CCurlFile::ParseAndCorrectUrl(CURL &url2)
{
CStdString strProtocol = url2.GetTranslatedProtocol();
url2.SetProtocol(strProtocol);
if( strProtocol.Equals("ftp")
|| strProtocol.Equals("ftps") )
{
/* this is uggly, depending on from where */
/* we get the link it may or may not be */
/* url encoded. if handed from ftpdirectory */
/* it won't be so let's handle that case */
CStdString partial, filename(url2.GetFileName());
CStdStringArray array;
/* our current client doesn't support utf8 */
g_charsetConverter.utf8ToStringCharset(filename);
/* TODO: create a tokenizer that doesn't skip empty's */
CUtil::Tokenize(filename, array, "/");
filename.Empty();
for(CStdStringArray::iterator it = array.begin(); it != array.end(); it++)
{
if(it != array.begin())
filename += "/";
partial = *it;
CURL::Encode(partial);
filename += partial;
}
/* make sure we keep slashes */
if(url2.GetFileName().Right(1) == "/")
filename += "/";
url2.SetFileName(filename);
CStdString options = url2.GetOptions().Mid(1);
options.TrimRight('/'); // hack for trailing slashes being added from source
m_ftpauth = "";
m_ftpport = "";
m_ftppasvip = false;
/* parse options given */
CUtil::Tokenize(options, array, "&");
for(CStdStringArray::iterator it = array.begin(); it != array.end(); it++)
{
CStdString name, value;
int pos = it->Find('=');
if(pos >= 0)
{
name = it->Left(pos);
value = it->Mid(pos+1, it->size());
}
else
{
name = (*it);
value = "";
}
if(name.Equals("auth"))
{
m_ftpauth = value;
if(m_ftpauth.IsEmpty())
m_ftpauth = "any";
}
else if(name.Equals("active"))
{
m_ftpport = value;
if(value.IsEmpty())
m_ftpport = "-";
}
else if(name.Equals("pasvip"))
{
if(value == "0")
m_ftppasvip = false;
else
m_ftppasvip = true;
}
}
/* ftp has no options */
url2.SetOptions("");
}
else if( strProtocol.Equals("http")
|| strProtocol.Equals("https"))
{
if (g_guiSettings.GetBool("network.usehttpproxy")
&& !g_guiSettings.GetString("network.httpproxyserver").empty()
&& !g_guiSettings.GetString("network.httpproxyport").empty()
&& m_proxy.IsEmpty())
{
m_proxy = g_guiSettings.GetString("network.httpproxyserver");
m_proxy += ":" + g_guiSettings.GetString("network.httpproxyport");
if (g_guiSettings.GetString("network.httpproxyusername").length() > 0 && m_proxyuserpass.IsEmpty())
{
m_proxyuserpass = g_guiSettings.GetString("network.httpproxyusername");
m_proxyuserpass += ":" + g_guiSettings.GetString("network.httpproxypassword");
}
m_proxytype = (ProxyType)g_guiSettings.GetInt("network.httpproxytype");
CLog::Log(LOGDEBUG, "Using proxy %s, type %d", m_proxy.c_str(), proxyType2CUrlProxyType[m_proxytype]);
}
// get username and password
m_username = url2.GetUserName();
m_password = url2.GetPassWord();
// handle any protocol options
CStdString options = url2.GetProtocolOptions();
options.TrimRight('/'); // hack for trailing slashes being added from source
if (options.length() > 0)
{
// clear protocol options
url2.SetProtocolOptions("");
// set xbmc headers
CStdStringArray array;
CUtil::Tokenize(options, array, "&");
for(CStdStringArray::iterator it = array.begin(); it != array.end(); it++)
{
// parse name, value
CStdString name, value;
int pos = it->Find('=');
if(pos >= 0)
{
name = it->Left(pos);
value = it->Mid(pos+1, it->size());
}
else
{
name = (*it);
value = "";
}
// url decode value
CURL::Decode(value);
if(name.Equals("auth"))
{
m_httpauth = value;
if(m_httpauth.IsEmpty())
m_httpauth = "any";
}
else if (name.Equals("Referer"))
SetReferer(value);
else if (name.Equals("User-Agent"))
SetUserAgent(value);
else if (name.Equals("Cookie"))
SetCookie(value);
else if (name.Equals("Encoding"))
SetContentEncoding(value);
else if (name.Equals("noshout") && value.Equals("true"))
m_skipshout = true;
else
SetRequestHeader(name, value);
}
}
}
if (m_username.length() > 0 && m_password.length() > 0)
m_url = url2.GetWithoutUserDetails();
else
m_url = url2.Get();
}
int CCurlFile::Stat(const CURL& url, struct __stat64* buffer)
{
// if file is already running, get info from it
if( m_opened )
{
CLog::Log(LOGWARNING, "%s - Stat called on open file %s", __FUNCTION__, url.Get().c_str());
if (buffer)
{
memset(buffer, 0, sizeof(struct __stat64));
buffer->st_size = GetLength();
buffer->st_mode = _S_IFREG;
}
return 0;
}
CURL url2(url);
ParseAndCorrectUrl(url2);
ASSERT(m_state->m_easyHandle == NULL);
g_curlInterface.easy_aquire(url2.GetProtocol(), url2.GetHostName(), &m_state->m_easyHandle, NULL);
SetCommonOptions(m_state);
SetRequestHeaders(m_state);
g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_TIMEOUT, 5);
g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_NOBODY, 1);
g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_WRITEDATA, NULL); /* will cause write failure*/
g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_FILETIME , 1);
if(url2.GetProtocol() == "ftp")
{
g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_FTP_FILEMETHOD, CURLFTPMETHOD_NOCWD);
}
CURLcode result = g_curlInterface.easy_perform(m_state->m_easyHandle);
if(result == CURLE_HTTP_RETURNED_ERROR)
{
long code;
if(g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_RESPONSE_CODE, &code) == CURLE_OK && code == 404 )
return -1;
}
if(result == CURLE_GOT_NOTHING
|| result == CURLE_HTTP_RETURNED_ERROR
|| result == CURLE_RECV_ERROR /* some silly shoutcast servers */ )
{
/* some http servers and shoutcast servers don't give us any data on a head request */
/* request normal and just fail out, it's their loss */
/* somehow curl doesn't reset CURLOPT_NOBODY properly so reset everything */
SetCommonOptions(m_state);
SetRequestHeaders(m_state);
g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_TIMEOUT, 5);
g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_RANGE, "0-0");
g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_WRITEDATA, NULL); /* will cause write failure*/
g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_FILETIME , 1);
result = g_curlInterface.easy_perform(m_state->m_easyHandle);
}
if( result == CURLE_HTTP_RANGE_ERROR )
{
/* crap can't use the range option, disable it and try again */
g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_RANGE, NULL);
result = g_curlInterface.easy_perform(m_state->m_easyHandle);
}
if( result != CURLE_WRITE_ERROR && result != CURLE_OK )
{
g_curlInterface.easy_release(&m_state->m_easyHandle, NULL);
errno = ENOENT;
return -1;
}
double length;
if (CURLE_OK != g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &length) || length < 0.0)
{
if (url.GetProtocol() == "ftp")
{
g_curlInterface.easy_release(&m_state->m_easyHandle, NULL);
errno = ENOENT;
return -1;
}
else
length = 0.0;
}
SetCorrectHeaders(m_state);
if(buffer)
{
char *content;
if (CURLE_OK != g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_CONTENT_TYPE, &content))
{
g_curlInterface.easy_release(&m_state->m_easyHandle, NULL);
errno = ENOENT;
return -1;
}
else
{
memset(buffer, 0, sizeof(struct __stat64));
buffer->st_size = (int64_t)length;
if(content && strstr(content, "text/html")) //consider html files directories
buffer->st_mode = _S_IFDIR;
else
buffer->st_mode = _S_IFREG;
}
long filetime;
if (CURLE_OK != g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_FILETIME, &filetime))
{
CLog::Log(LOGWARNING, "%s - Cannot get curl filetime for %s", __FUNCTION__, url.Get().c_str());
}
else
{
if (filetime != -1)
buffer->st_mtime = filetime;
}
}
g_curlInterface.easy_release(&m_state->m_easyHandle, NULL);
return 0;
}
bool CNFSDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
// We accept nfs://server/path[/file]]]]
int ret = 0;
FILETIME fileTime, localTime;
CSingleLock lock(gNfsConnection);
CURL url(strPath);
CStdString strDirName="";
CStdString myStrPath(strPath);
URIUtils::AddSlashAtEnd(myStrPath); //be sure the dir ends with a slash
if(!gNfsConnection.Connect(url,strDirName))
{
//connect has failed - so try to get the exported filesystms if no path is given to the url
if(url.GetShareName().Equals(""))
{
if(url.GetHostName().Equals(""))
{
return GetServerList(items);
}
else
{
return GetDirectoryFromExportList(myStrPath, items);
}
}
else
{
return false;
}
}
struct nfsdir *nfsdir = NULL;
struct nfsdirent *nfsdirent = NULL;
ret = gNfsConnection.GetImpl()->nfs_opendir(gNfsConnection.GetNfsContext(), strDirName.c_str(), &nfsdir);
if(ret != 0)
{
CLog::Log(LOGERROR, "Failed to open(%s) %s\n", strDirName.c_str(), gNfsConnection.GetImpl()->nfs_get_error(gNfsConnection.GetNfsContext()));
return false;
}
lock.Leave();
while((nfsdirent = gNfsConnection.GetImpl()->nfs_readdir(gNfsConnection.GetNfsContext(), nfsdir)) != NULL)
{
CStdString strName = nfsdirent->name;
CStdString path(myStrPath + strName);
int64_t iSize = 0;
bool bIsDir = false;
int64_t lTimeDate = 0;
//reslove symlinks
if(nfsdirent->type == NF3LNK)
{
CURL linkUrl;
//resolve symlink changes nfsdirent and strName
if(!ResolveSymlink(strDirName,nfsdirent,linkUrl))
{
continue;
}
path = linkUrl.Get();
}
iSize = nfsdirent->size;
bIsDir = nfsdirent->type == NF3DIR;
lTimeDate = nfsdirent->mtime.tv_sec;
if (!strName.Equals(".") && !strName.Equals("..")
&& !strName.Equals("lost+found"))
{
if(lTimeDate == 0) // if modification date is missing, use create date
{
lTimeDate = nfsdirent->ctime.tv_sec;
}
LONGLONG ll = Int32x32To64(lTimeDate & 0xffffffff, 10000000) + 116444736000000000ll;
fileTime.dwLowDateTime = (DWORD) (ll & 0xffffffff);
fileTime.dwHighDateTime = (DWORD)(ll >> 32);
FileTimeToLocalFileTime(&fileTime, &localTime);
CFileItemPtr pItem(new CFileItem(nfsdirent->name));
pItem->m_dateTime=localTime;
pItem->m_dwSize = iSize;
if (bIsDir)
{
URIUtils::AddSlashAtEnd(path);
pItem->m_bIsFolder = true;
}
else
{
pItem->m_bIsFolder = false;
}
if (strName[0] == '.')
{
pItem->SetProperty("file:hidden", true);
}
pItem->SetPath(path);
items.Add(pItem);
}
}
lock.Enter();
gNfsConnection.GetImpl()->nfs_closedir(gNfsConnection.GetNfsContext(), nfsdir);//close the dir
lock.Leave();
return true;
}
bool CRSSDirectory::GetDirectory(const CURL& url, CFileItemList &items)
{
const std::string pathToUrl(url.Get());
std::string strPath(pathToUrl);
URIUtils::RemoveSlashAtEnd(strPath);
std::map<std::string,CDateTime>::iterator it;
items.SetPath(strPath);
CSingleLock lock(m_section);
if ((it=m_cache.find(strPath)) != m_cache.end())
{
if (it->second > CDateTime::GetCurrentDateTime() &&
items.Load())
return true;
m_cache.erase(it);
}
lock.Leave();
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strPath))
{
CLog::Log(LOGERROR,"failed to load xml from <%s>. error: <%d>", strPath.c_str(), xmlDoc.ErrorId());
return false;
}
if (xmlDoc.Error())
{
CLog::Log(LOGERROR,"error parsing xml doc from <%s>. error: <%d>", strPath.c_str(), xmlDoc.ErrorId());
return false;
}
TiXmlElement* rssXmlNode = xmlDoc.RootElement();
if (!rssXmlNode)
return false;
TiXmlHandle docHandle( &xmlDoc );
TiXmlElement* channelXmlNode = docHandle.FirstChild( "rss" ).FirstChild( "channel" ).Element();
if (channelXmlNode)
ParseItem(&items, channelXmlNode, pathToUrl);
else
return false;
TiXmlElement* child = NULL;
for (child = channelXmlNode->FirstChildElement("item"); child; child = child->NextSiblingElement())
{
// Create new item,
CFileItemPtr item(new CFileItem());
ParseItem(item.get(), child, pathToUrl);
item->SetProperty("isrss", "1");
// Use channel image if item doesn't have one
if (!item->HasArt("thumb") && items.HasArt("thumb"))
item->SetArt("thumb", items.GetArt("thumb"));
if (!item->GetPath().empty())
items.Add(item);
}
items.AddSortMethod(SortByNone , 231, LABEL_MASKS("%L", "%D", "%L", "")); // FileName, Duration | Foldername, empty
items.AddSortMethod(SortByLabel , 551, LABEL_MASKS("%L", "%D", "%L", "")); // FileName, Duration | Foldername, empty
items.AddSortMethod(SortBySize , 553, LABEL_MASKS("%L", "%I", "%L", "%I")); // FileName, Size | Foldername, Size
items.AddSortMethod(SortByDate , 552, LABEL_MASKS("%L", "%J", "%L", "%J")); // FileName, Date | Foldername, Date
CDateTime time = CDateTime::GetCurrentDateTime();
int mins = 60;
TiXmlElement* ttl = docHandle.FirstChild("rss").FirstChild("ttl").Element();
if (ttl)
mins = strtol(ttl->FirstChild()->Value(),NULL,10);
time += CDateTimeSpan(0,0,mins,0);
items.SetPath(strPath);
items.Save();
CSingleLock lock2(m_section);
m_cache.insert(make_pair(strPath,time));
return true;
}
bool CFileCache::Exists(const CURL& url)
{
return CFile::Exists(url.Get());
}
CURL URIUtils::SubstitutePath(const CURL& url, bool reverse /* = false */)
{
const CStdString pathToUrl = url.Get();
return CURL(SubstitutePath(pathToUrl, reverse));
}
std::wstring CWIN32Util::ConvertPathToWin32Form(const CURL& url)
{
assert(url.GetProtocol().empty() || url.IsProtocol("smb"));
if (url.GetFileName().empty())
return std::wstring(); // empty string
if (url.GetProtocol().empty())
{
std::wstring result;
if (g_charsetConverter.utf8ToW("\\\\?\\" +
URIUtils::CanonicalizePath(URIUtils::FixSlashesAndDups(url.GetFileName(), '\\'), '\\'), result, false, false, true))
return result;
}
else if (url.IsProtocol("smb"))
{
if (url.GetHostName().empty())
return std::wstring(); // empty string
std::wstring result;
if (g_charsetConverter.utf8ToW("\\\\?\\UNC\\" +
URIUtils::CanonicalizePath(URIUtils::FixSlashesAndDups(url.GetHostName() + '\\' + url.GetFileName(), '\\'), '\\'),
result, false, false, true))
return result;
}
else
return std::wstring(); // unsupported protocol, return empty string
CLog::Log(LOGERROR, "%s: Error converting path \"%s\" to Win32 form", __FUNCTION__, url.Get().c_str());
return std::wstring(); // empty string
}
bool CLastFmManager::ChangeStation(const CURL& stationUrl)
{
unsigned int start = XbmcThreads::SystemClockMillis();
InitProgressDialog(stationUrl.Get());
StopRadio(false);
if (!RadioHandShake())
{
CloseProgressDialog();
CGUIDialogOK::ShowAndGetInput(15200, 15206, 0, 0);
return false;
}
UpdateProgressDialog(15252); // Selecting station...
CCurlFile http;
CStdString url;
CStdString html;
url.Format("http://" + m_RadioBaseUrl + m_RadioBasePath + "/adjust.php?session=%s&url=%s&debug=%i", m_RadioSession, stationUrl.Get().c_str(), 0);
if (!http.Get(url, html))
{
CLog::Log(LOGERROR, "Connect to Last.fm to change station failed.");
CloseProgressDialog();
return false;
}
//CLog::Log(LOGDEBUG, "ChangeStation: %s", html.c_str());
CStdString strErrorCode;
Parameter("error", html, strErrorCode);
if (strErrorCode != "")
{
CLog::Log(LOGERROR, "Last.fm returned an error (%s) response for change station request.", strErrorCode.c_str());
CloseProgressDialog();
return false;
}
UpdateProgressDialog(261); //Waiting for start....
g_playlistPlayer.ClearPlaylist(PLAYLIST_MUSIC);
RequestRadioTracks();
CacheTrackThumb(XBMC_LASTFM_MINTRACKS);
AddToPlaylist(XBMC_LASTFM_MINTRACKS);
Create(); //start thread
m_hWorkerEvent.Set(); //kickstart the thread
CSingleLock lock(m_lockPlaylist);
CPlayList& playlist = g_playlistPlayer.GetPlaylist(PLAYLIST_MUSIC);
if ((int)playlist.size())
{
g_application.m_strPlayListFile = stationUrl.Get(); //needed to highlight the playing item
g_playlistPlayer.SetCurrentPlaylist(PLAYLIST_MUSIC);
g_playlistPlayer.Play(0);
CLog::Log(LOGDEBUG, "%s: Done (time: %i ms)", __FUNCTION__, (int)(XbmcThreads::SystemClockMillis() - start));
CloseProgressDialog();
return true;
}
CloseProgressDialog();
return false;
}
bool CWin32Directory::GetDirectory(const CURL& url, CFileItemList &items)
{
items.Clear();
std::string pathWithSlash(url.Get());
if (!pathWithSlash.empty() && pathWithSlash.back() != '\\')
pathWithSlash.push_back('\\');
std::wstring searchMask(CWIN32Util::ConvertPathToWin32Form(pathWithSlash));
if (searchMask.empty())
return false;
// TODO: support m_strFileMask, require rewrite of internal caching
searchMask += L'*';
HANDLE hSearch;
WIN32_FIND_DATAW findData = {};
if (g_sysinfo.IsWindowsVersionAtLeast(CSysInfo::WindowsVersionWin7))
hSearch = FindFirstFileExW(searchMask.c_str(), FindExInfoBasic, &findData, FindExSearchNameMatch, NULL, FIND_FIRST_EX_LARGE_FETCH);
else
hSearch = FindFirstFileExW(searchMask.c_str(), FindExInfoStandard, &findData, FindExSearchNameMatch, NULL, 0);
if (hSearch == INVALID_HANDLE_VALUE)
return GetLastError() == ERROR_FILE_NOT_FOUND ? Exists(url) : false; // return true if directory exist and empty
do
{
std::wstring itemNameW(findData.cFileName);
if (itemNameW == L"." || itemNameW == L"..")
continue;
std::string itemName;
if (!g_charsetConverter.wToUTF8(itemNameW, itemName, true) || itemName.empty())
{
CLog::Log(LOGERROR, "%s: Can't convert wide string name to UTF-8 encoding", __FUNCTION__);
continue;
}
CFileItemPtr pItem(new CFileItem(itemName));
pItem->m_bIsFolder = ((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
if (pItem->m_bIsFolder)
pItem->SetPath(pathWithSlash + itemName + '\\');
else
pItem->SetPath(pathWithSlash + itemName);
if ((findData.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)) != 0
|| itemName.front() == '.') // mark files starting from dot as hidden
pItem->SetProperty("file:hidden", true);
// calculation of size and date costs a little on win32
// so DIR_FLAG_NO_FILE_INFO flag is ignored
FILETIME localTime;
if (FileTimeToLocalFileTime(&findData.ftLastWriteTime, &localTime) == TRUE)
pItem->m_dateTime = localTime;
else
pItem->m_dateTime = 0;
if (!pItem->m_bIsFolder)
pItem->m_dwSize = (__int64(findData.nFileSizeHigh) << 32) + findData.nFileSizeLow;
items.Add(pItem);
} while (FindNextFileW(hSearch, &findData));
FindClose(hSearch);
return true;
}
bool CPVRFile::Open(const CURL& url)
{
Close();
CStdString strURL = url.Get();
if (strURL.Left(18) == "pvr://channels/tv/")
{
const CPVRChannel *tag = CPVRManager::GetChannelGroups()->GetByPath(strURL);
if (tag)
{
if (!CPVRManager::Get()->OpenLiveStream(*tag))
return false;
m_isPlayRecording = false;
CLog::Log(LOGDEBUG, "%s - TV Channel has started on filename %s", __FUNCTION__, strURL.c_str());
}
else
{
CLog::Log(LOGERROR, "PVRFile - TV Channel not found with filename %s", strURL.c_str());
return false;
}
}
else if (strURL.Left(21) == "pvr://channels/radio/")
{
const CPVRChannel *tag = CPVRManager::GetChannelGroups()->GetByPath(strURL);
if (tag)
{
if (!CPVRManager::Get()->OpenLiveStream(*tag))
return false;
m_isPlayRecording = false;
CLog::Log(LOGDEBUG, "%s - Radio Channel has started on filename %s", __FUNCTION__, strURL.c_str());
}
else
{
CLog::Log(LOGERROR, "PVRFile - Radio Channel not found with filename %s", strURL.c_str());
return false;
}
}
else if (strURL.Left(17) == "pvr://recordings/")
{
CPVRRecording *tag = CPVRManager::GetRecordings()->GetByPath(strURL);
if (tag)
{
if (!CPVRManager::Get()->OpenRecordedStream(*tag))
return false;
m_isPlayRecording = true;
CLog::Log(LOGDEBUG, "%s - Recording has started on filename %s", __FUNCTION__, strURL.c_str());
}
else
{
CLog::Log(LOGERROR, "PVRFile - Recording not found with filename %s", strURL.c_str());
return false;
}
}
else
{
CLog::Log(LOGERROR, "%s - invalid path specified %s", __FUNCTION__, strURL.c_str());
return false;
}
return true;
}
CStdString CSpecialProtocol::TranslatePath(const CURL &url)
{
// check for special-protocol, if not, return
if (!url.GetProtocol().Equals("special"))
{
#if defined(TARGET_POSIX) && defined(_DEBUG)
CStdString path(url.Get());
if (path.length() >= 2 && path[1] == ':')
{
CLog::Log(LOGWARNING, "Trying to access old style dir: %s\n", path.c_str());
// printf("Trying to access old style dir: %s\n", path.c_str());
}
#endif
return url.Get();
}
CStdString FullFileName = url.GetFileName();
CStdString translatedPath;
CStdString FileName;
CStdString RootDir;
// Split up into the special://root and the rest of the filename
int pos = FullFileName.Find('/');
if (pos != -1 && pos > 1)
{
RootDir = FullFileName.Left(pos);
if (pos < FullFileName.GetLength())
FileName = FullFileName.Mid(pos + 1);
}
else
RootDir = FullFileName;
if (RootDir.Equals("subtitles"))
translatedPath = URIUtils::AddFileToFolder(CSettings::Get().GetString("subtitles.custompath"), FileName);
else if (RootDir.Equals("userdata"))
translatedPath = URIUtils::AddFileToFolder(CProfilesManager::Get().GetUserDataFolder(), FileName);
else if (RootDir.Equals("database"))
translatedPath = URIUtils::AddFileToFolder(CProfilesManager::Get().GetDatabaseFolder(), FileName);
else if (RootDir.Equals("thumbnails"))
translatedPath = URIUtils::AddFileToFolder(CProfilesManager::Get().GetThumbnailsFolder(), FileName);
else if (RootDir.Equals("recordings") || RootDir.Equals("cdrips"))
translatedPath = URIUtils::AddFileToFolder(CSettings::Get().GetString("audiocds.recordingpath"), FileName);
else if (RootDir.Equals("screenshots"))
translatedPath = URIUtils::AddFileToFolder(CSettings::Get().GetString("debug.screenshotpath"), FileName);
else if (RootDir.Equals("musicplaylists"))
translatedPath = URIUtils::AddFileToFolder(CUtil::MusicPlaylistsLocation(), FileName);
else if (RootDir.Equals("videoplaylists"))
translatedPath = URIUtils::AddFileToFolder(CUtil::VideoPlaylistsLocation(), FileName);
else if (RootDir.Equals("skin"))
translatedPath = URIUtils::AddFileToFolder(g_graphicsContext.GetMediaDir(), FileName);
else if (RootDir.Equals("logpath"))
translatedPath = URIUtils::AddFileToFolder(g_advancedSettings.m_logFolder, FileName);
// from here on, we have our "real" special paths
else if (RootDir.Equals("xbmc") ||
RootDir.Equals("xbmcbin") ||
RootDir.Equals("home") ||
RootDir.Equals("userhome") ||
RootDir.Equals("temp") ||
RootDir.Equals("profile") ||
RootDir.Equals("masterprofile") ||
RootDir.Equals("frameworks"))
{
CStdString basePath = GetPath(RootDir);
if (!basePath.IsEmpty())
translatedPath = URIUtils::AddFileToFolder(basePath, FileName);
else
translatedPath.clear();
}
// check if we need to recurse in
if (URIUtils::IsSpecial(translatedPath))
{ // we need to recurse in, as there may be multiple translations required
return TranslatePath(translatedPath);
}
// Validate the final path, just in case
return CUtil::ValidatePath(translatedPath);
}
bool CMultiPathDirectory::GetPaths(const CURL& url, std::vector<std::string>& vecPaths)
{
const std::string pathToUrl(url.Get());
return GetPaths(pathToUrl, vecPaths);
}
bool GetDirectoryFromTxtRecords(const CZeroconfBrowser::ZeroconfService& zeroconf_service, CURL& url, CFileItemList &items)
{
bool ret = false;
//get the txt-records from this service
CZeroconfBrowser::ZeroconfService::tTxtRecordMap txtRecords=zeroconf_service.GetTxtRecords();
//if we have some records
if(!txtRecords.empty())
{
std::string path;
std::string username;
std::string password;
//search for a path key entry
CZeroconfBrowser::ZeroconfService::tTxtRecordMap::iterator it = txtRecords.find(TXT_RECORD_PATH_KEY);
//if we found the key - be sure there is a value there
if( it != txtRecords.end() && !it->second.empty() )
{
//from now on we treat the value as a path - everything else would mean
//a missconfigured zeroconf server.
path=it->second;
}
//search for a username key entry
it = txtRecords.find(TXT_RECORD_USERNAME_KEY);
//if we found the key - be sure there is a value there
if( it != txtRecords.end() && !it->second.empty() )
{
username=it->second;
url.SetUserName(username);
}
//search for a password key entry
it = txtRecords.find(TXT_RECORD_PASSWORD_KEY);
//if we found the key - be sure there is a value there
if( it != txtRecords.end() && !it->second.empty() )
{
password=it->second;
url.SetPassword(password);
}
//if we got a path - add a item - else at least we maybe have set username and password to theurl
if( !path.empty())
{
CFileItemPtr item(new CFileItem("", true));
std::string urlStr(url.Get());
//if path has a leading slash (sure it should have one)
if( path.at(0) == '/' )
{
URIUtils::RemoveSlashAtEnd(urlStr);//we don't need the slash at and of url then
}
else//path doesn't start with slash -
{//this is some kind of missconfiguration - we fix it by adding a slash to the url
URIUtils::AddSlashAtEnd(urlStr);
}
//add slash at end of path since it has to be a folder
URIUtils::AddSlashAtEnd(path);
//this is the full path includeing remote stuff (e.x. nfs://ip/path
item->SetPath(urlStr + path);
//remove the slash at the end of the path or GetFileName will not give the last dir
URIUtils::RemoveSlashAtEnd(path);
//set the label to the last directory in path
if( !URIUtils::GetFileName(path).empty() )
item->SetLabel(URIUtils::GetFileName(path));
else
item->SetLabel("/");
item->SetLabelPreformated(true);
//just set the default folder icon
item->FillInDefaultIcon();
item->m_bIsShareOrDrive=true;
items.Add(item);
ret = true;
}
}
return ret;
}
bool CDirectory::GetDirectory(const CURL& url, CFileItemList &items, const CHints &hints, bool allowThreads)
{
try
{
CURL realURL = URIUtils::SubstitutePath(url);
std::shared_ptr<IDirectory> pDirectory(CDirectoryFactory::Create(realURL));
if (!pDirectory.get())
return false;
// check our cache for this path
if (g_directoryCache.GetDirectory(realURL.Get(), items, (hints.flags & DIR_FLAG_READ_CACHE) == DIR_FLAG_READ_CACHE))
items.SetURL(url);
else
{
// need to clear the cache (in case the directory fetch fails)
// and (re)fetch the folder
if (!(hints.flags & DIR_FLAG_BYPASS_CACHE))
g_directoryCache.ClearDirectory(realURL.Get());
pDirectory->SetFlags(hints.flags);
bool result = false, cancel = false;
while (!result && !cancel)
{
const std::string pathToUrl(url.Get());
if (g_application.IsCurrentThread() && allowThreads && !URIUtils::IsSpecial(pathToUrl))
{
CSingleExit ex(g_graphicsContext);
CGetDirectory get(pDirectory, realURL, url);
if(!get.Wait(TIME_TO_BUSY_DIALOG))
{
CGUIDialogBusy* dialog = (CGUIDialogBusy*)g_windowManager.GetWindow(WINDOW_DIALOG_BUSY);
if (dialog)
{
dialog->Open();
while(!get.Wait(10))
{
CSingleLock lock(g_graphicsContext);
// update progress
float progress = pDirectory->GetProgress();
if (progress > 0)
dialog->SetProgress(progress);
if (dialog->IsCanceled())
{
cancel = true;
pDirectory->CancelDirectory();
break;
}
lock.Leave(); // prevent an occasional deadlock on exit
g_windowManager.ProcessRenderLoop(false);
}
dialog->Close();
}
}
result = get.GetDirectory(items);
}
else
{
items.SetURL(url);
result = pDirectory->GetDirectory(realURL, items);
}
if (!result)
{
if (!cancel && g_application.IsCurrentThread() && pDirectory->ProcessRequirements())
continue;
CLog::Log(LOGERROR, "%s - Error getting %s", __FUNCTION__, url.GetRedacted().c_str());
return false;
}
}
// cache the directory, if necessary
if (!(hints.flags & DIR_FLAG_BYPASS_CACHE))
g_directoryCache.SetDirectory(realURL.Get(), items, pDirectory->GetCacheType(url));
}
// now filter for allowed files
if (!pDirectory->AllowAll())
{
pDirectory->SetMask(hints.mask);
for (int i = 0; i < items.Size(); ++i)
{
CFileItemPtr item = items[i];
if (!item->m_bIsFolder && !pDirectory->IsAllowed(item->GetURL()))
{
items.Remove(i);
i--; // don't confuse loop
}
}
}
// filter hidden files
// TODO: we shouldn't be checking the gui setting here, callers should use getHidden instead
if (!CSettings::Get().GetBool("filelists.showhidden") && !(hints.flags & DIR_FLAG_GET_HIDDEN))
{
for (int i = 0; i < items.Size(); ++i)
{
if (items[i]->GetProperty("file:hidden").asBoolean())
{
items.Remove(i);
i--; // don't confuse loop
}
}
}
// Should any of the files we read be treated as a directory?
// Disable for database folders, as they already contain the extracted items
if (!(hints.flags & DIR_FLAG_NO_FILE_DIRS) && !items.IsMusicDb() && !items.IsVideoDb() && !items.IsSmartPlayList())
FilterFileDirectories(items, hints.mask);
// Correct items for path substitution
const std::string pathToUrl(url.Get());
const std::string pathToUrl2(realURL.Get());
if (pathToUrl != pathToUrl2)
{
for (int i = 0; i < items.Size(); ++i)
{
CFileItemPtr item = items[i];
item->SetPath(URIUtils::SubstitutePath(item->GetPath(), true));
}
}
return true;
}
XBMCCOMMONS_HANDLE_UNCHECKED
catch (...)
{
CLog::Log(LOGERROR, "%s - Unhandled exception", __FUNCTION__);
}
CLog::Log(LOGERROR, "%s - Error getting %s", __FUNCTION__, url.GetRedacted().c_str());
return false;
}
//*********************************************************************************************
bool CFileReaderFile::Open(const CURL& url)
{
CStdString strURL = url.Get();
strURL = strURL.Mid(13);
return m_reader.Open(strURL,READ_CACHED);
}
bool CFileCache::Open(const CURL& url)
{
Close();
CSingleLock lock(m_sync);
CLog::Log(LOGDEBUG,"CFileCache::Open - opening <%s> using cache", url.GetFileName().c_str());
m_sourcePath = url.Get();
// opening the source file.
if (!m_source.Open(m_sourcePath, READ_NO_CACHE | READ_TRUNCATED | READ_CHUNKED))
{
CLog::Log(LOGERROR,"%s - failed to open source <%s>", __FUNCTION__, url.GetRedacted().c_str());
Close();
return false;
}
m_source.IoControl(IOCTRL_SET_CACHE, this);
bool retry = false;
m_source.IoControl(IOCTRL_SET_RETRY, &retry); // We already handle retrying ourselves
// check if source can seek
m_seekPossible = m_source.IoControl(IOCTRL_SEEK_POSSIBLE, NULL);
m_chunkSize = CFile::GetChunkSize(m_source.GetChunkSize(), READ_CACHE_CHUNK_SIZE);
m_fileSize = m_source.GetLength();
if (!m_pCache)
{
if (g_advancedSettings.m_cacheMemBufferSize == 0)
{
// Use cache on disk
m_pCache = new CSimpleFileCache();
m_forwardCacheSize = 0;
}
else
{
size_t cacheSize;
if (m_fileSize > 0 && m_fileSize < g_advancedSettings.m_cacheMemBufferSize && !(m_flags & READ_AUDIO_VIDEO))
{
// NOTE: We don't need to take into account READ_MULTI_STREAM here as it's only used for audio/video
cacheSize = m_fileSize;
}
else
{
cacheSize = g_advancedSettings.m_cacheMemBufferSize;
}
size_t back = cacheSize / 4;
size_t front = cacheSize - back;
if (m_flags & READ_MULTI_STREAM)
{
// READ_MULTI_STREAM requires double buffering, so use half the amount of memory for each buffer
front /= 2;
back /= 2;
}
m_pCache = new CCircularCache(front, back);
m_forwardCacheSize = front;
}
if (m_flags & READ_MULTI_STREAM)
{
// If READ_MULTI_STREAM flag is set: Double buffering is required
m_pCache = new CDoubleCache(m_pCache);
}
}
// open cache strategy
if (!m_pCache || m_pCache->Open() != CACHE_RC_OK)
{
CLog::Log(LOGERROR,"CFileCache::Open - failed to open cache");
Close();
return false;
}
m_readPos = 0;
m_writePos = 0;
m_writeRate = 1024 * 1024;
m_writeRateActual = 0;
m_seekEvent.Reset();
m_seekEnded.Reset();
CThread::Create(false);
return true;
}
bool CFileReaderFile::Exists(const CURL& url)
{
return CFile::Exists(url.Get().Mid(13));
}
int CFileCache::Stat(const CURL& url, struct __stat64* buffer)
{
return CFile::Stat(url.Get(), buffer);
}
int CFileReaderFile::Stat(const CURL& url, struct __stat64* buffer)
{
return CFile::Stat(url.Get().Mid(13),buffer);
}
bool CMythDirectory::GetDirectory(const CURL& url, CFileItemList &items)
{
m_session = CMythSession::AquireSession(url);
if (!m_session)
return false;
m_dll = m_session->GetLibrary();
if (!m_dll)
return false;
CStdString base(url.Get());
URIUtils::RemoveSlashAtEnd(base);
CStdString fileName = url.GetFileName();
URIUtils::RemoveSlashAtEnd(fileName);
if (fileName == "")
{
/*
* If we can't get the control then we can't connect to the backend. Don't even show any of the
* virtual folders as none of them will work. Without this check the "Browse" functionality
* when adding a myth:// source is way confusing as it shows folders so it looks like it has
* connected successfully when it in fact hasn't.
*/
cmyth_conn_t control = m_session->GetControl();
if (!control)
return false;
CFileItemPtr item;
item.reset(new CFileItem(base + "/recordings/", true));
item->SetLabel(g_localizeStrings.Get(22015)); // All recordings
items.Add(item);
item.reset(new CFileItem(base + "/tvshows/", true));
item->SetLabel(g_localizeStrings.Get(20343)); // TV shows
items.Add(item);
item.reset(new CFileItem(base + "/movies/", true));
item->SetLabel(g_localizeStrings.Get(20342)); // Movies
items.Add(item);
item.reset(new CFileItem(base + "/channels/", true));
item->SetLabel(g_localizeStrings.Get(22018)); // Live channels
items.Add(item);
item.reset(new CFileItem(base + "/guide/", true));
item->SetLabel(g_localizeStrings.Get(22020)); // Guide
items.Add(item);
items.AddSortMethod(SortByNone, 564 /* Type */, LABEL_MASKS("", "", "%L", "")); // No sorting, as added to list.
/*
* Clear the directory cache so the cached sub-folders are guaranteed to be accurate.
*/
g_directoryCache.ClearSubPaths(base);
return true;
}
else if (fileName == "channels")
return GetChannels(base, items);
else if (fileName == "guide")
return GetGuide(base, items);
else if (StringUtils::StartsWith(fileName, "guide/"))
return GetGuideForChannel(base, items, atoi(fileName.substr(6).c_str()));
else if (fileName == "movies")
return GetRecordings(base, items, MOVIES);
else if (fileName == "recordings")
return GetRecordings(base, items);
else if (fileName == "tvshows")
return GetTvShowFolders(base, items);
else if (StringUtils::StartsWith(fileName, "tvshows/"))
return GetRecordings(base, items, TV_SHOWS, fileName.substr(8).c_str());
return false;
}
std::string CPlayListM3U::GetBestBandwidthStream(const std::string &strFileName, size_t bandwidth)
{
// we may be passed a playlist that does not contain playlists of different
// bitrates (eg: this playlist is really the HLS video). So, default the
// return to the filename so it can be played
char szLine[4096];
std::string strLine;
size_t maxBandwidth = 0;
// open the file, and if it fails, return
CFile file;
if (!file.Open(strFileName) )
{
file.Close();
return strFileName;
}
// get protocol options if they were set, so we can restore them again at the end
CURL playlistUrl(strFileName);
// and set the fallback value
CURL subStreamUrl = CURL(strFileName);
// determine the base
CURL basePlaylistUrl(URIUtils::GetParentPath(strFileName));
basePlaylistUrl.SetOptions("");
basePlaylistUrl.SetProtocolOptions("");
std::string basePart = basePlaylistUrl.Get();
// convert bandwidth specified in kbps to bps used by the m3u8
bandwidth *= 1000;
while (file.ReadString(szLine, 1024))
{
// read and trim a line
strLine = szLine;
StringUtils::Trim(strLine);
// skip the first line
if (strLine == M3U_START_MARKER)
continue;
else if (StringUtils::StartsWith(strLine, M3U_STREAM_MARKER))
{
// parse the line so we can pull out the bandwidth
std::map< std::string, std::string > params = ParseStreamLine(strLine);
std::map< std::string, std::string >::iterator it = params.find(M3U_BANDWIDTH_MARKER);
if (it != params.end())
{
size_t streamBandwidth = atoi(it->second.c_str());
if ((maxBandwidth < streamBandwidth) && (streamBandwidth <= bandwidth))
{
// read the next line
if (!file.ReadString(szLine, 1024))
continue;
strLine = szLine;
StringUtils::Trim(strLine);
// this line was empty
if (strLine.empty())
continue;
// store the max bandwidth
maxBandwidth = streamBandwidth;
// if the path is absolute just use it
if (CURL::IsFullPath(strLine))
subStreamUrl = CURL(strLine);
else
subStreamUrl = CURL(basePart + strLine);
}
}
}
}
// if any protocol options were set, restore them
subStreamUrl.SetProtocolOptions(playlistUrl.GetProtocolOptions());
return subStreamUrl.Get();
}
void CApplicationMessenger::ProcessMessage(ThreadMessage *pMsg)
{
switch (pMsg->dwMessage)
{
case TMSG_SHUTDOWN:
{
switch (CSettings::Get().GetInt("powermanagement.shutdownstate"))
{
case POWERSTATE_SHUTDOWN:
Powerdown();
break;
case POWERSTATE_SUSPEND:
Suspend();
break;
case POWERSTATE_HIBERNATE:
Hibernate();
break;
case POWERSTATE_QUIT:
Quit();
break;
case POWERSTATE_MINIMIZE:
Minimize();
break;
case TMSG_RENDERER_FLUSH:
g_renderManager.Flush();
break;
}
}
break;
case TMSG_POWERDOWN:
{
g_application.Stop(EXITCODE_POWERDOWN);
g_powerManager.Powerdown();
}
break;
case TMSG_QUIT:
{
g_application.Stop(EXITCODE_QUIT);
}
break;
case TMSG_HIBERNATE:
{
g_powerManager.Hibernate();
}
break;
case TMSG_SUSPEND:
{
g_powerManager.Suspend();
}
break;
case TMSG_RESTART:
case TMSG_RESET:
{
g_application.Stop(EXITCODE_REBOOT);
g_powerManager.Reboot();
}
break;
case TMSG_RESTARTAPP:
{
#if defined(TARGET_WINDOWS) || defined(TARGET_LINUX)
g_application.Stop(EXITCODE_RESTARTAPP);
#endif
}
break;
case TMSG_INHIBITIDLESHUTDOWN:
{
g_application.InhibitIdleShutdown(pMsg->param1 != 0);
}
break;
case TMSG_ACTIVATESCREENSAVER:
{
g_application.ActivateScreenSaver();
}
break;
case TMSG_MEDIA_PLAY:
{
// first check if we were called from the PlayFile() function
if (pMsg->lpVoid && pMsg->param2 == 0)
{
CFileItem *item = (CFileItem *)pMsg->lpVoid;
g_application.PlayFile(*item, pMsg->param1 != 0);
delete item;
return;
}
// restore to previous window if needed
if (g_windowManager.GetActiveWindow() == WINDOW_SLIDESHOW ||
g_windowManager.GetActiveWindow() == WINDOW_FULLSCREEN_VIDEO ||
g_windowManager.GetActiveWindow() == WINDOW_VISUALISATION)
g_windowManager.PreviousWindow();
g_application.ResetScreenSaver();
g_application.WakeUpScreenSaverAndDPMS();
//g_application.StopPlaying();
// play file
if(pMsg->lpVoid)
{
CFileItemList *list = (CFileItemList *)pMsg->lpVoid;
if (list->Size() > 0)
{
int playlist = PLAYLIST_MUSIC;
for (int i = 0; i < list->Size(); i++)
{
if ((*list)[i]->IsVideo())
{
playlist = PLAYLIST_VIDEO;
break;
}
}
g_playlistPlayer.ClearPlaylist(playlist);
g_playlistPlayer.SetCurrentPlaylist(playlist);
//For single item lists try PlayMedia. This covers some more cases where a playlist is not appropriate
//It will fall through to PlayFile
if (list->Size() == 1 && !(*list)[0]->IsPlayList())
g_application.PlayMedia(*((*list)[0]), playlist);
else
{
// Handle "shuffled" option if present
if (list->HasProperty("shuffled") && list->GetProperty("shuffled").isBoolean())
g_playlistPlayer.SetShuffle(playlist, list->GetProperty("shuffled").asBoolean(), false);
// Handle "repeat" option if present
if (list->HasProperty("repeat") && list->GetProperty("repeat").isInteger())
g_playlistPlayer.SetRepeat(playlist, (PLAYLIST::REPEAT_STATE)list->GetProperty("repeat").asInteger(), false);
g_playlistPlayer.Add(playlist, (*list));
g_playlistPlayer.Play(pMsg->param1);
}
}
delete list;
}
else if (pMsg->param1 == PLAYLIST_MUSIC || pMsg->param1 == PLAYLIST_VIDEO)
{
if (g_playlistPlayer.GetCurrentPlaylist() != pMsg->param1)
g_playlistPlayer.SetCurrentPlaylist(pMsg->param1);
PlayListPlayerPlay(pMsg->param2);
}
}
break;
case TMSG_MEDIA_RESTART:
g_application.Restart(true);
break;
case TMSG_PICTURE_SHOW:
{
CGUIWindowSlideShow *pSlideShow = (CGUIWindowSlideShow *)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (!pSlideShow) return ;
// stop playing file
if (g_application.m_pPlayer->IsPlayingVideo()) g_application.StopPlaying();
if (g_windowManager.GetActiveWindow() == WINDOW_FULLSCREEN_VIDEO)
g_windowManager.PreviousWindow();
g_application.ResetScreenSaver();
g_application.WakeUpScreenSaverAndDPMS();
g_graphicsContext.Lock();
if (g_windowManager.GetActiveWindow() != WINDOW_SLIDESHOW)
g_windowManager.ActivateWindow(WINDOW_SLIDESHOW);
if (URIUtils::IsZIP(pMsg->strParam) || URIUtils::IsRAR(pMsg->strParam)) // actually a cbz/cbr
{
CFileItemList items;
CURL pathToUrl;
if (URIUtils::IsZIP(pMsg->strParam))
pathToUrl = URIUtils::CreateArchivePath("zip", CURL(pMsg->strParam), "");
else
pathToUrl = URIUtils::CreateArchivePath("rar", CURL(pMsg->strParam), "");
CUtil::GetRecursiveListing(pathToUrl.Get(), items, g_advancedSettings.m_pictureExtensions, XFILE::DIR_FLAG_NO_FILE_DIRS);
if (items.Size() > 0)
{
pSlideShow->Reset();
for (int i=0;i<items.Size();++i)
{
pSlideShow->Add(items[i].get());
}
pSlideShow->Select(items[0]->GetPath());
}
}
else
{
CFileItem item(pMsg->strParam, false);
pSlideShow->Reset();
pSlideShow->Add(&item);
pSlideShow->Select(pMsg->strParam);
}
g_graphicsContext.Unlock();
}
break;
case TMSG_PICTURE_SLIDESHOW:
{
CGUIWindowSlideShow *pSlideShow = (CGUIWindowSlideShow *)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (!pSlideShow) return ;
if (g_application.m_pPlayer->IsPlayingVideo())
g_application.StopPlaying();
g_graphicsContext.Lock();
pSlideShow->Reset();
CFileItemList items;
std::string strPath = pMsg->strParam;
std::string extensions = g_advancedSettings.m_pictureExtensions;
if (pMsg->param1)
extensions += "|.tbn";
CUtil::GetRecursiveListing(strPath, items, extensions);
if (items.Size() > 0)
{
for (int i=0;i<items.Size();++i)
pSlideShow->Add(items[i].get());
pSlideShow->StartSlideShow(); //Start the slideshow!
}
if (g_windowManager.GetActiveWindow() != WINDOW_SLIDESHOW)
{
if(items.Size() == 0)
{
CSettings::Get().SetString("screensaver.mode", "screensaver.xbmc.builtin.dim");
g_application.ActivateScreenSaver();
}
else
g_windowManager.ActivateWindow(WINDOW_SLIDESHOW);
}
g_graphicsContext.Unlock();
}
break;
case TMSG_SETLANGUAGE:
g_application.SetLanguage(pMsg->strParam);
break;
case TMSG_MEDIA_STOP:
{
// restore to previous window if needed
bool stopSlideshow = true;
bool stopVideo = true;
bool stopMusic = true;
if (pMsg->param1 >= PLAYLIST_MUSIC && pMsg->param1 <= PLAYLIST_PICTURE)
{
stopSlideshow = (pMsg->param1 == PLAYLIST_PICTURE);
stopVideo = (pMsg->param1 == PLAYLIST_VIDEO);
stopMusic = (pMsg->param1 == PLAYLIST_MUSIC);
}
if ((stopSlideshow && g_windowManager.GetActiveWindow() == WINDOW_SLIDESHOW) ||
(stopVideo && g_windowManager.GetActiveWindow() == WINDOW_FULLSCREEN_VIDEO) ||
(stopMusic && g_windowManager.GetActiveWindow() == WINDOW_VISUALISATION))
g_windowManager.PreviousWindow();
g_application.ResetScreenSaver();
g_application.WakeUpScreenSaverAndDPMS();
// stop playing file
if (g_application.m_pPlayer->IsPlaying()) g_application.StopPlaying();
}
break;
case TMSG_MEDIA_PAUSE:
if (g_application.m_pPlayer->HasPlayer())
{
g_application.ResetScreenSaver();
g_application.WakeUpScreenSaverAndDPMS();
g_application.m_pPlayer->Pause();
}
break;
case TMSG_MEDIA_UNPAUSE:
if (g_application.m_pPlayer->IsPausedPlayback())
{
g_application.ResetScreenSaver();
g_application.WakeUpScreenSaverAndDPMS();
g_application.m_pPlayer->Pause();
}
break;
case TMSG_MEDIA_PAUSE_IF_PLAYING:
if (g_application.m_pPlayer->IsPlaying() && !g_application.m_pPlayer->IsPaused())
{
g_application.ResetScreenSaver();
g_application.WakeUpScreenSaverAndDPMS();
g_application.m_pPlayer->Pause();
}
break;
case TMSG_SWITCHTOFULLSCREEN:
if(g_windowManager.GetActiveWindow() != WINDOW_FULLSCREEN_VIDEO)
g_application.SwitchToFullScreen(true);
break;
case TMSG_SETVIDEORESOLUTION:
{
RESOLUTION res = (RESOLUTION)pMsg->param1;
bool forceUpdate = pMsg->param2 == 1 ? true : false;
g_graphicsContext.SetVideoResolution(res, forceUpdate);
}
break;
case TMSG_VIDEORESIZE:
{
XBMC_Event newEvent;
memset(&newEvent, 0, sizeof(newEvent));
newEvent.type = XBMC_VIDEORESIZE;
newEvent.resize.w = pMsg->param1;
newEvent.resize.h = pMsg->param2;
g_application.OnEvent(newEvent);
g_windowManager.MarkDirty();
}
break;
case TMSG_TOGGLEFULLSCREEN:
g_graphicsContext.Lock();
g_graphicsContext.ToggleFullScreenRoot();
g_graphicsContext.Unlock();
break;
case TMSG_MINIMIZE:
g_application.Minimize();
break;
case TMSG_EXECUTE_OS:
/* Suspend AE temporarily so exclusive or hog-mode sinks */
/* don't block external player's access to audio device */
if (!CAEFactory::Suspend())
{
CLog::Log(LOGNOTICE, "%s: Failed to suspend AudioEngine before launching external program",__FUNCTION__);
}
#if defined( TARGET_POSIX) && !defined(TARGET_DARWIN)
CUtil::RunCommandLine(pMsg->strParam.c_str(), (pMsg->param1 == 1));
#elif defined(TARGET_WINDOWS)
CWIN32Util::XBMCShellExecute(pMsg->strParam.c_str(), (pMsg->param1 == 1));
#endif
/* Resume AE processing of XBMC native audio */
if (!CAEFactory::Resume())
{
CLog::Log(LOGFATAL, "%s: Failed to restart AudioEngine after return from external player",__FUNCTION__);
}
break;
case TMSG_EXECUTE_SCRIPT:
CScriptInvocationManager::Get().ExecuteAsync(pMsg->strParam);
break;
case TMSG_EXECUTE_BUILT_IN:
CBuiltins::Execute(pMsg->strParam.c_str());
break;
case TMSG_PLAYLISTPLAYER_PLAY:
if (pMsg->param1 != -1)
g_playlistPlayer.Play(pMsg->param1);
else
g_playlistPlayer.Play();
break;
case TMSG_PLAYLISTPLAYER_PLAY_SONG_ID:
if (pMsg->param1 != -1)
{
bool *result = (bool*)pMsg->lpVoid;
*result = g_playlistPlayer.PlaySongId(pMsg->param1);
}
else
g_playlistPlayer.Play();
break;
case TMSG_PLAYLISTPLAYER_NEXT:
g_playlistPlayer.PlayNext();
break;
case TMSG_PLAYLISTPLAYER_PREV:
g_playlistPlayer.PlayPrevious();
break;
case TMSG_PLAYLISTPLAYER_ADD:
if(pMsg->lpVoid)
{
CFileItemList *list = (CFileItemList *)pMsg->lpVoid;
g_playlistPlayer.Add(pMsg->param1, (*list));
delete list;
}
break;
case TMSG_PLAYLISTPLAYER_INSERT:
if (pMsg->lpVoid)
{
CFileItemList *list = (CFileItemList *)pMsg->lpVoid;
g_playlistPlayer.Insert(pMsg->param1, (*list), pMsg->param2);
delete list;
}
break;
case TMSG_PLAYLISTPLAYER_REMOVE:
if (pMsg->param1 != -1)
g_playlistPlayer.Remove(pMsg->param1,pMsg->param2);
break;
case TMSG_PLAYLISTPLAYER_CLEAR:
g_playlistPlayer.ClearPlaylist(pMsg->param1);
break;
case TMSG_PLAYLISTPLAYER_SHUFFLE:
g_playlistPlayer.SetShuffle(pMsg->param1, pMsg->param2 > 0);
break;
case TMSG_PLAYLISTPLAYER_REPEAT:
g_playlistPlayer.SetRepeat(pMsg->param1, (PLAYLIST::REPEAT_STATE)pMsg->param2);
break;
case TMSG_PLAYLISTPLAYER_GET_ITEMS:
if (pMsg->lpVoid)
{
PLAYLIST::CPlayList playlist = g_playlistPlayer.GetPlaylist(pMsg->param1);
CFileItemList *list = (CFileItemList *)pMsg->lpVoid;
for (int i = 0; i < playlist.size(); i++)
list->Add(CFileItemPtr(new CFileItem(*playlist[i])));
}
break;
case TMSG_PLAYLISTPLAYER_SWAP:
if (pMsg->lpVoid)
{
vector<int> *indexes = (vector<int> *)pMsg->lpVoid;
if (indexes->size() == 2)
g_playlistPlayer.Swap(pMsg->param1, indexes->at(0), indexes->at(1));
delete indexes;
}
break;
// Window messages below here...
case TMSG_DIALOG_DOMODAL: //doModel of window
{
CGUIDialog* pDialog = (CGUIDialog*)g_windowManager.GetWindow(pMsg->param1);
if (!pDialog) return ;
pDialog->DoModal();
}
break;
case TMSG_NETWORKMESSAGE:
{
g_application.getNetwork().NetworkMessage((CNetwork::EMESSAGE)pMsg->param1, pMsg->param2);
}
break;
case TMSG_GUI_DO_MODAL:
{
CGUIDialog *pDialog = (CGUIDialog *)pMsg->lpVoid;
if (pDialog)
pDialog->DoModal(pMsg->param1, pMsg->strParam);
}
break;
case TMSG_GUI_SHOW:
{
CGUIDialog *pDialog = (CGUIDialog *)pMsg->lpVoid;
if (pDialog)
pDialog->Show();
}
break;
case TMSG_GUI_WINDOW_CLOSE:
{
CGUIWindow *window = (CGUIWindow *)pMsg->lpVoid;
if (window)
window->Close(pMsg->param2 & 0x1 ? true : false, pMsg->param1, pMsg->param2 & 0x2 ? true : false);
}
break;
case TMSG_GUI_ACTIVATE_WINDOW:
{
g_windowManager.ActivateWindow(pMsg->param1, pMsg->params, pMsg->param2 & 0x1 ? true : false, pMsg->param2 & 0x2 ? true : false);
}
break;
case TMSG_GUI_ADDON_DIALOG:
{
if (pMsg->lpVoid)
{ // TODO: This is ugly - really these python dialogs should just be normal XBMC dialogs
((ADDON::CGUIAddonWindowDialog *) pMsg->lpVoid)->Show_Internal(pMsg->param2 > 0);
}
}
break;
#ifdef HAS_PYTHON
case TMSG_GUI_PYTHON_DIALOG:
{
// This hack is not much better but at least I don't need to make ApplicationMessenger
// know about Addon (Python) specific classes.
CAction caction(pMsg->param1);
((CGUIWindow*)pMsg->lpVoid)->OnAction(caction);
}
break;
#endif
case TMSG_GUI_ACTION:
{
if (pMsg->lpVoid)
{
CAction *action = (CAction *)pMsg->lpVoid;
if (pMsg->param1 == WINDOW_INVALID)
g_application.OnAction(*action);
else
{
CGUIWindow *pWindow = g_windowManager.GetWindow(pMsg->param1);
if (pWindow)
pWindow->OnAction(*action);
else
CLog::Log(LOGWARNING, "Failed to get window with ID %i to send an action to", pMsg->param1);
}
delete action;
}
}
break;
case TMSG_GUI_MESSAGE:
{
if (pMsg->lpVoid)
{
CGUIMessage *message = (CGUIMessage *)pMsg->lpVoid;
g_windowManager.SendMessage(*message, pMsg->param1);
delete message;
}
}
break;
case TMSG_GUI_INFOLABEL:
{
if (pMsg->lpVoid)
{
vector<string> *infoLabels = (vector<string> *)pMsg->lpVoid;
for (unsigned int i = 0; i < pMsg->params.size(); i++)
infoLabels->push_back(g_infoManager.GetLabel(g_infoManager.TranslateString(pMsg->params[i])));
}
}
break;
case TMSG_GUI_INFOBOOL:
{
if (pMsg->lpVoid)
{
vector<bool> *infoLabels = (vector<bool> *)pMsg->lpVoid;
for (unsigned int i = 0; i < pMsg->params.size(); i++)
infoLabels->push_back(g_infoManager.EvaluateBool(pMsg->params[i]));
}
}
break;
case TMSG_CALLBACK:
{
ThreadMessageCallback *callback = (ThreadMessageCallback*)pMsg->lpVoid;
callback->callback(callback->userptr);
}
break;
case TMSG_VOLUME_SHOW:
{
CAction action(pMsg->param1);
g_application.ShowVolumeBar(&action);
}
break;
case TMSG_DISPLAY_SETUP:
{
*((bool*)pMsg->lpVoid) = g_application.InitWindow();
g_application.SetRenderGUI(true);
}
break;
case TMSG_DISPLAY_DESTROY:
{
*((bool*)pMsg->lpVoid) = g_application.DestroyWindow();
g_application.SetRenderGUI(false);
}
break;
case TMSG_UPDATE_CURRENT_ITEM:
{
CFileItem* item = (CFileItem*)pMsg->lpVoid;
if (!item)
return;
if (pMsg->param1 == 1 && item->HasMusicInfoTag()) // only grab music tag
g_infoManager.SetCurrentSongTag(*item->GetMusicInfoTag());
else if (pMsg->param1 == 2 && item->HasVideoInfoTag()) // only grab video tag
g_infoManager.SetCurrentVideoTag(*item->GetVideoInfoTag());
else
g_infoManager.SetCurrentItem(*item);
delete item;
break;
}
case TMSG_LOADPROFILE:
{
CGUIWindowLoginScreen::LoadProfile(pMsg->param1);
break;
}
case TMSG_CECTOGGLESTATE:
{
*((bool*)pMsg->lpVoid) = g_peripherals.ToggleDeviceState(STATE_SWITCH_TOGGLE);
break;
}
case TMSG_CECACTIVATESOURCE:
{
g_peripherals.ToggleDeviceState(STATE_ACTIVATE_SOURCE);
break;
}
case TMSG_CECSTANDBY:
{
g_peripherals.ToggleDeviceState(STATE_STANDBY);
break;
}
case TMSG_START_ANDROID_ACTIVITY:
{
#if defined(TARGET_ANDROID)
if (pMsg->params.size())
{
CXBMCApp::StartActivity(pMsg->params[0],
pMsg->params.size() > 1 ? pMsg->params[1] : "",
pMsg->params.size() > 2 ? pMsg->params[2] : "",
pMsg->params.size() > 3 ? pMsg->params[3] : "");
}
#endif
break;
}
case TMSG_SETPVRMANAGERSTATE:
{
if (pMsg->param1 != 0)
g_application.StartPVRManager();
else
g_application.StopPVRManager();
}
}
}
bool CISO9660Directory::GetDirectory(const CURL& url, CFileItemList &items)
{
std::string strRoot = url.Get();
URIUtils::AddSlashAtEnd(strRoot);
// Scan active disc if not done before
if (!m_isoReader.IsScanned())
m_isoReader.Scan();
WIN32_FIND_DATA wfd;
HANDLE hFind;
memset(&wfd, 0, sizeof(wfd));
std::string strSearchMask;
std::string strDirectory = url.GetFileName();
if (strDirectory != "")
{
strSearchMask = StringUtils::Format("\\%s", strDirectory.c_str());
}
else
{
strSearchMask = "\\";
}
for (int i = 0; i < (int)strSearchMask.size(); ++i )
{
if (strSearchMask[i] == '/') strSearchMask[i] = '\\';
}
hFind = m_isoReader.FindFirstFile((char*)strSearchMask.c_str(), &wfd);
if (hFind == NULL)
return false;
do
{
if (wfd.cFileName[0] != 0)
{
if ( (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) )
{
std::string strDir = wfd.cFileName;
if (strDir != "." && strDir != "..")
{
CFileItemPtr pItem(new CFileItem(wfd.cFileName));
std::string path = strRoot + wfd.cFileName;
URIUtils::AddSlashAtEnd(path);
pItem->SetPath(path);
pItem->m_bIsFolder = true;
FILETIME localTime;
FileTimeToLocalFileTime(&wfd.ftLastWriteTime, &localTime);
pItem->m_dateTime=localTime;
items.Add(pItem);
}
}
else
{
CFileItemPtr pItem(new CFileItem(wfd.cFileName));
pItem->SetPath(strRoot + wfd.cFileName);
pItem->m_bIsFolder = false;
pItem->m_dwSize = CUtil::ToInt64(wfd.nFileSizeHigh, wfd.nFileSizeLow);
FILETIME localTime;
FileTimeToLocalFileTime(&wfd.ftLastWriteTime, &localTime);
pItem->m_dateTime=localTime;
items.Add(pItem);
}
}
}
while (m_isoReader.FindNextFile(hFind, &wfd));
m_isoReader.FindClose(hFind);
return true;
}
/* STATIC FUNCTIONS */
bool CCurlFile::GetHttpHeader(const CURL &url, CHttpHeader &headers)
{
try
{
CCurlFile file;
if(file.Stat(url, NULL) == 0)
{
headers = file.GetHttpHeader();
return true;
}
return false;
}
catch(...)
{
CLog::Log(LOGERROR, "%s - Exception thrown while trying to retrieve header url: %s", __FUNCTION__, url.Get().c_str());
return false;
}
}
bool CFileCDDA::IsValidFile(const CURL& url)
{
// Only .cdda files are supported
return URIUtils::HasExtension(url.Get(), ".cdda");
}
bool CZeroconfDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
assert(strPath.substr(0, 11) == "zeroconf://");
CStdString path = strPath.substr(11, strPath.length());
URIUtils::RemoveSlashAtEnd(path);
if(path.empty())
{
std::vector<CZeroconfBrowser::ZeroconfService> found_services = CZeroconfBrowser::GetInstance()->GetFoundServices();
for(std::vector<CZeroconfBrowser::ZeroconfService>::iterator it = found_services.begin(); it != found_services.end(); ++it)
{
//only use discovered services we can connect to through directory
CStdString tmp;
if(GetXBMCProtocol(it->GetType(), tmp))
{
CFileItemPtr item(new CFileItem("", true));
CURL url;
url.SetProtocol("zeroconf");
CStdString service_path = CZeroconfBrowser::ZeroconfService::toPath(*it);
CURL::Encode(service_path);
url.SetFileName(service_path);
item->m_strPath = url.Get();
//now do the formatting
CStdString protocol = GetHumanReadableProtocol(it->GetType());
item->SetLabel(it->GetName() + " (" + protocol + ")");
item->SetLabelPreformated(true);
//just set the default folder icon
item->FillInDefaultIcon();
items.Add(item);
}
}
return true;
} else
{
//decode the path first
CStdString decoded = path;
CURL::Decode(decoded);
try
{
CZeroconfBrowser::ZeroconfService zeroconf_service = CZeroconfBrowser::ZeroconfService::fromPath(decoded);
if(!CZeroconfBrowser::GetInstance()->ResolveService(zeroconf_service))
{
CLog::Log(LOGINFO, "CZeroconfDirectory::GetDirectory service ( %s ) could not be resolved in time", zeroconf_service.GetName().c_str());
return false;
}
else
{
assert(!zeroconf_service.GetIP().empty());
CURL service;
service.SetPort(zeroconf_service.GetPort());
service.SetHostName(zeroconf_service.GetIP());
//do protocol conversion (_smb._tcp -> smb)
//ToDo: try automatic conversion -> remove leading '_' and '._tcp'?
CStdString protocol;
if(!GetXBMCProtocol(zeroconf_service.GetType(), protocol))
{
CLog::Log(LOGERROR, "CZeroconfDirectory::GetDirectory Unknown service type (%s), skipping; ", zeroconf_service.GetType().c_str());
return false;
}
service.SetProtocol(protocol);
return CDirectory::GetDirectory(service.Get(), items, "", true, true);
}
} catch (std::runtime_error& e) {
CLog::Log(LOGERROR, "CZeroconfDirectory::GetDirectory failed getting directory: '%s'. Error: '%s'", decoded.c_str(), e.what());
return false;
}
}
}
void CGUIWindowFileManager::OnClick(int iList, int iItem)
{
if ( iList < 0 || iList >= 2) return ;
if ( iItem < 0 || iItem >= m_vecItems[iList]->Size() ) return ;
CFileItemPtr pItem = m_vecItems[iList]->Get(iItem);
if (pItem->GetPath() == "add" && pItem->GetLabel() == g_localizeStrings.Get(1026)) // 'add source button' in empty root
{
if (CGUIDialogMediaSource::ShowAndAddMediaSource("files"))
{
m_rootDir.SetSources(*CMediaSourceSettings::Get().GetSources("files"));
Update(0,m_Directory[0]->GetPath());
Update(1,m_Directory[1]->GetPath());
}
return;
}
if (!pItem->m_bIsFolder && pItem->IsFileFolder(EFILEFOLDER_MASK_ALL))
{
XFILE::IFileDirectory *pFileDirectory = NULL;
pFileDirectory = XFILE::CFileDirectoryFactory::Create(pItem->GetURL(), pItem.get(), "");
if(pFileDirectory)
pItem->m_bIsFolder = true;
else if(pItem->m_bIsFolder)
pItem->m_bIsFolder = false;
delete pFileDirectory;
}
if (pItem->m_bIsFolder)
{
// save path + drive type because of the possible refresh
CStdString strPath = pItem->GetPath();
int iDriveType = pItem->m_iDriveType;
if ( pItem->m_bIsShareOrDrive )
{
if ( !g_passwordManager.IsItemUnlocked( pItem.get(), "files" ) )
{
Refresh();
return ;
}
if ( !HaveDiscOrConnection( strPath, iDriveType ) )
return ;
}
if (!Update(iList, strPath))
ShowShareErrorMessage(pItem.get());
}
else if (pItem->IsZIP() || pItem->IsCBZ()) // mount zip archive
{
CURL pathToUrl = URIUtils::CreateArchivePath("zip", pItem->GetURL(), "");
Update(iList, pathToUrl.Get());
}
else if (pItem->IsRAR() || pItem->IsCBR())
{
CURL pathToUrl = URIUtils::CreateArchivePath("rar", pItem->GetURL(), "");
Update(iList, pathToUrl.Get());
}
else
{
OnStart(pItem.get());
return ;
}
// UpdateButtons();
}
