upplay / Code / Diff of /application.cpp

Diff of /application.cpp [bce59a] .. [78a4ff]

Switch to unified view


...
    return MRDH();
}


Application::Application(QApplication* qapp, QObject *parent)
    : QObject(parent), m_player(0), m_cdb(0), m_rdco(0),
      m_avto(0), m_ohtmo(0), m_ohvlo(0), m_ohpro(0),
      m_ui_playlist(0), m_sctool(0), m_settings(0), m_app(qapp),
      m_initialized(false), m_playlistIsPlaylist(false),
      m_ohsourcetype(OHProductQO::OHPR_SourceUnknown)
{
    m_settings = CSettingsStorage::getInstance();

    QString version = UPPLAY_VERSION;
...
    dlg.rndsLW->addItem("Radio");
    if (!dlg.exec()) {
        return;
    }
    int row = dlg.rndsLW->currentRow();
    if (m_playlist) {
        m_playlist->psl_stop();
    }
    m_player->stopped();

    if (row == 1) {
        QString fn = QDir(Helper::getSharePath()).filePath("radiolist.xml");
        m_playlist = shared_ptr<Playlist>(new PlaylistLOCRD(m_avto,
                                                            fn.toLocal8Bit()));
        m_playlistIsPlaylist = false;
    } else {
        m_playlist = shared_ptr<Playlist>(new PlaylistAVT(m_avto,
                                                          m_rdr->desc()->UDN));
        m_playlistIsPlaylist = true;
    }
    playlist_connections();
}

void Application::openSongcast()
...
    }
}

bool Application::setupRenderer(const string& uid)
{

    deleteZ(m_rdco);
    deleteZ(m_avto);
    deleteZ(m_ohtmo);
    deleteZ(m_ohvlo);
    deleteZ(m_ohpro);
...
    }

    // Keep this after avt object creation !
    if (!m_playlist) {
        qDebug() <<"Application::setupRenderer: using AVT playlist";
        m_playlist = shared_ptr<Playlist>(new PlaylistAVT(m_avto,
                                                         m_rdr->desc()->UDN));
        m_playlistIsPlaylist = true;
    }


    // Use either renderingControl or ohvolume for volume control.
    if (m_rdr->rdc()) {
...
    return true;
}

