File indexing completed on 2025-02-23 04:27:37

 /****************************************************************************************
  * Copyright (c) 2006 Ian Monroe <ian@monroe.nu>                                        *
  * Copyright (c) 2006 Seb Ruiz <ruiz@kde.org>                                           *
  * Copyright (c) 2007 Maximilian Kossick <maximilian.kossick@googlemail.com>            *
  *                                                                                      *
  * This program is free software; you can redistribute it and/or modify it under        *
  * the terms of the GNU General Public License as published by the Free Software        *
  * Foundation; either version 2 of the License, or (at your option) any later           *
  * version.                                                                             *
  *                                                                                      *
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY      *
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A      *
  * PARTICULAR PURPOSE. See the GNU General Public License for more details.             *
  *                                                                                      *
  * You should have received a copy of the GNU General Public License along with         *
  * this program.  If not, see <http://www.gnu.org/licenses/>.                           *
  ****************************************************************************************/
 
 #define DEBUG_PREFIX "DaapCollection"
 
 #include "DaapCollection.h"
 
 #include "amarokconfig.h"
 #include "core/logger/Logger.h"
 #include "core/support/Components.h"
 #include "core/support/Debug.h"
 #include "DaapMeta.h"
 #include "MemoryQueryMaker.h"
 #include "daapreader/Reader.h"
 
 #include <QStringList>
 #include <QTimer>
 
 #include <KLocalizedString>
 
 #include <DNSSD/RemoteService>
 #include <DNSSD/ServiceBase>
 #include <DNSSD/ServiceBrowser>
 
 using namespace Collections;
 
 DaapCollectionFactory::DaapCollectionFactory()
     : Collections::CollectionFactory()
     , m_browser( nullptr )
 {
 }
 
 DaapCollectionFactory::~DaapCollectionFactory()
 {
     delete m_browser;
 }
 
 void
 DaapCollectionFactory::init()
 {
     DEBUG_BLOCK
     switch( KDNSSD::ServiceBrowser::isAvailable() )
     {
     case KDNSSD::ServiceBrowser::Working:
         //don't block Amarok's startup by connecting to DAAP servers
         QTimer::singleShot( 1000, this, &DaapCollectionFactory::connectToManualServers );
         m_browser = new KDNSSD::ServiceBrowser("_daap._tcp");
         m_browser->setObjectName("daapServiceBrowser");
         connect( m_browser, &KDNSSD::ServiceBrowser::serviceAdded,
                  this, &DaapCollectionFactory::foundDaap );
         connect( m_browser, &KDNSSD::ServiceBrowser::serviceRemoved,
                  this, &DaapCollectionFactory::serverOffline );
         m_browser->startBrowse();
         break;
 
     case KDNSSD::ServiceBrowser::Stopped:
         debug() << "The Zeroconf daemon is not running";
         break;
 
     case KDNSSD::ServiceBrowser::Unsupported:
         debug() << "Zeroconf support is not available";
         break;
 
     default:
         debug() << "Unknown error with Zeroconf";
     }
     m_initialized = true;
 }
 
 void
 DaapCollectionFactory::connectToManualServers()
 {
     DEBUG_BLOCK
     QStringList sl = AmarokConfig::manuallyAddedServers();
     foreach( const QString &server, sl )
     {
         debug() << "Adding server " << server;
         QStringList current = server.split( QLatin1Char(':'), Qt::KeepEmptyParts );
         //handle invalid urls gracefully
         if( current.count() < 2 )
             continue;
             
         QString host = current.first();
         quint16 port = current.last().toUShort();
         Amarok::Logger::longMessage(
                     i18n( "Loading remote collection from host %1", host),
                     Amarok::Logger::Information );
 
         int lookup_id = QHostInfo::lookupHost( host, this, &DaapCollectionFactory::resolvedManualServerIp );
         m_lookupHash.insert( lookup_id, port );
     }
 }
 
 void
 DaapCollectionFactory::serverOffline( KDNSSD::RemoteService::Ptr service )
 {
     DEBUG_BLOCK
     QString key =  serverKey( service->hostName(), service->port() );
     if( m_collectionMap.contains( key ) )
     {
         auto coll = m_collectionMap[ key ];
         if( coll )
             coll->serverOffline();  //collection will be deleted by collectionmanager
         else
             warning() << "collection already null";
         
         m_collectionMap.remove( key );
 
     }
     else
         warning() << "removing non-existent service";
 }
 
 void
 DaapCollectionFactory::foundDaap( KDNSSD::RemoteService::Ptr service )
 {
     DEBUG_BLOCK
 
     connect( service.data(), &KDNSSD::RemoteService::resolved, this, &DaapCollectionFactory::resolvedDaap );
     service->resolveAsync();
 }
 
 void
 DaapCollectionFactory::resolvedDaap( bool success )
 {
     const KDNSSD::RemoteService* service =  dynamic_cast<const KDNSSD::RemoteService*>(sender());
     if( !success || !service ) return;
     debug() << service->serviceName() << ' ' << service->hostName() << ' ' << service->domain() << ' ' << service->type();
 
     int lookup_id = QHostInfo::lookupHost( service->hostName(), this, &DaapCollectionFactory::resolvedServiceIp );
     m_lookupHash.insert( lookup_id, service->port() );
 }
 
 QString
 DaapCollectionFactory::serverKey( const QString& host, quint16 port) const
 {
     return host + QLatin1Char(':') + QString::number( port );
 }
 
 void
 DaapCollectionFactory::slotCollectionReady()
 {
     DEBUG_BLOCK
     DaapCollection *collection = dynamic_cast<DaapCollection*>( sender() );
     if( collection )
     {
         disconnect( collection, &DaapCollection::remove, this, &DaapCollectionFactory::slotCollectionDownloadFailed );
         Q_EMIT newCollection( collection );
     }
 }
 
 void
 DaapCollectionFactory::slotCollectionDownloadFailed()
 {
     DEBUG_BLOCK
     DaapCollection *collection = qobject_cast<DaapCollection*>( sender() );
     if( !collection )
         return;
     disconnect( collection, &DaapCollection::collectionReady, this, &DaapCollectionFactory::slotCollectionReady );
     for( const auto &it : m_collectionMap )
     {
         if( it.data() == collection )
         {
             m_collectionMap.remove( m_collectionMap.key( it ) );
             break;
         }
     }
     collection->deleteLater();
 }
 
 void
 DaapCollectionFactory::resolvedManualServerIp( const QHostInfo &hostInfo )
 {
     if ( !m_lookupHash.contains(hostInfo.lookupId()) )
         return;
 
     if ( hostInfo.addresses().isEmpty() )
         return;
 
     QString host = hostInfo.hostName();
     QString ip = hostInfo.addresses().at(0).toString();
     quint16 port = m_lookupHash.value( hostInfo.lookupId() );
 
     //adding manual servers to the collectionMap doesn't make sense
     DaapCollection *coll = new DaapCollection( host, ip, port );
     connect( coll, &DaapCollection::collectionReady, this, &DaapCollectionFactory::slotCollectionReady );
     connect( coll, &DaapCollection::remove, this, &DaapCollectionFactory::slotCollectionDownloadFailed );
 }
 
 void
 DaapCollectionFactory::resolvedServiceIp( const QHostInfo &hostInfo )
 {
     DEBUG_BLOCK
    // debug() << "got address:" << hostInfo.addresses() << "and lookup hash contains id" << hostInfo.lookupId() << "?" << m_lookupHash.contains(hostInfo.lookupId());
     if ( !m_lookupHash.contains(hostInfo.lookupId()) )
         return;
 
     if ( hostInfo.addresses().isEmpty() )
         return;
 
     QString host = hostInfo.hostName();
     QString ip = hostInfo.addresses().at(0).toString();
     quint16 port = m_lookupHash.value( hostInfo.lookupId() );
 
    // debug() << "already added server?" << m_collectionMap.contains(serverKey( host, port ));
     if( m_collectionMap.contains(serverKey( host, port )) ) //same server from multiple interfaces
         return;
 
    // debug() << "creating daap collection with" << host << ip << port;
     QPointer<DaapCollection> coll( new DaapCollection( host, ip, port ) );
     connect( coll, &DaapCollection::collectionReady, this, &DaapCollectionFactory::slotCollectionReady );
     connect( coll, &DaapCollection::remove, this, &DaapCollectionFactory::slotCollectionDownloadFailed );
     m_collectionMap.insert( serverKey( host, port ), coll.data() );
 }
 
 //DaapCollection
 
 DaapCollection::DaapCollection( const QString &host, const QString &ip, quint16 port )
     : Collection()
     , m_host( host )
     , m_port( port )
     , m_ip( ip )
     , m_reader( nullptr )
     , m_mc( new MemoryCollection() )
 {
     debug() << "Host: " << host << " port: " << port;
     m_reader = new Daap::Reader( this, host, port, QString(), this, "DaapReader" );
     connect( m_reader, &Daap::Reader::passwordRequired,this, &DaapCollection::passwordRequired );
     connect( m_reader, &Daap::Reader::httpError, this, &DaapCollection::httpError );
     m_reader->loginRequest();
 }
 
 DaapCollection::~DaapCollection()
 {
 }
 
 QueryMaker*
 DaapCollection::queryMaker()
 {
     return new MemoryQueryMaker( m_mc.toWeakRef(), collectionId() );
 }
 
 QString
 DaapCollection::collectionId() const
 {
     return QString( QStringLiteral("daap://") + m_ip + QLatin1Char(':') ) + QString::number( m_port );
 }
 
 QString
 DaapCollection::prettyName() const
 {
     QString host = m_host;
     // No need to be overly verbose
     if( host.endsWith( ".local" ) )
         host = host.remove( QRegExp(".local$") );
     return i18n("Music share at %1", host);
 }
 
 void
 DaapCollection::passwordRequired()
 {
     //get password
     QString password;
     delete m_reader;
     m_reader = new Daap::Reader( this, m_host, m_port, password, this, "DaapReader" );
     connect( m_reader, &Daap::Reader::passwordRequired, this, &DaapCollection::passwordRequired );
     connect( m_reader, &Daap::Reader::httpError, this, &DaapCollection::httpError );
     m_reader->loginRequest();
 }
 
 void
 DaapCollection::httpError( const QString &error )
 {
     DEBUG_BLOCK
     debug() << "Http error in DaapReader: " << error;
     Q_EMIT remove();
 }
 
 void
 DaapCollection::serverOffline()
 {
     Q_EMIT remove();
 }
 
 void
 DaapCollection::loadedDataFromServer()
 {
     DEBUG_BLOCK
     Q_EMIT collectionReady();
 }
 
 void
 DaapCollection::parsingFailed()
 {
     DEBUG_BLOCK
     Q_EMIT remove();
 }