ServiceBrowser.hpp

Go to the documentation of this file.

#ifndef _SERVICE_DISCOVERY_SERVICEBROWSER_H_
#define _SERVICE_DISCOVERY_SERVICEBROWSER_H_

namespace servicediscovery {
namespace avahi {

struct ResolveData;
class ServiceBrowser;

}}

#include <iostream>
#include <map>
#include <list>
#include <string>
#include <boost/thread.hpp>
#include <sigc++/sigc++.h>
#include <avahi-client/client.h>
#include <service_discovery/impl/avahi/RemoteService.hpp>
#include <service_discovery/impl/avahi/Client.hpp>
#include <service_discovery/utils/List.hpp>
#include <service_discovery/impl/avahi/Service.hpp>

namespace servicediscovery {
namespace avahi {

struct ResolveData {
        ServiceBrowser* serviceBrowser;
        int count;
};


class ServiceBrowser {
private:
        Client* client;
        std::string type;
        AvahiIfIndex interface;
        AvahiProtocol protocol;
        std::string domain;
        AvahiLookupFlags flags;
        
        void *data;

        AvahiServiceBrowser *browser;

        void bootstrap();

        List<RemoteService> services;

        boost::mutex mServicesMutex;

        const char* getInType() {
                return type.c_str();
        }

        const char* getInDomain() {
                if (domain == "") {
                        return NULL; //if empty string then the default value NULL (.local) domain is used
                } else {
                        return domain.c_str();
                }
        }


        sigc::signal<void, RemoteService> ServiceAdded;

        sigc::signal<void, RemoteService> ServiceRemoved;

        sigc::signal<void, RemoteService> ServiceUpdated;

        boost::mutex mServiceAddedMutex;
        boost::mutex mServiceRemovedMutex;
        boost::mutex mServiceUpdateMutex;

public:

        const int static MAX_RESOLVER_TRIES = 5;
        
        ServiceBrowser(
                        Client *client,
                        std::string type);
        ServiceBrowser(
                        Client* client,
                        AvahiIfIndex interface, // In most cases pass AVAHI_IF_UNSPEC here 
                        AvahiProtocol protocol, // In most cases pass AVAHI_PROTO_UNSPEC here
                        std::string type,  // A service type such as "_http._tcp" 
                        std::string domain, // A domain to browse in. In most cases you want to pass NULL here for the default domain (usually ".local")
                        AvahiLookupFlags flags,
                        void* data);

        virtual ~ServiceBrowser();

        void cleanup();

//      sigc::signal<void,
//              ServiceBrowser*,
//          AvahiBrowserEvent,
//              RemoteService*,
//              void*> ServiceBrowserSignal;


        void serviceAddedConnect(const sigc::slot<void, RemoteService>& slot_) {
                boost::unique_lock<boost::mutex> lock(mServiceAddedMutex);
                ServiceAdded.connect(slot_);
        }

        void serviceAddedEmit(RemoteService rms) {
                boost::unique_lock<boost::mutex> lock(mServiceAddedMutex);
                ServiceAdded.emit(rms);
        }


        void serviceRemovedConnect(const sigc::slot<void, RemoteService>& slot_) {
                boost::unique_lock<boost::mutex> lock(mServiceRemovedMutex);
                ServiceRemoved.connect(slot_);
        }

        void serviceRemovedEmit(RemoteService rms) {
                boost::unique_lock<boost::mutex> lock(mServiceRemovedMutex);
                ServiceRemoved.emit(rms);
        }

        void serviceUpdatedConnect(const sigc::slot<void, RemoteService>& slot_) {
                boost::unique_lock<boost::mutex> lock(mServiceUpdateMutex);
                ServiceUpdated.connect(slot_);
        }

        void serviceUpdatedEmit(RemoteService rms) {
                boost::unique_lock<boost::mutex> lock(mServiceUpdateMutex);
                ServiceUpdated.emit(rms);
        }

    List<RemoteService> getServices()
    {
        boost::unique_lock<boost::mutex> lock(mServicesMutex);
        List<RemoteService> tlist = services;
        return tlist;
    }
    
    //to be used only by the static callbacks. TODO: how to avoid this to be public
    List<RemoteService> *getInternalServices()
    {
        return &services;
    }
    //to be used only by the static callbacks. TODO: how to avoid this to be public
    boost::mutex& getServicesMutex()
    {
        return mServicesMutex;
    }

    

    AvahiServiceBrowser* getAvahiBrowser()
    {
        return browser;
    }

    Client* getClient()
    {
        return client;
    }


    static void browseCallback(AvahiServiceBrowser *sb, AvahiIfIndex interface, AvahiProtocol protocol,
                                  AvahiBrowserEvent event, const char *name, const char *type, const char *domain,
                                  AvahiLookupResultFlags flags, void *userdata);

    static void resolveCallback(AvahiServiceResolver *sr, AvahiIfIndex interface, AvahiProtocol protocol,
                            AvahiResolverEvent event, const char *name, const char *type, const char *domain, const char *host,
                            const AvahiAddress *address, uint16_t port, AvahiStringList *list, AvahiLookupResultFlags flags, void *userdata);

};

} // end namespace avahi
} // end namespace servicediscovery
#endif /* _SERVICE_DISCOVERYSERVICEBROWSER_H_ */