WinCE实时获取电源状态变化

 //========================================================================
//TITLE:
//    WinCE实时获取电源状态变化
//AUTHOR:
//    norains
//DATE:
//    Friday  20-July-2007
//Environment:
//        EVC4.0 + Windows CE 5.0 Standard SDK
//========================================================================

    使用CTpowerThread很简单实现实时获取电源的状态.在该类的内部创建了一个获取电量的线程,只要设置好回调函数,就可以自动接收设定间隔的电源状态.
    
    现在我们来看看该类的具体操作方法:
    
    //获取类的实例
    CPowerThread *pPowThrd = CPowerThread::GetInstance();
    if(pPowThrd != NULL)
    {
       //设置回调函数
       pPowThrd->SetCallbackFunction(NotifyPowerStatus);
       //启动线程,开始捕抓电量
       pPowThrd->StartCapture();
    }
    
    这段代码中最重要的是设置回调函数,该函数的声明如下:
    void NotifyPowerStatus(PowerStatusType powStatus, int iBatteryPercent)
    
    powStatus是电源的简易状态,分为七个部分,取值为其中之一:
    POW_UNKNOW,        //Unknow the status
    POW_CHARGING,    //It's charging now
    POW_CHARGEFULL,    //Full charge
    POW_VLOW,        //The battery level is very low
    POW_LOW,
    POW_NORMAL,
    POW_HIGH,
    
    iBatteryPercent为当前电源的百分比,取值为:0~1.
    
    下面给出一个回调函数的样例代码:
    void NotifyPowerStatus(PowerStatusType powStatus, int iBatteryPercent)
    {
        switch(powStatus)
        {
          case POW_UNKNOW:
            //当前状态不明
            break;
           case POW_CHARGING:
            //充电中
            break;
           case POW_VLOW:
            //电池电量非常低
            break;
            
            ...
        }
    }
    
    再来看看该类的其它接口函数:
    
    SetWaitTime(ULONG ulTime)
    该函数设置线程的超时时间.如果设置为INFINITE,则只有当电源状态有变化时才会调用回调函数.

    GetCallbackFunction(void (* *pCallbackFunc)(PowerStatusType powStatus, int iBatteryPercent))
    获取已设置的回调函数的指针

        StopCapture()
        停止线程.如果超时时间设为为INFINITE,则只有获取下次电源状态后才退出.
        
        GetRunStatus()
        获取当前线程的运行状态.
        
        
        以下为该CPowerthread的完整源码:
        源代码的具体原理可参考此篇文章:<EVC获取电源属性>http://blog.csdn.net/norains/archive/2006/09/07/1189157.aspx


//////////////////////////////////////////////////////////////////////
// PowerThread.h: interface for the CPowerThread class.
//
//Version:
//    1.0.1
//Date:
//    2007.07.20
//////////////////////////////////////////////////////////////////////

#ifndef POWERTHREAD_H
#define POWERTHREAD_H



#include "Pm.h"



//-----------------------------------------------------------------
//Enum data type
enum PowerStatusType
{
    POW_UNKNOW,        //Unknow the status
    POW_CHARGING,    //It's charging now
    POW_CHARGEFULL,    //Full charge
    POW_VLOW,        //The battery level is very low
    POW_LOW,
    POW_NORMAL,
    POW_HIGH,
    POW_VHIGH        //The battery level is very high
};
//----------------------------------------------------------------

class CPowerThread  
{
public:
    void GetCallbackFunction(void (* *pCallbackFunc)(PowerStatusType powStatus, int iBatteryPercent));
    void SetCallbackFunction(void (*pCallbackFunc)(PowerStatusType powStatus, int iBatteryPercent));
    void StopCapture();
    BOOL StartCapture();
    BOOL GetRunStatus();
    void SetTimeout(ULONG ulTime);
    static CPowerThread * GetInstance();
    virtual ~CPowerThread();
protected:
    CPowerThread();
    PowerStatusType GetPowerStatus(PPOWER_BROADCAST pPowerInfo, int *piPercent);
    static DWORD WINAPI PowerThread(PVOID pArg);

    static CPowerThread *m_pInstance;
    BOOL m_bExitThread;
    ULONG m_ulWaitTime;
    BOOL m_bRunning;
    CRITICAL_SECTION m_csLock;