void Application::createPlaylistForOpenHomeSource()
{


    m_ohsourcetype = m_ohpro->getSourceType();

    switch (m_ohsourcetype) {

    case OHProductQO::OHPR_SourceRadio:
...
            qDebug() << "Application::createPlaylistForOpenHomeSource: "
                "radio mode, but can't connect";
            return;
        }
        OHIFH ohif = m_rdr->ohif();
        m_playlist = shared_ptr<Playlist>(
            new PlaylistOHRD(new OHRad(ohrd), ohif ? new OHInf(ohif) : 0));
        m_playlistIsPlaylist = false;
    }
    break;

    case OHProductQO::OHPR_SourceReceiver:
    {
...
        if (!ohrc) {
            qDebug() << "Application::createPlaylistForOpenHomeSource: "
                "receiver mode, but can't connect";
            return;
        }
        m_playlist = shared_ptr<Playlist>(
            new PlaylistOHRCV(ohrc, u8s2qs(m_rdr->desc()->friendlyName)));
        m_playlistIsPlaylist = false;
    }
    break;

    case OHProductQO::OHPR_SourcePlaylist:
    {
        OHPLH ohpl = m_rdr->ohpl();
        if (ohpl) {
            m_playlist = shared_ptr<Playlist>(
                new PlaylistOHPL(new OHPlayer(ohpl)));
            m_playlistIsPlaylist = true;
        }
    }
    break;

    default:
    {
        m_playlist = shared_ptr<Playlist>(new PlaylistNULL());
        m_playlistIsPlaylist = false;
    }
    break;
    }

    if (!m_playlist) {
...

// We may switch the playlist when an openhome renderer switches sources. So
// set the playlist connections in a separate function
void Application::playlist_connections()
{
    if (m_playlistIsPlaylist)
        m_cdb->setPlaylist(m_playlist);
    else
        m_cdb->setPlaylist(shared_ptr<Playlist>());

    // Use either ohtime or avt for time updates
    if (m_ohtmo) {
        CONNECT(m_ohtmo, secsInSongChanged(quint32),
                m_playlist.get(), onRemoteSecsInSong(quint32));
    } else if (m_avto) {
        CONNECT(m_avto, secsInSongChanged(quint32),
                m_playlist.get(), onRemoteSecsInSong(quint32));
    }

    CONNECT(m_player, play(), m_playlist.get(), psl_play());
    CONNECT(m_player, pause(), m_playlist.get(), psl_pause());
    CONNECT(m_player, stop(), m_playlist.get(), psl_stop());
    CONNECT(m_player, forward(), m_playlist.get(), psl_forward());
    CONNECT(m_player, backward(), m_playlist.get(), psl_backward());
    CONNECT(m_player, sig_load_playlist(), m_playlist.get(), psl_load_playlist());
    CONNECT(m_player, sig_save_playlist(), m_playlist.get(), psl_save_playlist());
    CONNECT(m_player, sig_seek(int), m_playlist.get(), psl_seek(int));

    CONNECT(m_playlist.get(), connectionLost(), this, reconnectOrChoose());
    CONNECT(m_playlist.get(), playlistModeChanged(Playlist_Mode),
            m_ui_playlist, setPlayerMode(Playlist_Mode));
    CONNECT(m_playlist.get(), sig_track_metadata(const MetaData&),
            m_player, update_track(const MetaData&));
    CONNECT(m_playlist.get(), sig_stopped(),  m_player, stopped());
    CONNECT(m_playlist.get(), sig_paused(),  m_player, paused());
    CONNECT(m_playlist.get(), sig_playing(),  m_player, playing());
    CONNECT(m_playlist.get(), sig_playing_track_changed(int),
            m_ui_playlist, track_changed(int));
    CONNECT(m_playlist.get(), sig_playlist_updated(MetaDataList&, int, int),
            m_ui_playlist, fillPlaylist(MetaDataList&, int, int));
    CONNECT(m_ui_playlist, selection_min_row(int),
            m_playlist.get(), psl_selection_min_row(int));
    CONNECT(m_ui_playlist, playlist_mode_changed(const Playlist_Mode&),
            m_playlist.get(), psl_change_mode(const Playlist_Mode&));
    CONNECT(m_ui_playlist, dropped_tracks(const MetaDataList&, int),
            m_playlist.get(), psl_insert_tracks(const MetaDataList&, int));
    CONNECT(m_ui_playlist, sig_rows_removed(const QList<int>&, bool),
            m_playlist.get(), psl_remove_rows(const QList<int>&, bool));
    CONNECT(m_ui_playlist, sig_sort_tno(),
            m_playlist.get(), psl_sort_by_tno());
    CONNECT(m_ui_playlist, row_activated(int),
            m_playlist.get(), psl_change_track(int));
    CONNECT(m_ui_playlist, clear_playlist(),
            m_playlist.get(), psl_clear_playlist());

    m_playlist->update_state();
}

void Application::renderer_connections()

	a/application.cpp		b/application.cpp
	...		...
97	return MRDH();	97	return MRDH();
98	}	98	}
99		99
100		100
101	Application::Application(QApplication* qapp, QObject *parent)	101	Application::Application(QApplication* qapp, QObject *parent)
102	: QObject(parent), m_player(0), m_playlist(0), m_cdb(0), m_rdco(0),	102	: QObject(parent), m_player(0), m_cdb(0), m_rdco(0),
103	m_avto(0), m_ohtmo(0), m_ohvlo(0), m_ohpro(0),	103	m_avto(0), m_ohtmo(0), m_ohvlo(0), m_ohpro(0),
104	m_ui_playlist(0), m_sctool(0), m_settings(0), m_app(qapp),	104	m_ui_playlist(0), m_sctool(0), m_settings(0), m_app(qapp),
105	m_initialized(false),	105	m_initialized(false), m_playlistIsPlaylist(false),
106	m_ohsourcetype(OHProductQO::OHPR_SourceUnknown)	106	m_ohsourcetype(OHProductQO::OHPR_SourceUnknown)
107	{	107	{
108	m_settings = CSettingsStorage::getInstance();	108	m_settings = CSettingsStorage::getInstance();
109		109
110	QString version = UPPLAY_VERSION;	110	QString version = UPPLAY_VERSION;
	...		...
271	dlg.rndsLW->addItem("Radio");	271	dlg.rndsLW->addItem("Radio");
272	if (!dlg.exec()) {	272	if (!dlg.exec()) {
273	return;	273	return;
274	}	274	}
275	int row = dlg.rndsLW->currentRow();	275	int row = dlg.rndsLW->currentRow();
		276	if (m_playlist) {
276	m_playlist->psl_stop();	277	m_playlist->psl_stop();
		278	}
277	m_player->stopped();	279	m_player->stopped();
278	deleteZ(m_playlist);
279	if (row == 1) {	280	if (row == 1) {
280	QString fn = QDir(Helper::getSharePath()).filePath("radiolist.xml");	281	QString fn = QDir(Helper::getSharePath()).filePath("radiolist.xml");
281	m_playlist = new PlaylistLOCRD(m_avto, fn.toLocal8Bit());	282	m_playlist = shared_ptr<Playlist>(new PlaylistLOCRD(m_avto,
		283	fn.toLocal8Bit()));
		284	m_playlistIsPlaylist = false;
282	} else {	285	} else {
283	m_playlist = new PlaylistAVT(m_avto, m_rdr->desc()->UDN);	286	m_playlist = shared_ptr<Playlist>(new PlaylistAVT(m_avto,
		287	m_rdr->desc()->UDN));
		288	m_playlistIsPlaylist = true;
284	}	289	}
285	playlist_connections();	290	playlist_connections();
286	}	291	}
287		292
288	void Application::openSongcast()	293	void Application::openSongcast()
	...		...
