TnbCePowerWatcher.h

[詳解]

#pragma once
#ifndef _WIN32_WCE
    #error TnbCePowerWatcher.h is only supported on Windows CE platforms.
#endif // _WIN32_WCE
 
 
 
#include "TnbCeMsgQueueWatcher.h"
#include <pm.h>
 
 
 
//TNB Library
namespace TNB{
 
 
 
class CPowerWatcher
{
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual void OnPowerTransitionEvent(DWORD flag, LPCTSTR lpszState) {}
 
        virtual void OnPowerResumeEvent(void) {}
 
        virtual void OnPowerStatusChange(void) {}
 
        virtual void OnPowerInfoChange(const POWER_BROADCAST_POWER_INFO& info) {}
    };
 
 
    //---------------------------
 
 
    CPowerWatcher(void) : m_handle(NULL)
    {
        m_inner.pListener = NULL;
    }
 
    ~CPowerWatcher(void)
    {
        Stop();
    }
 
    HANDLE GetSafeHandle(void) const
    {
        return m_handle;
    }
 
    void SetListener(IListener* P)
    {
        m_inner.pListener = P;
    }
 
    bool IsStarted(void) const
    {
        return m_handle != NULL;
    }
 
    bool Start(DWORD flag = POWER_NOTIFY_ALL)
    {
        Stop();
        m_msgQueue.SetListener(&m_inner);
        if ( m_msgQueue.Start(3, true, _T("PowerWatch")) )
        {
            m_handle = ::RequestPowerNotifications(m_msgQueue, flag);
        }
        if ( m_handle != NULL )
        {
            return true;
        }
        DWORD r = ::GetLastError();
        Stop();
        ::SetLastError(r);
        return false;
    }
 
    void Stop(void)
    {
        if ( m_handle != NULL )
        {
            ::StopPowerNotifications(m_handle);
            m_handle = NULL;
        }
        m_msgQueue.Stop();
    }
 
private:
    struct TMyPowerBroadcast
    {
        DWORD   Message;    
        DWORD   Flags;      
        DWORD   Length;     
        union
        {
            POWER_BROADCAST_POWER_INFO  powerInfo;  
            TCHAR                       state[260]; 
        };
    };
    class CInner : public CMsgQueueWatcherT<TMyPowerBroadcast>::IListener
    {
    public:
        virtual void OnMsgQueueWatcherEvent(const TMyPowerBroadcast& data, size_t length, bool isAlert)
        {
            if ( pListener != NULL )
            {
                switch ( data.Message )
                {
                case PBT_POWERINFOCHANGE:
                    ASSERT( data.Length == sizeof(POWER_BROADCAST_POWER_INFO) );
                    pListener->OnPowerInfoChange(data.powerInfo);
                    break;
                case PBT_POWERSTATUSCHANGE:
                    pListener->OnPowerStatusChange();
                    break;
                case PBT_RESUME:
                    pListener->OnPowerResumeEvent();
                    break;
                case PBT_TRANSITION:
                    pListener->OnPowerTransitionEvent(data.Flags, data.state);
                    break;
                }
            }
        }
        CPowerWatcher::IListener* pListener;    
    };
    CInner                                  m_inner;        
    HANDLE                                  m_handle;       
    CMsgQueueWatcherT<TMyPowerBroadcast>    m_msgQueue;     
};
 
 
 
}; // TNB