    //The critical section function
    inline void    InitLock()    { InitializeCriticalSection(&m_csLock); }
    inline void LockThis()    { EnterCriticalSection(&m_csLock);      }    
    inline void    UnLockThis()  { LeaveCriticalSection(&m_csLock);      }
    inline void    DelLock()     { DeleteCriticalSection(&m_csLock);     }

    //This is for callback function.
    void (*m_pNotifyPower)(PowerStatusType powStatus, int iBatteryPercent);
};

#endif //#ifndef POWERTHREAD_H







//////////////////////////////////////////////////////////////////////
// PowerThread.cpp: implementation of the CPowerThread class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "PowerThread.h"
#include "Msgqueue.h"


//--------------------------------------------------------------------
//Macro define
#define DEFAULT_TIMEOUT        1000ms //1000ms

//---------------------------------------------------------------------
//Initialize
CPowerThread *CPowerThread::m_pInstance = NULL;


//----------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CPowerThread::CPowerThread():
m_bExitThread(TRUE),
m_ulWaitTime(DEFAULT_TIMEOUT),
m_bRunning(FALSE),
m_pNotifyPower(NULL)
{
    InitLock();
}

CPowerThread::~CPowerThread()
{
    if(m_pInstance != NULL)
    {
        delete m_pInstance;
        m_pInstance = NULL;
    }

    DelLock();
}



//------------------------------------------------------------------
//Description:
//    Get the level of power from the PPOWER_BROADCAST struct
//
//Parameters:
//    pPowerInfo:[in] The struct includes the power information
//    piPercent:[out] The battery life percent.
//
//Return Values:
//    The power status
//----------------------------------------------------------------
PowerStatusType CPowerThread::GetPowerStatus(PPOWER_BROADCAST pPowerInfo, int *piPercent)
{
    PowerStatusType powStatus = POW_UNKNOW;

    if ( !pPowerInfo )
    {
        return POW_UNKNOW;
    }
    
    PPOWER_BROADCAST_POWER_INFO ppbpi = (PPOWER_BROADCAST_POWER_INFO) pPowerInfo->SystemPowerState;
    if ( !ppbpi )
    {
        return POW_UNKNOW;
    }
    
    *piPercent = ppbpi->bBatteryLifePercent;
    
    if(ppbpi->bACLineStatus == AC_LINE_ONLINE)
    {        
        if(ppbpi->bBatteryFlag == BATTERY_FLAG_CHARGING)
        {
            //Charging
            powStatus = POW_CHARGING;
        }
        else
        {
            //May be full charging,or may be no battery
            powStatus = POW_CHARGEFULL;
        }
    }
    else
    {
        //Use battery
    
        if(0 <= ppbpi->bBatteryLifePercent && ppbpi->bBatteryLifePercent <= 20)
        {
            powStatus = POW_VLOW;
        }
        else if(20 < ppbpi->bBatteryLifePercent && ppbpi->bBatteryLifePercent <= 40)
        {
            powStatus = POW_LOW;
        }
        else if(40 < ppbpi->bBatteryLifePercent && ppbpi->bBatteryLifePercent <=60)
        {
            powStatus = POW_NORMAL;
        }
        else if(60 < ppbpi->bBatteryLifePercent && ppbpi->bBatteryLifePercent <=80)
        {
            powStatus = POW_HIGH;
        }
        else if(80 < ppbpi->bBatteryLifePercent && ppbpi->bBatteryLifePercent <= 100)
        {
            powStatus = POW_VHIGH;
        }
        else
        {
            powStatus = POW_UNKNOW;
        }
    }

    return powStatus;
}




