gizmod/GizmoDaemon.hpp

Go to the documentation of this file.

/*
  
  Copyright (c) 2007, Tim Burrell
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at 

        http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and 
  limitations under the License. 
  
*/

#ifndef __GizmoDaemon_h
#define __GizmoDaemon_h

#if HAVE_CONFIG_H
#include "config.h"
#endif

#include "GizmodEventHandlerInterface.hpp"
#include "GizmoUtils.hpp"
#include "../libGizmod/Alsa.hpp"
#include "../libGizmod/CPUUsage.hpp"
#include "../libGizmod/Gizmo.hpp"
#include "../libGizmod/GizmoClient.hpp"
#include "../libGizmod/GizmodShared.hpp"
#include "../libGizmod/Processes.hpp"
#include "../libGizmod/X11FocusWatcher.hpp"
#include "../libH/FileEventWatcher.hpp"
#include "../libH/SignalHandler.hpp"
#include "../libH/SocketServer.hpp"
#include <ext/hash_map>
#include <map>
#include <string>
#include <boost/python.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>

using namespace Gizmod;

// Typedef's Enums

// Class Definition

class GizmoDaemon : 
        public GizmodShared,
        public H::FileEventWatcher, 
        private H::SignalHandler, 
        public X11FocusWatcher,
        public Alsa,
        public Processes,
        public CPUUsage,
        public SocketServer,
        public GizmoClient,
        public GizmoUtils
{
public:
        // public functions
        bool                            checkVersion(double Version, bool Strict); 
        void                            enterLoop();                    
        X11FocusEvent                   getCurrentFocus();              
        bool                            getDebugEnabled();              
        GizmodEventHandlerInterface *   getDispatcher();                
        boost::shared_ptr<Gizmo>        getGizmoByFileName(std::string FileName); 
        int                             getNumGizmosByClass(GizmoClass Class); 
        bool                            getReloadConfig();              
        bool                            getUseKeyboardLEDs();           
        bool                            getUseRemoteControl();          
        double                          getVersion();                   
        void                            initGizmod();                   
        bool                            initialize(int argc, char ** argv); 
        void                            printNiceScriptInit(int Width, std::string Text1, std::string Text2, std::string Text3); 
        void                            signalShutdown();               
                
        // construction / deconstruction
        GizmoDaemon();                                                  
        virtual ~GizmoDaemon();                                         

private:
        // private functions
        void                            deleteGizmo(std::string FileName); 
        void                            deserializeMessage(GizmoEventClass EventClass, std::string const & Message); 
        void                            deserializeMessageATIX10(std::string const & Message); 
        void                            deserializeMessageCPUUsage(std::string const & Message); 
        void                            deserializeMessageLIRC(std::string const & Message); 
        void                            deserializeMessagePowermate(std::string const & Message); 
        void                            deserializeMessageSoundcard(std::string const & Message); 
        void                            deserializeMessageSoundVisualization(std::string const & Message); 
        void                            deserializeMessageStandard(std::string const & Message); 
        void                            deserializeMessageWindowFocus(std::string const & Message); 
        int                             getGizmoClassID(GizmoClass Class); 
        std::string                     getProps();                     
        std::string                     getUserScriptDirPaths();        
        void                            handleFileEventReadATIX10(GizmoATIX10 & pGizmo, DynamicBuffer<char> const & ReadBuffer); 
        void                            handleFileEventReadLIRC(GizmoLIRC & pGizmo, DynamicBuffer<char> const & ReadBuffer); 
        void                            handleFileEventReadPowermate(GizmoPowermate & pGizmo, DynamicBuffer<char> const & ReadBuffer); 
        void                            handleFileEventReadStandard(GizmoStandard & pGizmo, DynamicBuffer<char> const & ReadBuffer); 
        void                            initPython();                   
        void                            loadUserScripts();              
        void                            loadUserScriptsFunctor(std::string UserScript); 
        virtual void                    onAlsaEventMixerElementAttach(AlsaEvent const & Event, AlsaSoundCard const & SoundCard, AlsaMixer const & Mixer); 
        virtual void                    onAlsaEventMixerElementChange(AlsaEvent const & Event, AlsaSoundCard const & SoundCard, AlsaMixer const & Mixer); 
        virtual void                    onAlsaEventMixerElementDetach(AlsaEvent const & Event, AlsaSoundCard const & SoundCard, AlsaMixer const & Mixer); 
        virtual void                    onAlsaEventSoundCardAttach(AlsaEvent const & Event, AlsaSoundCard const & SoundCard); 
        virtual void                    onAlsaEventSoundCardDetach(AlsaEvent const & Event, AlsaSoundCard const & SoundCard); 
        virtual void                    onCPUUsage(std::vector< boost::shared_ptr<CPUUsageInfo> > const & Event); 
        virtual void                    onFileEventCreate(boost::shared_ptr<H::FileWatchee> pWatchee, std::string FullPath, std::string FileName); 
        virtual void                    onFileEventDelete(boost::shared_ptr<H::FileWatchee> pWatchee, std::string FullPath, std::string FileName); 
        virtual void                    onFileEventDisconnect(boost::shared_ptr<H::FileWatchee> pWatchee); 
        virtual void                    onFileEventRead(boost::shared_ptr<H::FileWatchee> pWatchee, DynamicBuffer<char> const & ReadBuffer); 
        virtual void                    onFileEventRegister(boost::shared_ptr<H::FileWatchee> pWatchee); 
        virtual void                    onFileEventWatchBegin();        
        virtual void                    onFileEventWatchEnd();          
        virtual void                    onFocusIn(X11FocusEvent const & Event); 
        virtual void                    onFocusOut(X11FocusEvent const & Event); 
        virtual void                    onSignalSegv();                 
        virtual void                    onSignalInt();                  
        virtual void                    onSignalHup();                  
        virtual void                    onSignalQuit();                 
        virtual void                    onSignalKill();                 
        virtual void                    onSignalTerm();                 
        virtual void                    onSignalStop();                 
        virtual void                    onSignalUnknown(int Signal); 
        virtual void                    onSocketClientConnect(Socket const & socket); 
        virtual void                    onSocketClientDisconnect(Socket const & socket); 
        virtual void                    onSocketClientMessage(Socket const & socket, std::string const & Message); 
        virtual void                    onSocketClientRead(Socket const & socket, DynamicBuffer<char> & ReadBuffer); 
        virtual void                    onSocketServerConnect(boost::shared_ptr<Socket> pSocket); 
        virtual void                    onSocketServerDisconnect(Socket const & socket); 
        virtual void                    onSocketServerMessage(Socket const & socket, std::string const & Message); 
        virtual void                    onSocketServerRead(Socket const & socket, DynamicBuffer<char> & ReadBuffer); 
        void                            registerDevices();              
        void                            registerInputEventDevices();    
        void                            registerLircDevice();           
        void                            setConfigDir();                 
        void                            setVersionInfo();               
        
        // private member vars
        std::string                     mClientHost;                    
        int                             mClientPort;                    
        std::string                     mConfigDir;                     
        X11FocusEvent                   mCurrentFocus;                  
        bool                            mDisabledALSA;                  
        bool                            mDisabledCPUUsage;              
        bool                            mDisabledX11;                   
        bool                            mDisableShutdownMessage;        
        std::string                     mEventsDir;                     
        std::map< std::string, boost::shared_ptr<Gizmo> > mGizmos;      
        bool                            mInitialized;                   
        std::string                     mLircDev;                       
        bool                            mLocalDisabled;                 
        GizmodEventHandlerInterface *   mpPyDispatcher;                 
        boost::python::object           mPyMainModule;                  
        boost::python::object           mPyMainNamespace;               
        bool                            mReloadConfig;                  
        bool                            mServerEnabled;                 
        int                             mServerPort;                    
        bool                            mShuttingDown;                  
        bool                            mUseKeyboardLEDs;               
        bool                            mUseRemoteControl;              
        double                          mVersion;                       
        int                             mVersionMajor;                  
        int                             mVersionMinor;                  
};

#endif // __GizmoDaemon_h

---