pwstates.cpp

LX 800 WindowsCE 6.0 BSP

        // get timeout thresholds for transitions between states
        StringCchPrintf(szPath, MAX_PATH, _T("%s\\%s"), PWRMGR_REG_KEY, _T("Timeouts"));
        dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szPath, 0, 0, &hk);
        if(dwStatus == ERROR_SUCCESS) {
            // read system power state timeouts
            m_dwACSuspendTimeout = RegReadStateTimeout(hk, _T("ACSuspend"), DEF_TIMEOUTTOSUSPEND);
            m_dwACTimeoutToSystemIdle = RegReadStateTimeout(hk, _T("ACSystemIdle"), DEF_TIMEOUTTOSYSTEMIDLE);
            m_dwACUserIdleTimeout = RegReadStateTimeout(hk, _T("ACUserIdle"), DEF_TIMEOUTTOUSERIDLE);
             
            m_dwBattSuspendTimeout = RegReadStateTimeout(hk, _T("BattSuspend"), DEF_TIMEOUTTOUSERIDLE);
            m_dwBattTimeoutToSystemIdle = RegReadStateTimeout(hk, _T("BattSystemIdle"), DEF_TIMEOUTTOSYSTEMIDLE);
            m_dwBattUserIdleTimeout = RegReadStateTimeout(hk, _T("BattUserIdle"), DEF_TIMEOUTTOSUSPEND);
             
            // release resources
            RegCloseKey(hk);
        }
        // Update Legacy if we find them.
        PMLOGMSG(ZONE_INIT || ZONE_PLATFORM, 
            (_T("%s: ACSuspendTimeout %d, ACTimeoutToSystemIdle %d, ACUserIdleTimeout %d \r\n"), pszFname, m_dwACSuspendTimeout, m_dwACTimeoutToSystemIdle, m_dwACUserIdleTimeout));
        PMLOGMSG(ZONE_INIT || ZONE_PLATFORM, 
            (_T("%s: BattSuspendTimeout %d,BattTimeoutToSystemIdle %d, BattUserIdleTimeout%d \r\n"  ),pszFname, m_dwBattSuspendTimeout,m_dwBattTimeoutToSystemIdle, m_dwBattUserIdleTimeout));
    }
    
    virtual BOOL    CreatePowerStateList(); // Implement this at last.
    // Timeout Function.
    DWORD GetSuspendTimeOut () {
        return (gSystemPowerStatus.bACLineStatus == AC_LINE_OFFLINE? m_dwBattSuspendTimeout: m_dwACSuspendTimeout);
    }
    DWORD GetSystemIdleTimeOut() {
        return (gSystemPowerStatus.bACLineStatus == AC_LINE_OFFLINE? m_dwBattTimeoutToSystemIdle: m_dwACTimeoutToSystemIdle);
    }
    DWORD GetUserIdleTimeOut() {
        return (gSystemPowerStatus.bACLineStatus == AC_LINE_OFFLINE? m_dwBattUserIdleTimeout: m_dwACUserIdleTimeout);
    }
protected:
    
    // TimeOut Parameter.
    DWORD m_dwACSuspendTimeout;
    DWORD m_dwACTimeoutToSystemIdle ;
    DWORD m_dwACUserIdleTimeout;
    
    DWORD m_dwBattSuspendTimeout ;
    DWORD m_dwBattTimeoutToSystemIdle ;
    DWORD m_dwBattUserIdleTimeout;
        
    DWORD m_dwCurSuspendTimeout;
    DWORD m_dwCurTimeoutToSystemIdle ;
    DWORD m_dwCurUserIdleTimeout;

    BOOL  m_fActiveManagement;

};


class PowerStateOn : public PowerState {
public:
    PowerStateOn(PowerStateManager *pPwrStateMgr, PowerState * pNextPowerState = NULL )      
    :   PowerState(pPwrStateMgr,pNextPowerState)
    {;  };
    virtual void EnterState() {
        PowerState::EnterState();
        ((PowerStateManager *)m_pPwrStateMgr)->ReInitTimeOuts( );
    }

