void CWebCache::RequestRandom()
{
qDebug("RequestRandom()");
quint32 nIndex = rand() % m_lCaches.size();
if(m_lCaches[nIndex].CanQuery())
{
CancelRequests();
m_bRequesting = true;
QUrl u = m_lCaches.at(nIndex).m_sUrl;
u.addQueryItem("get", "1");
u.addQueryItem("hostfile", "1");
u.addQueryItem("net", "gnutella2");
u.addQueryItem("client", "BROV1.0");
systemLog.postLog(tr("Querying ").arg(u.toString()), LogSeverity::Debug);
//qDebug("Querying " + u.toString().toAscii());
m_lCaches[nIndex].m_tLastQuery = time(0);
QNetworkRequest req(u);
req.setRawHeader("User-Agent", "G2Core/0.1");
m_pRequest = new QNetworkAccessManager();
connect(m_pRequest, SIGNAL(finished(QNetworkReply*)), this, SLOT(OnRequestComplete(QNetworkReply*)));
m_pReply = m_pRequest->get(req);
}
CWebCache::~CWebCache()
{
qDebug("Destroying CWebCache");
delete m_pRequest;
m_pRequest = 0;
CancelRequests();
}
void AlbumCoverManager::ArtistChanged(QListWidgetItem* current) {
if (!current) return;
QString artist;
if (current->type() == Specific_Artist) artist = current->text();
ui_->albums->clear();
context_menu_items_.clear();
CancelRequests();
// Get the list of albums. How we do it depends on what thing we have
// selected in the artist list.
LibraryBackend::AlbumList albums;
switch (current->type()) {
case Various_Artists:
albums = library_backend_->GetCompilationAlbums();
break;
case Specific_Artist:
albums = library_backend_->GetAlbumsByArtist(current->text());
break;
case All_Artists:
default:
albums = library_backend_->GetAllAlbums();
break;
}
// Sort by album name. The list is already sorted by sqlite but it was done
// case sensitively.
qStableSort(albums.begin(), albums.end(), CompareAlbumNameNocase);
for (const LibraryBackend::Album& info : albums) {
// Don't show songs without an album, obviously
if (info.album_name.isEmpty()) continue;
QListWidgetItem* item =
new QListWidgetItem(no_cover_icon_, info.album_name, ui_->albums);
item->setData(Role_ArtistName, info.artist);
item->setData(Role_AlbumName, info.album_name);
item->setData(Role_FirstUrl, info.first_url);
item->setData(Qt::TextAlignmentRole,
QVariant(Qt::AlignTop | Qt::AlignHCenter));
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled |
Qt::ItemIsDragEnabled);
item->setToolTip(info.artist + " - " + info.album_name);
if (!info.art_automatic.isEmpty() || !info.art_manual.isEmpty()) {
quint64 id = app_->album_cover_loader()->LoadImageAsync(
cover_loader_options_, info.art_automatic, info.art_manual,
info.first_url.toLocalFile());
item->setData(Role_PathAutomatic, info.art_automatic);
item->setData(Role_PathManual, info.art_manual);
cover_loading_tasks_[id] = item;
}
}
UpdateFilter();
}
// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
//
CMPXPlaybackSession::~CMPXPlaybackSession()
{
CancelRequests();
CMPXPlaybackServer* server = static_cast<CMPXPlaybackServer*>(
const_cast<CServer2*>(Server()));
if ( iMessageQueue )
{
server->RemoveClient( *iMessageQueue );
}
delete iSyncBuffer;
delete iAsyncBuffer;
delete iMedia;
delete iMessageQueue;
}
void AlbumCoverManager::closeEvent(QCloseEvent* e) {
if (!cover_fetching_tasks_.isEmpty()) {
boost::scoped_ptr<QMessageBox> message_box(new QMessageBox(
QMessageBox::Question, tr("Really cancel?"),
tr("Closing this window will stop searching for album covers."),
QMessageBox::Abort, this));
message_box->addButton(tr("Don't stop!"), QMessageBox::AcceptRole);
if (message_box->exec() != QMessageBox::Abort) {
e->ignore();
return;
}
}
// Save geometry
QSettings s;
s.beginGroup(kSettingsGroup);
s.setValue("geometry", saveGeometry());
s.setValue("splitter_state", ui_->splitter->saveState());
// Cancel any outstanding requests
CancelRequests();
}
AlbumCoverManager::~AlbumCoverManager() {
CancelRequests();
delete ui_;
}
AlbumCoverManager::AlbumCoverManager(Application* app,
LibraryBackend* library_backend,
QWidget* parent,
QNetworkAccessManager* network)
: QMainWindow(parent),
ui_(new Ui_CoverManager),
app_(app),
album_cover_choice_controller_(new AlbumCoverChoiceController(this)),
cover_fetcher_(
new AlbumCoverFetcher(app_->cover_providers(), this, network)),
cover_searcher_(nullptr),
cover_export_(nullptr),
cover_exporter_(new AlbumCoverExporter(this)),
artist_icon_(IconLoader::Load("x-clementine-artist")),
all_artists_icon_(IconLoader::Load("x-clementine-album")),
context_menu_(new QMenu(this)),
progress_bar_(new QProgressBar(this)),
abort_progress_(new QPushButton(this)),
jobs_(0),
library_backend_(library_backend) {
ui_->setupUi(this);
ui_->albums->set_cover_manager(this);
// Icons
ui_->action_fetch->setIcon(IconLoader::Load("download"));
ui_->export_covers->setIcon(IconLoader::Load("document-save"));
ui_->view->setIcon(IconLoader::Load("view-choose"));
ui_->fetch->setIcon(IconLoader::Load("download"));
ui_->action_add_to_playlist->setIcon(
IconLoader::Load("media-playback-start"));
ui_->action_load->setIcon(IconLoader::Load("media-playback-start"));
album_cover_choice_controller_->SetApplication(app_);
// Get a square version of nocover.png
QImage nocover(":/nocover.png");
nocover =
nocover.scaled(120, 120, Qt::KeepAspectRatio, Qt::SmoothTransformation);
QImage square_nocover(120, 120, QImage::Format_ARGB32);
square_nocover.fill(0);
QPainter p(&square_nocover);
p.setOpacity(0.4);
p.drawImage((120 - nocover.width()) / 2, (120 - nocover.height()) / 2,
nocover);
p.end();
no_cover_icon_ = QPixmap::fromImage(square_nocover);
cover_searcher_ = new AlbumCoverSearcher(no_cover_icon_, app_, this);
cover_export_ = new AlbumCoverExport(this);
// Set up the status bar
statusBar()->addPermanentWidget(progress_bar_);
statusBar()->addPermanentWidget(abort_progress_);
progress_bar_->hide();
abort_progress_->hide();
abort_progress_->setText(tr("Abort"));
connect(abort_progress_, SIGNAL(clicked()), this, SLOT(CancelRequests()));
ui_->albums->setAttribute(Qt::WA_MacShowFocusRect, false);
ui_->artists->setAttribute(Qt::WA_MacShowFocusRect, false);
QShortcut* close = new QShortcut(QKeySequence::Close, this);
connect(close, SIGNAL(activated()), SLOT(close()));
EnableCoversButtons();
}
// ----------------------------------------------------------------------------
// Message dispatcher
// ----------------------------------------------------------------------------
//
void CMPXPlaybackSession::DispatchMessageL( const RMessage2& aMessage, TInt& aMsgHandleResult )
{
aMsgHandleResult = KErrNone;
//
// All methods apart from the player creation methods, require a player
//
TInt op=aMessage.Function();
if (op != EPbsSetMode)
{
CheckPlayerL();
}
MPX_DEBUG3("-->CMPXPlaybackSession::DispatchMessageL %d, this 0x%08x",
op, this);
switch(op)
{
case EPbsSetMode:
{
SetModeL(aMessage);
break;
}
case EPbsGetClients:
{
RArray<TProcessId> procArray;
::CopyArrayL<TProcessId>(
iPlayer->ClientList()->ClientProcessList(),
procArray );
TProcessId lastPid = static_cast<CMPXPlaybackServer*>(
const_cast<CServer2*>(Server()))->LastActiveProcessId();
TInt index( procArray.Find( lastPid ));
if ( KErrNotFound != index && index )
{
procArray.Remove( index );
procArray.Insert( lastPid, 0 );
}
::CreateBufferL<TProcessId>(
procArray.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
procArray.Close();
break;
}
case EPbsGetSyncBuffer:
{
aMessage.WriteL(0,iSyncBuffer->Ptr(0));
delete iSyncBuffer;
iSyncBuffer = NULL;
break;
}
case EPbsGetAsyncBuffer:
{
//In case of other application leaving, causing us to leave
//we could have a task that does not get removed from the top of the queue
//but the data for that task has been deleted.
//When the task runs again, there will be no data causing a panic - leave if this occurs
User::LeaveIfNull(iAsyncBuffer);
aMessage.WriteL(0,iAsyncBuffer->Ptr(0));
delete iAsyncBuffer;
iAsyncBuffer = NULL;
break;
}
case EPbsInitFromCollection:
{
MPXUser::CreateBufferL(aMessage, 0, iSyncBuffer);
CMPXCollectionPlaylist* p = NULL;
::NewFromBufferL(*iSyncBuffer, p);
delete iSyncBuffer;
iSyncBuffer = NULL;
CleanupStack::PushL(p);
iPlayer->InitL(*p,aMessage.Int1());
CleanupStack::PopAndDestroy(p);
}
break;
case EPbsInitFromUri:
{
CBufBase* buf0(NULL);
MPXUser::CreateBufferL(aMessage,0,buf0);
CleanupStack::PushL(buf0);
// Type parameter is optional
if ( aMessage.GetDesLength( 1 ) > 0 )
{
CBufBase* buf1(NULL);
MPXUser::CreateBufferL(aMessage,1,buf1);
CleanupStack::PushL(buf1);
iPlayer->InitL(MPXUser::Ptr(buf0->Ptr(0)), buf1->Ptr(0));
CleanupStack::PopAndDestroy(buf1);
}
else
{
MPX_DEBUG2("CMPXPlaybackSession::DispatchMessageL %d: Type is empty", op);
iPlayer->InitL( MPXUser::Ptr( buf0->Ptr(0) ), KNullDesC8 );
}
CleanupStack::PopAndDestroy(buf0);
}
break;
case EPbsInitFromFile:
{
InitFromFileL(aMessage);
break;
}
case EPbsInitStreamingFromUri:
{
CBufBase* buf0(NULL);
MPXUser::CreateBufferL(aMessage,0,buf0);
CleanupStack::PushL(buf0);
// Type parameter is optional
if ( aMessage.GetDesLength( 1 ) > 0 )
{
CBufBase* buf1(NULL);
MPXUser::CreateBufferL(aMessage,1,buf1);
CleanupStack::PushL(buf1);
iPlayer->InitStreamingL(MPXUser::Ptr(buf0->Ptr(0)), buf1->Ptr(0), aMessage.Int2());
CleanupStack::PopAndDestroy(buf1);
}
else
{
MPX_DEBUG2("CMPXPlaybackSession::DispatchMessageL %d: Type is empty", op);
iPlayer->InitStreamingL( MPXUser::Ptr( buf0->Ptr(0) ), KNullDesC8, aMessage.Int2() );
}
CleanupStack::PopAndDestroy(buf0);
break;
}
case EPbsInitStreamingFromFile:
{
RFile file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->InitStreamingL(file, aMessage.Int2());
file.Close();
break;
}
case EPbsCancelRequest:
{
CancelRequests();
break;
}
case EPbsGetState:
{
aMsgHandleResult = iPlayer->State();
break;
}
case EPbsSetProperty:
{
iPlayer->SetL(static_cast<TMPXPlaybackProperty>(aMessage.Int0()),
aMessage.Int1());
break;
}
case EPbsGetProperty:
{
SetAsync(aMessage);
iPlayer->PropertyL(
static_cast<TMPXPlaybackProperty>(aMessage.Int0()),*this);
break;
}
case EPbsGetPlayerTypes:
{
RArray<TMPXPlaybackPlayerType> pluginTypes;
CleanupClosePushL(pluginTypes);
RArray<TInt> types;
CleanupClosePushL(types);
iPlayer->PluginHandler()->GetPluginTypes(types);
for (TInt i=0; i< types.Count(); ++i)
{
pluginTypes.AppendL(
static_cast<TMPXPlaybackPlayerType>(types[i]));
}
CleanupStack::PopAndDestroy(&types);
::CreateBufferL<TMPXPlaybackPlayerType>(
pluginTypes.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(&pluginTypes);
break;
}
case EPbsGetPlayerTypeDisplayName:
{
const TDesC& playerName = iPlayer->PluginHandler()->PlayerName(
static_cast<TMPXPlaybackPlayerType>(aMessage.Int0()));
aMsgHandleResult = 0;
if (playerName.Length()>0)
{
MPXUser::CreateBufferL(playerName, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetAllPlayersUids:
{
RArray<TUid> uids;
CleanupClosePushL(uids);
iPlayer->PluginHandler()->GetPluginUids(uids);
::CreateBufferL<TUid>(
uids.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(&uids);
break;
}
case EPbsGetPlayersUidsForType:
{
aMsgHandleResult = CreatePlayerUidsBufferL(aMessage);
break;
}
case EPbsGetSubPlayerNamesByUid:
{
SetAsync(aMessage);
iPlayer->SubPlayerNamesL(TUid::Uid(aMessage.Int0()),*this);
break;
}
case EPbsSelectPlayerByType:
{
iPlayer->PluginHandler()->SelectPlayersL(
static_cast<TMPXPlaybackPlayerType>(aMessage.Int0()));
break;
}
case EPbsSelectPlayerByUid:
{
iPlayer->PluginHandler()->SelectPlayerL(TUid::Uid(aMessage.Int0()));
break;
}
case EPbsSelectSubPlayer:
{
iPlayer->PluginHandler()->SelectSubPlayerL(
TUid::Uid(aMessage.Int0()),aMessage.Int1());
break;
}
case EPbsClearPlayerSelection:
{
iPlayer->PluginHandler()->ClearSelectPlayersL();
break;
}
case EPbsGetSelection:
{
GetSelectionL(aMessage);
break;
}
case EPbsPlayerFound:
{
aMsgHandleResult = iPlayer->PluginHandler()->PlayerFound();
break;
}
case EPbsGetPlayerType:
{
aMsgHandleResult = iPlayer->PluginHandler()->PluginType();
break;
}
case EPbsGetTypeName:
{
MPXUser::CreateBufferL(iPlayer->PluginHandler()->PlayerName(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
break;
}
case EPbsGetSubPlayerIndex:
{
aMsgHandleResult = iPlayer->PluginHandler()->SubPlayer();
break;
}
case EPbsGetPlayerUid:
{
TPckgC<TInt> uidPkg((iPlayer->PluginHandler()->PluginUid()).iUid);
aMessage.Write(0,uidPkg);
break;
}
case EPbsGetCollectionPlaylist:
{
aMsgHandleResult = 0;
if (iPlayer->Playlist())
{
::CreateBufferL<CMPXCollectionPlaylist>(*(iPlayer->Playlist()),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetFile:
{
const RFile& file = iPlayer->File();
if (file.SubSessionHandle())
{
aMsgHandleResult = file.TransferToClient(aMessage,0); //message completed
}
else
{
TPckgC<TInt> handle(KErrNotFound);
aMessage.Write(0, handle);
}
break;
}
case EPbsGetUri:
{
aMsgHandleResult=0;
if (iPlayer->Uri().Length()>0)
{
MPXUser::CreateBufferL(iPlayer->Uri(),iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetMedia:
{
SetAsync( aMessage );
CMPXCommand* cmd( CMPXCommand::NewL( aMessage.Int1() ) );
CleanupStack::PushL( cmd );
iPlayer->MediaL( *this, *cmd );
CleanupStack::PopAndDestroy( cmd );
break;
}
case EPbsGetSupportedMimeTypes:
{
CDesCArray* mimeTypes =
iPlayer->PluginHandler()->SupportedMimeTypesL();
CleanupStack::PushL(mimeTypes);
MPXUser::CreateBufferL((const MDesCArray*)mimeTypes, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(mimeTypes);
}
break;
case EPbsGetSupportedExtensions:
{
CDesCArray* exts =
iPlayer->PluginHandler()->SupportedExtensionsL();
CleanupStack::PushL(exts);
MPXUser::CreateBufferL((const MDesCArray*)exts, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(exts);
}
break;
case EPbsGetSupportedSchemas:
{
CDesCArray* schemas =
iPlayer->PluginHandler()->SupportedSchemasL();
CleanupStack::PushL(schemas);
MPXUser::CreateBufferL((const MDesCArray*)schemas, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(schemas);
}
break;
case EPbsGetNextMessage:
{
ASSERT(iMessageQueue);
iMessageQueue->SendNext(aMessage);
iCompleteRequest=EFalse;
break;
}
case EPbsCancelGetMessage:
{
ASSERT(iMessageQueue);
iMessageQueue->Reset();
break;
}
case EPbsCommand:
{
CMPXCommand* cmd( NULL );
::NewFromMessageL<CMPXMedia>(aMessage, 1, cmd);
CleanupStack::PushL(cmd);
iPlayer->CommandL(*cmd, *iMessageQueue);
CleanupStack::PopAndDestroy(cmd);
break;
}
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
case EPbsInitFromFile64:
{
RFile64 file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->Init64L(file);
file.Close();
break;
}
case EPbsInitStreamingFromFile64:
{
RFile64 file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->InitStreaming64L(file, aMessage.Int2());
file.Close();
break;
}
case EPbsGetFile64:
{
const RFile64& file = iPlayer->File64();
if (file.SubSessionHandle())
{
aMsgHandleResult = file.TransferToClient(aMessage,0); //message completed
}
else
{
TPckgC<TInt> handle(KErrNotFound);
aMessage.Write(0, handle);
}
break;
}
#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
case EPbsSetPrimaryClient:
{
aMsgHandleResult = iPlayer->ClientList()->SetPrimaryClient(*iMessageQueue);
break;
}
default:
{
PanicClient(aMessage,KErrNotSupported);
break;
}
}
MPX_DEBUG1("<---CMPXPlaybackSession::DispatchMessageL");
}