bool CUploader::Upload(UploadTask* task) {
if (!m_CurrentEngine) {
Error(true, "Cannot proceed: m_CurrentEngine is NULL!");
return false;
}
std::string FileName;
if ( task->getType() == "file" ) {
FileName = ((FileUploadTask*)task)->getFileName();
if ( FileName.empty() ) {
Error(true, "Empty filename!");
return false;
}
if ( ! IuCoreUtils::FileExists (FileName) ) {
Error(true, "File \""+FileName+"\" doesn't exist!");
return false;
}
}
m_PrInfo.IsUploading = false;
m_PrInfo.Total = 0;
m_PrInfo.Uploaded = 0;
m_FileName = FileName;
m_bShouldStop = false;
if (onConfigureNetworkClient)
onConfigureNetworkClient(&m_NetworkClient);
m_CurrentEngine->setNetworkClient(&m_NetworkClient);
m_CurrentEngine->onDebugMessage.bind(this, &CUploader::DebugMessage);
m_CurrentEngine->onNeedStop.bind(this, &CUploader::needStop);
m_CurrentEngine->onStatusChanged.bind(this, &CUploader::SetStatus);
m_CurrentEngine->onErrorMessage.bind(this, &CUploader::ErrorMessage);
m_CurrentEngine->setThumbnailWidth(m_nThumbWidth);
CIUUploadParams uparams;
uparams.thumbWidth = m_nThumbWidth;
m_NetworkClient.setProgressCallback(pluginProgressFunc, (void*)this);
int EngineRes = 0;
int i = 0;
do
{
if (needStop())
{
Cleanup();
return false;
}
EngineRes = m_CurrentEngine->doUpload(task, uparams);
if ( EngineRes == -1 ) {
Cleanup();
return false;
}
i++;
if (needStop())
{
Cleanup();
return false;
}
if (!EngineRes && i != m_CurrentEngine->RetryLimit())
{
Error(false, "", etRepeating, i);
}
}
while (!EngineRes && i < m_CurrentEngine->RetryLimit());
if (!EngineRes)
{
Error(true, "", etRetriesLimitReached);
Cleanup();
return false;
}
m_ImageUrl = (uparams.DirectUrl);
m_ThumbUrl = (uparams.ThumbUrl);
m_DownloadUrl = (uparams.ViewUrl);
return true;
}
void CFileDownloader::memberThreadFunc()
{
NetworkClient nm;
// Providing callback function to stop downloading
nm.setProgressCallback(CFileDownloader::ProgressFunc, this);
m_CS.Lock();
if (onConfigureNetworkClient)
onConfigureNetworkClient(&nm);
m_CS.Unlock();
for (;; )
{
DownloadFileListItem curItem;
if (!getNextJob(curItem))
break;
std::string url = curItem.url;
if (url.empty())
break;
nm.setOutputFile(curItem.fileName);
if ( !curItem.referer.empty() ) {
nm.setReferer(curItem.referer);
}
nm.doGet(url);
if (m_NeedStop)
break;
m_CS.Lock();
if (nm.responseCode() >= 200 && nm.responseCode() <= 299)
{
std::string name = IuCoreUtils::ExtractFileName(url);
if (!onFileFinished.empty())
onFileFinished(true, nm.responseCode(), curItem); // delegate call
}
else
{
if (!onFileFinished.empty())
onFileFinished(false, nm.responseCode(), curItem); // delegate call
}
if (m_NeedStop)
m_fileList.clear();
m_CS.Unlock();
}
m_CS.Lock();
HANDLE hThread = GetCurrentThread();
for (size_t i = 0; i < m_hThreads.size(); i++)
{
if (m_hThreads[i] == hThread)
{
m_hThreads.erase(m_hThreads.begin() + i);
break;
}
}
m_nRunningThreads--;
if (m_NeedStop)
m_fileList.clear();
m_CS.Unlock(); // We need to release mutex before calling onQueueFinished()
// otherwise we may get a deadlock
if (!m_nRunningThreads)
{
m_IsRunning = false;
m_NeedStop = false;
if (onQueueFinished) // it is a delegate
onQueueFinished();
}
return;
}