    // This state does not need Resume Time out.
    virtual PLATFORM_ACTIVITY_EVENT  WaitForEvent(DWORD dwTimeouts = INFINITE , DWORD dwNumOfExternEvent = 0, HANDLE * pExternEventArray = NULL) {
        TIMEOUT_ITEM TimeoutItem;
        ((PowerStateManager *) m_pPwrStateMgr)->DisableSuspendTimeout();
        ((PowerStateManager *) m_pPwrStateMgr)->DisableSystemIdleTimeout();
        DWORD dwTimeout =((PowerStateManager *) m_pPwrStateMgr)->GetSmallestTimeout(&TimeoutItem);
        PLATFORM_ACTIVITY_EVENT activeEvent = PowerState::WaitForEvent(dwTimeout ,dwNumOfExternEvent, pExternEventArray) ;
        switch (activeEvent) {
            case Timeout: {
                switch (TimeoutItem) {
                    case UserActivityTimeout:
                        m_LastNewState = UserIdle;
                        break;
                    default:
                        ASSERT(FALSE);
                        break;
                }
                break;
            }
        }
        return activeEvent;
    }
    virtual DWORD  GetState() { return (DWORD)On; };
    virtual LPCTSTR GetStateString() { return STRING_ON ; };
    virtual DWORD StateValidateRegistry(DWORD  , DWORD  ) {
        return PowerState::StateValidateRegistry(0, POWER_STATE_ON|POWER_STATE_PASSWORD);
    }
    virtual BOOL AppsCanRequestState() { return TRUE; }
    
};

class PowerStateUserIdle : public PowerState {
public:
    PowerStateUserIdle(PowerStateManager *pPwrStateMgr, PowerState * pNextPowerState = NULL )     
    :   PowerState(pPwrStateMgr,pNextPowerState)
    {;  };
    virtual void EnterState() {
        PowerState::EnterState();
        ((PowerStateManager *)m_pPwrStateMgr)->ReInitTimeOuts( );
    }
    // This state does not need Resume Time out.
    virtual PLATFORM_ACTIVITY_EVENT  WaitForEvent(DWORD dwTimeouts = INFINITE , DWORD dwNumOfExternEvent = 0, HANDLE * pExternEventArray = NULL) {
        TIMEOUT_ITEM TimeoutItem;
        ((PowerStateManager *)m_pPwrStateMgr)->DisableUserIdleTimeout();
        ((PowerStateManager *) m_pPwrStateMgr)->DisableSuspendTimeout();
        DWORD dwTimeout = ((PowerStateManager *)m_pPwrStateMgr)->GetSmallestTimeout(&TimeoutItem);
        PLATFORM_ACTIVITY_EVENT activeEvent = PowerState::WaitForEvent(dwTimeout ,dwNumOfExternEvent, pExternEventArray) ;
        switch (activeEvent) {
            case UserActivity: 
                m_LastNewState = On;
                break;
            case Timeout: {
                switch (TimeoutItem) {
                    case SystemActivityTimeout:
                        m_LastNewState = SystemIdle;
                        break;
                    default:
                        ASSERT(FALSE);
                        break;
                }
                break;
            }
        }
        return activeEvent;
    }
    virtual DWORD  GetState() { return (DWORD)UserIdle; };
    virtual LPCTSTR GetStateString() { return STRING_USERIDLE; };
    virtual DWORD StateValidateRegistry(DWORD dwDState , DWORD dwFlag ) {
        return PowerState::StateValidateRegistry(1, POWER_STATE_PASSWORD|POWER_STATE_USERIDLE );
    }
    virtual BOOL AppsCanRequestState() { return TRUE; }
    
};

