ServiceDiscovery.hpp

Go to the documentation of this file.

#ifndef _SERVICEDISCOVERY_CORE_H_
#define _SERVICEDISCOVERY_CORE_H_

#include <string>
#include <vector>
#include <boost/thread.hpp>
#include <service_discovery/impl/avahi/Client.hpp>
#include <service_discovery/impl/avahi/ServiceBrowser.hpp>
#include <service_discovery/impl/avahi/ServiceEvent.hpp>
#include <service_discovery/impl/avahi/ServicePattern.hpp>
#include <service_discovery/impl/avahi/LocalService.hpp>

namespace servicediscovery { 
namespace avahi {

enum SDException {
        already_started,
        not_configured
};

class ServiceDiscovery : public sigc::trackable, public ClientObserver
{

public: 
        ServiceDiscovery();

        virtual ~ServiceDiscovery();

        void start(const ServiceConfiguration& conf);

        void listenOn(const std::vector<std::string>& types);

        void update(const ServiceDescription& desc);

        virtual void update(const ClientObserver::Event& event);

        void stop();

        static bool update(const std::string& servicename, const ServiceDescription& description);
        
        static ServiceDescription getServiceDescription(const std::string& servicename);

        static std::vector<ServiceDescription> getUpdateableServices();

        std::vector<ServiceDescription> findServices( const SearchPattern& pattern = SearchPattern()) const;

        std::vector<ServiceDescription> findServices(const ServicePattern& pattern, 
                const std::string& name_space = "*") const;

        std::vector<std::string> getServiceNames();

        bool isRunning() const;


        ServiceConfiguration getConfiguration() const;

        void addedComponentConnect(const sigc::slot<void, ServiceEvent>& slot) {
                boost::unique_lock<boost::mutex> lock(mAddedComponentMutex);
                ServiceAddedSignal.connect(slot);
        }

        void removedComponentConnect(const sigc::slot<void, ServiceEvent>& slot) {
                boost::unique_lock<boost::mutex> lock(mRemovedComponentMutex);
                ServiceRemovedSignal.connect(slot);
        }

        static std::map<std::string, ServiceDescription> getVisibleServices(const SearchPattern& pattern = SearchPattern("")); 

        static void registerCallbacks(const std::string& serviceName, const sigc::slot<void, ServiceEvent>& serviceAdded, const sigc::slot<void, ServiceEvent>& serviceRemoved);

private:

        // The internal modes for the service discovery, reflect the
        // usage as service publisher or listener only, i.e. 
        // to allow search one or more avahi domains, e.g. 
        // _test._tcp or similar
        enum Mode { NONE = 0, LISTEN_ONLY = 1, PUBLISH = 2};

        void addedService(const RemoteService& service);

        void removedService(const RemoteService& service);

        void updatedService(const RemoteService& service);

        std::vector<ServiceDescription> _findServices(const SearchPattern& pattern) const;

        void _start(const ServiceConfiguration& conf);

        void _stop(bool lock_client, bool wait_until_unpublished = true);

        void _listenOn(const std::vector<std::string>& types);

        void reconnect();

        void cleanupBrowsers();

        sigc::signal<void, ServiceEvent> ServiceAddedSignal;
        sigc::signal<void, ServiceEvent> ServiceRemovedSignal;

        mutable boost::mutex mAddedComponentMutex;
        mutable boost::mutex mRemovedComponentMutex;
        mutable boost::mutex mUpdatedComponentMutex;

        List<ServiceDescription> mServices;
        static boost::mutex mServicesMutex;

        // Flag whether service is published or not
        bool mPublished;

        // Seems to allow better thread safety and handling of the dbus if 
        // every browser is started with the same client object
        //
        // Map service type such as _myservice._tcp to a corresponding browser
        std::map<std::string, ServiceBrowser*> mBrowsers;

        // There can be only a single local service
        LocalService* mLocalService;
        // Configuration of the local service 
        ServiceConfiguration mLocalServiceConfiguration;

        // When in listing mode, the list of service types this instance
        // is listening to
        std::vector<std::string> mListenTypes;

        // Mode of the 
        Mode mMode;

        // Global list of service discovery instances
        static std::vector<ServiceDiscovery*> msServiceDiscoveries;

};

} // end namespace avahi
} // end namespace servicediscovery
#endif // _SERVICEDISCOVERY_CORE_H_