//------------------------------------------------------------------
//Description:
//    Thread to get the power status
//----------------------------------------------------------------
DWORD WINAPI CPowerThread::PowerThread(PVOID pArg)
{

    m_pInstance->m_bRunning = TRUE;

    BYTE pbMsgBuf[sizeof(POWER_BROADCAST) + sizeof(POWER_BROADCAST_POWER_INFO)];
    PPOWER_BROADCAST ppb = (PPOWER_BROADCAST) pbMsgBuf;
    MSGQUEUEOPTIONS msgopts;
    
    // Create our message queue
    memset(&msgopts, 0, sizeof(msgopts));
    msgopts.dwSize = sizeof(msgopts);
    msgopts.dwFlags = 0;
    msgopts.dwMaxMessages = 0;
    msgopts.cbMaxMessage = sizeof(pbMsgBuf);
    msgopts.bReadAccess = TRUE;
    
    HANDLE rghWaits[1] = { NULL };
    rghWaits[0] = CreateMsgQueue(NULL, &msgopts);
    if (!rghWaits[0])
    {
        //erro
        return 0x10;
    
    }
    
    HANDLE hReq = NULL;
    // Request notifications
    hReq = RequestPowerNotifications(rghWaits[0], PBT_POWERINFOCHANGE);
    if (!hReq)
    {
        CloseHandle( rghWaits[ 0 ] );
        //erro
        return 0x15;

    }      
    


    while(m_pInstance->m_bExitThread == FALSE)
    {
        

        DWORD dwWaitCode = MsgWaitForMultipleObjectsEx( 1, rghWaits, m_pInstance->m_ulWaitTime, QS_ALLINPUT, MWMO_INPUTAVAILABLE );
        if ( dwWaitCode == WAIT_OBJECT_0 )
        {              
            DWORD dwSize, dwFlags;
            BOOL bReadResult = ReadMsgQueue(rghWaits[0], ppb, sizeof(pbMsgBuf), &dwSize, 0, &dwFlags);
            if (bReadResult == TRUE)
            {
                int iPowPercent;
                PowerStatusType powStatus = m_pInstance->GetPowerStatus(ppb,&iPowPercent);

                m_pInstance->LockThis();
                if(m_pInstance->m_pNotifyPower != NULL)
                {
                    m_pInstance->m_pNotifyPower(powStatus,iPowPercent);
                }
                m_pInstance->UnLockThis();

            }
            else
            {
                // We should never get here
                break;                
            }
        }


    }
    m_pInstance->m_bRunning = FALSE;
    
    return 0;
}


//------------------------------------------------------------------
//Description:
//    Get instance
//----------------------------------------------------------------
CPowerThread * CPowerThread::GetInstance()
{
    if(m_pInstance == NULL)
    {
        m_pInstance = new CPowerThread();
    }

    return m_pInstance;
}


//------------------------------------------------------------------
//Description:
//    Set the timeout for the wait thread.  It is only for the MsgWaitForMultipleObjectsEx()
//The default value is DEFAULT_TIMEOUT
//----------------------------------------------------------------
void CPowerThread::SetTimeout(ULONG ulTime)
{
    m_ulWaitTime = ulTime;
}


//------------------------------------------------------------------
//Description:
//    Get the status of thread
//
//Return Values:
//    TRUE: The thread is running for capturing the power status.
//    FALSE: No thread running.
//----------------------------------------------------------------
BOOL CPowerThread::GetRunStatus()
{
    return m_bRunning;
}


//------------------------------------------------------------------
//Description:
//    start capturing the power status.If there is thread running,
//it will return FALSE;
//
//------------------------------------------------------------------
BOOL CPowerThread::StartCapture()
{
    if(m_bRunning == TRUE)
    {
        return FALSE;
    }

    m_bExitThread = FALSE;

    //Create the thread for batter sampled    
    DWORD dwPwrThdID;
    HANDLE hdThrd = CreateThread(NULL,0,PowerThread,NULL,0,&dwPwrThdID);
    if(hdThrd == NULL)
    {
        return FALSE;
    }
    CloseHandle(hdThrd);

    return TRUE;
}



//-----------------------------------------------------------------------------
//Description:
//    Stop capturing.
//
//--------------------------------------------------------------------------------
void CPowerThread::StopCapture()
{
    m_bExitThread = TRUE;
}


//------------------------------------------------------------------
//Description:
//    Set the callback function for receive the power status
//------------------------------------------------------------------
void CPowerThread::SetCallbackFunction(void (*pCallbackFunc)(PowerStatusType powStatus, int iBatteryPercent))
{
    LockThis();
    m_pNotifyPower = pCallbackFunc;
    UnLockThis();
}



//------------------------------------------------------------------
//Description:
//    Get the callback function
//------------------------------------------------------------------
void CPowerThread::GetCallbackFunction(void (* *pCallbackFunc)(PowerStatusType powStatus, int iBatteryPercent))
{
    LockThis();
    *pCallbackFunc = m_pNotifyPower;
    UnLockThis();
}