class PowerStateSystemIdle : public PowerState {
public:
    PowerStateSystemIdle(PowerStateManager *pPwrStateMgr, PowerState * pNextPowerState = NULL )     
    :   PowerState(pPwrStateMgr,pNextPowerState)
    {;  };
    virtual void EnterState() {
        PowerState::EnterState();
        ((PowerStateManager *)m_pPwrStateMgr)->ReInitTimeOuts( );
    }
    // This state does not need Resume Time out.
    virtual PLATFORM_ACTIVITY_EVENT  WaitForEvent(DWORD dwTimeouts = INFINITE , DWORD dwNumOfExternEvent = 0, HANDLE * pExternEventArray = NULL) {
        TIMEOUT_ITEM TimeoutItem;
        ((PowerStateManager *)m_pPwrStateMgr)->DisableUserIdleTimeout();
        ((PowerStateManager *)m_pPwrStateMgr)->DisableSystemIdleTimeout();
        DWORD dwTimeout = ((PowerStateManager *)m_pPwrStateMgr)->GetSmallestTimeout(&TimeoutItem);
        PLATFORM_ACTIVITY_EVENT activeEvent = PowerState::WaitForEvent(dwTimeout ,dwNumOfExternEvent, pExternEventArray) ;
        switch (activeEvent) {
            case UserActivity: 
                m_LastNewState = On;
                break;
            case Timeout: {
                switch (TimeoutItem) {
                    case SuspendTimeout:
                        m_LastNewState = Suspend;
                        break;
                    default:
                        ASSERT(FALSE);
                }
                break;
            }
        }
        return activeEvent;
    }
    virtual DWORD  GetState() { return (DWORD)SystemIdle; };
    virtual LPCTSTR GetStateString() { return STRING_SYSTEMIDLE; };
    virtual DWORD StateValidateRegistry(DWORD dwDState , DWORD dwFlag ) {
        return PowerState::StateValidateRegistry(2, 0 );
    }
    
};
class PowerStateSuspended : public PowerState {
public:
    PowerStateSuspended (PowerStateManager *pPwrStateMgr, PowerState * pNextPowerState = NULL )
    :   PowerState(pPwrStateMgr,pNextPowerState)
    {; };
    virtual void EnterState() {
        PmSetSystemPowerState_I ( GetStateString() , 0 , 0, TRUE);
        // Because it wakeup by wakeup source So it automatic enter Resuming State.
        m_LastNewState = Resuming; // Point to Resuming.
        
    }
    virtual PLATFORM_ACTIVITY_EVENT  WaitForEvent(DWORD dwTimeouts = INFINITE , DWORD dwNumOfExternEvent = 0, HANDLE * pExternEventArray = NULL) {
        // Suspend is no wait
        return NoActivity;
    }
    virtual DWORD  GetState() { return (DWORD)Suspend; };
    virtual LPCTSTR GetStateString()  { return STRING_SUSPEND; };
    virtual DWORD StateValidateRegistry(DWORD  , DWORD  ) {
        return PowerState::StateValidateRegistry(3, POWER_STATE_SUSPEND );
    }
    virtual BOOL AppsCanRequestState() { return TRUE; }
};


class PowerStateResuming : public PowerState {
public:
    PowerStateResuming  (PowerStateManager *pPwrStateMgr, PowerState * pNextPowerState = NULL )
    :   PowerState(pPwrStateMgr,pNextPowerState)
    {; };
    virtual void EnterState() {
        PowerState::EnterState();
        ((PowerStateManager *)m_pPwrStateMgr)->ReInitTimeOuts();
        // Initial Timeout to Active First.
        if (m_pPwrStateMgr->GetUserActivityTimer()!=NULL)
            m_dwEventArray [ PM_USER_ACTIVITY_EVENT ] = m_pPwrStateMgr->GetUserActivityTimer()->hevActive;
        if (m_pPwrStateMgr->GetSystemActivityTimer()!=NULL)
            m_dwEventArray [ PM_SYSTEM_ACTIVITY_EVENT ] = m_pPwrStateMgr->GetSystemActivityTimer()->hevActive;
        m_pPwrStateMgr->ResetSystemIdleTimeTimeout(TRUE); // This will at least do not folling into suspend directly.
    }
    virtual PLATFORM_ACTIVITY_EVENT  WaitForEvent(DWORD dwTimeouts = INFINITE , DWORD dwNumOfExternEvent = 0, HANDLE * pExternEventArray = NULL)  {
        PLATFORM_ACTIVITY_EVENT activeEvent = PowerState::WaitForEvent(0 ,dwNumOfExternEvent, pExternEventArray) ;
        switch (activeEvent)
        {
            case UserActivity:
            case SystemActivity:
            case Timeout:
                m_LastNewState = On;
                break;
        }
        return activeEvent;
    }
    virtual DWORD  GetState() { return (DWORD)Resuming; };
    virtual LPCTSTR GetStateString() { return STRING_RESUMING; };
    virtual DWORD StateValidateRegistry(DWORD , DWORD  ) {
        return PowerState::StateValidateRegistry(2, 0 );
    }
};