315	}	320	}
316	}	321	}
317		322
318	bool Application::setupRenderer(const string& uid)	323	bool Application::setupRenderer(const string& uid)
319	{	324	{
320	deleteZ(m_playlist);
321	deleteZ(m_rdco);	325	deleteZ(m_rdco);
322	deleteZ(m_avto);	326	deleteZ(m_avto);
323	deleteZ(m_ohtmo);	327	deleteZ(m_ohtmo);
324	deleteZ(m_ohvlo);	328	deleteZ(m_ohvlo);
325	deleteZ(m_ohpro);	329	deleteZ(m_ohpro);
	...		...
373	}	377	}
374		378
375	// Keep this after avt object creation !	379	// Keep this after avt object creation !
376	if (!m_playlist) {	380	if (!m_playlist) {
377	qDebug() <<"Application::setupRenderer: using AVT playlist";	381	qDebug() <<"Application::setupRenderer: using AVT playlist";
378	m_playlist = new PlaylistAVT(m_avto, m_rdr->desc()->UDN);	382	m_playlist = shared_ptr<Playlist>(new PlaylistAVT(m_avto,
		383	m_rdr->desc()->UDN));
		384	m_playlistIsPlaylist = true;
379	}	385	}
380		386
381		387
382	// Use either renderingControl or ohvolume for volume control.	388	// Use either renderingControl or ohvolume for volume control.
383	if (m_rdr->rdc()) {	389	if (m_rdr->rdc()) {
	...		...
399	return true;	405	return true;
400	}	406	}
401		407
402	void Application::createPlaylistForOpenHomeSource()	408	void Application::createPlaylistForOpenHomeSource()
403	{	409	{
404	deleteZ(m_playlist);
405
406	m_ohsourcetype = m_ohpro->getSourceType();	410	m_ohsourcetype = m_ohpro->getSourceType();
407		411
408	switch (m_ohsourcetype) {	412	switch (m_ohsourcetype) {
409		413
410	case OHProductQO::OHPR_SourceRadio:	414	case OHProductQO::OHPR_SourceRadio:
	...		...
414	qDebug() << "Application::createPlaylistForOpenHomeSource: "	418	qDebug() << "Application::createPlaylistForOpenHomeSource: "
415	"radio mode, but can't connect";	419	"radio mode, but can't connect";
416	return;	420	return;
417	}	421	}
418	OHIFH ohif = m_rdr->ohif();	422	OHIFH ohif = m_rdr->ohif();
419	m_playlist = new PlaylistOHRD(new OHRad(ohrd), ohif ?	423	m_playlist = shared_ptr<Playlist>(
420	new OHInf(ohif) : 0);	424	new PlaylistOHRD(new OHRad(ohrd), ohif ? new OHInf(ohif) : 0));
		425	m_playlistIsPlaylist = false;
421	}	426	}
422	break;	427	break;
423		428
424	case OHProductQO::OHPR_SourceReceiver:	429	case OHProductQO::OHPR_SourceReceiver:
425	{	430	{
	...		...
427	if (!ohrc) {	432	if (!ohrc) {
428	qDebug() << "Application::createPlaylistForOpenHomeSource: "	433	qDebug() << "Application::createPlaylistForOpenHomeSource: "
429	"receiver mode, but can't connect";	434	"receiver mode, but can't connect";
430	return;	435	return;
431	}	436	}
432	m_playlist = new PlaylistOHRCV(ohrc,	437	m_playlist = shared_ptr<Playlist>(
433	u8s2qs(m_rdr->desc()->friendlyName));	438	new PlaylistOHRCV(ohrc, u8s2qs(m_rdr->desc()->friendlyName)));
		439	m_playlistIsPlaylist = false;
434	}	440	}
435	break;	441	break;
436		442
437	case OHProductQO::OHPR_SourcePlaylist:	443	case OHProductQO::OHPR_SourcePlaylist:
438	{	444	{
439	OHPLH ohpl = m_rdr->ohpl();	445	OHPLH ohpl = m_rdr->ohpl();
440	if (ohpl) {	446	if (ohpl) {
		447	m_playlist = shared_ptr<Playlist>(
441	m_playlist = new PlaylistOHPL(new OHPlayer(ohpl));	448	new PlaylistOHPL(new OHPlayer(ohpl)));
		449	m_playlistIsPlaylist = true;
442	}	450	}
443	}	451	}
444	break;	452	break;
445		453
446	default:	454	default:
447	{	455	{
448	m_playlist = new PlaylistNULL();	456	m_playlist = shared_ptr<Playlist>(new PlaylistNULL());
		457	m_playlistIsPlaylist = false;
449	}	458	}
450	break;	459	break;
451	}	460	}
452		461
453	if (!m_playlist) {	462	if (!m_playlist) {
	...		...
501		510
502	// We may switch the playlist when an openhome renderer switches sources. So	511	// We may switch the playlist when an openhome renderer switches sources. So
503	// set the playlist connections in a separate function	512	// set the playlist connections in a separate function
504	void Application::playlist_connections()	513	void Application::playlist_connections()
505	{	514	{
		515	if (m_playlistIsPlaylist)
506	m_cdb->setPlaylist(m_playlist);	516	m_cdb->setPlaylist(m_playlist);
		517	else
		518	m_cdb->setPlaylist(shared_ptr<Playlist>());
507		519
508	// Use either ohtime or avt for time updates	520	// Use either ohtime or avt for time updates
509	if (m_ohtmo) {	521	if (m_ohtmo) {
510	CONNECT(m_ohtmo, secsInSongChanged(quint32),	522	CONNECT(m_ohtmo, secsInSongChanged(quint32),
511	m_playlist, onRemoteSecsInSong(quint32));	523	m_playlist.get(), onRemoteSecsInSong(quint32));
512	} else if (m_avto) {	524	} else if (m_avto) {
513	CONNECT(m_avto, secsInSongChanged(quint32),	525	CONNECT(m_avto, secsInSongChanged(quint32),
514	m_playlist, onRemoteSecsInSong(quint32));	526	m_playlist.get(), onRemoteSecsInSong(quint32));
515	}	527	}
516		528
517	CONNECT(m_player, play(), m_playlist, psl_play());	529	CONNECT(m_player, play(), m_playlist.get(), psl_play());
518	CONNECT(m_player, pause(), m_playlist, psl_pause());	530	CONNECT(m_player, pause(), m_playlist.get(), psl_pause());
519	CONNECT(m_player, stop(), m_playlist, psl_stop());	531	CONNECT(m_player, stop(), m_playlist.get(), psl_stop());
520	CONNECT(m_player, forward(), m_playlist, psl_forward());	532	CONNECT(m_player, forward(), m_playlist.get(), psl_forward());
521	CONNECT(m_player, backward(), m_playlist, psl_backward());	533	CONNECT(m_player, backward(), m_playlist.get(), psl_backward());
522	CONNECT(m_player, sig_load_playlist(), m_playlist, psl_load_playlist());	534	CONNECT(m_player, sig_load_playlist(), m_playlist.get(), psl_load_playlist());
523	CONNECT(m_player, sig_save_playlist(), m_playlist, psl_save_playlist());	535	CONNECT(m_player, sig_save_playlist(), m_playlist.get(), psl_save_playlist());
524	CONNECT(m_player, sig_seek(int), m_playlist, psl_seek(int));	536	CONNECT(m_player, sig_seek(int), m_playlist.get(), psl_seek(int));
525		537
526	CONNECT(m_playlist, connectionLost(), this, reconnectOrChoose());	538	CONNECT(m_playlist.get(), connectionLost(), this, reconnectOrChoose());
527	CONNECT(m_playlist, playlistModeChanged(Playlist_Mode),	539	CONNECT(m_playlist.get(), playlistModeChanged(Playlist_Mode),
528	m_ui_playlist, setPlayerMode(Playlist_Mode));	540	m_ui_playlist, setPlayerMode(Playlist_Mode));
529	CONNECT(m_playlist, sig_track_metadata(const MetaData&),	541	CONNECT(m_playlist.get(), sig_track_metadata(const MetaData&),
530	m_player, update_track(const MetaData&));	542	m_player, update_track(const MetaData&));
531	CONNECT(m_playlist, sig_stopped(), m_player, stopped());	543	CONNECT(m_playlist.get(), sig_stopped(), m_player, stopped());
532	CONNECT(m_playlist, sig_paused(), m_player, paused());	544	CONNECT(m_playlist.get(), sig_paused(), m_player, paused());
533	CONNECT(m_playlist, sig_playing(), m_player, playing());	545	CONNECT(m_playlist.get(), sig_playing(), m_player, playing());
534	CONNECT(m_playlist, sig_playing_track_changed(int),	546	CONNECT(m_playlist.get(), sig_playing_track_changed(int),
535	m_ui_playlist, track_changed(int));	547	m_ui_playlist, track_changed(int));
536	CONNECT(m_playlist, sig_playlist_updated(MetaDataList&, int, int),	548	CONNECT(m_playlist.get(), sig_playlist_updated(MetaDataList&, int, int),
537	m_ui_playlist, fillPlaylist(MetaDataList&, int, int));	549	m_ui_playlist, fillPlaylist(MetaDataList&, int, int));
538	CONNECT(m_ui_playlist, selection_min_row(int),	550	CONNECT(m_ui_playlist, selection_min_row(int),
539	m_playlist, psl_selection_min_row(int));	551	m_playlist.get(), psl_selection_min_row(int));
540	CONNECT(m_ui_playlist, playlist_mode_changed(const Playlist_Mode&),	552	CONNECT(m_ui_playlist, playlist_mode_changed(const Playlist_Mode&),
541	m_playlist, psl_change_mode(const Playlist_Mode&));	553	m_playlist.get(), psl_change_mode(const Playlist_Mode&));
542	CONNECT(m_ui_playlist, dropped_tracks(const MetaDataList&, int),	554	CONNECT(m_ui_playlist, dropped_tracks(const MetaDataList&, int),
543	m_playlist, psl_insert_tracks(const MetaDataList&, int));	555	m_playlist.get(), psl_insert_tracks(const MetaDataList&, int));
544	CONNECT(m_ui_playlist, sig_rows_removed(const QList<int>&, bool),	556	CONNECT(m_ui_playlist, sig_rows_removed(const QList<int>&, bool),
545	m_playlist, psl_remove_rows(const QList<int>&, bool));	557	m_playlist.get(), psl_remove_rows(const QList<int>&, bool));
546	CONNECT(m_ui_playlist, sig_sort_tno(),	558	CONNECT(m_ui_playlist, sig_sort_tno(),
547	m_playlist, psl_sort_by_tno());	559	m_playlist.get(), psl_sort_by_tno());
548	CONNECT(m_ui_playlist, row_activated(int),	560	CONNECT(m_ui_playlist, row_activated(int),
549	m_playlist, psl_change_track(int));	561	m_playlist.get(), psl_change_track(int));
550	CONNECT(m_ui_playlist, clear_playlist(),	562	CONNECT(m_ui_playlist, clear_playlist(),
551	m_playlist, psl_clear_playlist());	563	m_playlist.get(), psl_clear_playlist());
552		564
553	m_playlist->update_state();	565	m_playlist->update_state();
554	}	566	}
555		567
556	void Application::renderer_connections()	568	void Application::renderer_connections()