class PowerStateColdReboot : public PowerState {
public:
    PowerStateColdReboot (PowerStateManager *pPwrStateMgr, PowerState * pNextPowerState = NULL )
    :   PowerState(pPwrStateMgr,pNextPowerState)
    {; };
    virtual void EnterState() {
        PmSetSystemPowerState_I ( GetStateString() , 0 , 0, TRUE);
        // Because it wakeup by wakeup source So it automatic enter Resuming State.
    }
    virtual PLATFORM_ACTIVITY_EVENT  WaitForEvent(DWORD dwTimeouts = INFINITE , DWORD dwNumOfExternEvent = 0, HANDLE * pExternEventArray = NULL) {
        // Suspend is no wait
        return NoActivity;
    }
    virtual DWORD  GetState() { return (DWORD)ColdReboot; };
    virtual DWORD  GetLastNewState() {  return (DWORD)ColdReboot;; };
    virtual LPCTSTR GetStateString()  { return STRING_ColdReboot; };
    virtual DWORD StateValidateRegistry(DWORD  , DWORD  ) {
        return PowerState::StateValidateRegistry(4, POWER_STATE_RESET );
    }
    virtual BOOL AppsCanRequestState() { return TRUE; }
};

class PowerStateReboot : public PowerState {
public:
    PowerStateReboot (PowerStateManager *pPwrStateMgr, PowerState * pNextPowerState = NULL )
    :   PowerState(pPwrStateMgr,pNextPowerState)
    {; };
    virtual void EnterState() {
        PmSetSystemPowerState_I ( GetStateString() , 0 , 0, TRUE);
        // Because it wakeup by wakeup source So it automatic enter Resuming State.
    }
    virtual PLATFORM_ACTIVITY_EVENT  WaitForEvent(DWORD dwTimeouts = INFINITE , DWORD dwNumOfExternEvent = 0, HANDLE * pExternEventArray = NULL) {
        // Suspend is no wait
        return NoActivity;
    }
    virtual DWORD  GetState() { return (DWORD)Reboot; };
    virtual DWORD  GetLastNewState() {  return (DWORD)Reboot;; };
    virtual LPCTSTR GetStateString()  { return STRING_Reboot; };
    virtual DWORD StateValidateRegistry(DWORD  , DWORD  ) {
        return PowerState::StateValidateRegistry(4, POWER_STATE_RESET );
    }
    virtual BOOL AppsCanRequestState() { return TRUE; }
};



BOOL PowerStateManager::CreatePowerStateList()
{
    if (m_pPowerStateList == NULL ) {
        m_pPowerStateList = new PowerStateOn( this, new PowerStateUserIdle( this, new PowerStateSystemIdle(this,  
            new PowerStateResuming(this, new PowerStateSuspended(this, new PowerStateReboot(this,new PowerStateColdReboot(this)))))));
    }
    if (m_pPowerStateList != NULL) {
        PowerState * pCurState = m_pPowerStateList;
        while (pCurState) {
            if (!pCurState->Init()) {
                ASSERT(FALSE);
                return FALSE;
            }
            pCurState = pCurState->GetNextPowerState();
        }
        return TRUE;
    }
    else
        return FALSE;
}

DefaultPowerStateManager * CreateDefaultPowerManager(PVOID pParm)
{
    return (new PowerStateManager(pParm));
}