/*
 * ============================================================================
 *  Name        : hgteleportdevicestate.cpp
 *  Part of     : Hg Teleport
 *  Description : Device state (touch mode, screen orientation) handler
 *  Version     : %version: sa1spcx1#14 %
 *
 *  Copyright © 2008 Nokia.  All rights reserved.
 *  This material, including documentation and any related computer
 *  programs, is protected by copyright controlled by Nokia.  All
 *  rights are reserved.  Copying, including reproducing, storing,
 *  adapting or translating, any or all of this material requires the
 *  prior written consent of Nokia.  This material also contains
 *  confidential information which may not be disclosed to others
 *  without the prior written consent of Nokia.
 * ============================================================================
 * Template version: 4.2
 */

#include "hgteleportdevicestate.h"
#include <AknUtils.h>
#include <hwrmdomainpskeys.h>

#include "hgteleportapplogging.h"


// -----------------------------------------------------------------------------
// CHgTeleportDeviceState::NewL
// -----------------------------------------------------------------------------
//
CHgTeleportDeviceState* CHgTeleportDeviceState::NewL()
    {
    CHgTeleportDeviceState* self = new ( ELeave ) CHgTeleportDeviceState;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CHgTeleportDeviceState::CHgTeleportDeviceState
// -----------------------------------------------------------------------------
//
CHgTeleportDeviceState::CHgTeleportDeviceState()
    {
    }

// -----------------------------------------------------------------------------
// CHgTeleportDeviceState::ConstructL
// -----------------------------------------------------------------------------
//
void CHgTeleportDeviceState::ConstructL()
    {
    iFlipStatusObserver = new ( ELeave ) CHgPropertyListener(KPSUidHWRM,	
		KHWRMFlipStatus, *this);
    // check if touch is enabled or not
    CheckTouchState();
    // are we in portrait or landscape
    CheckOrientation();
    // checks the qwerty input mode.
    CheckDeviceType();
    }

// -----------------------------------------------------------------------------
// CHgTeleportDeviceState::~CHgTeleportDeviceState
// -----------------------------------------------------------------------------
//
CHgTeleportDeviceState::~CHgTeleportDeviceState()
    {
    iObservers.Close();
    delete iFlipStatusObserver;
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::HandleResourceChange
// --------------------------------------------------------------------------
//
void CHgTeleportDeviceState::HandleResourceChange( TInt aType )
    {
    HGLOG_CONTEXT( HandleResourceChange, HGLOG_LOCAL );
    HGLOG2_IN( "aType = %d (active count = %d)", aType, iResChangeActiveCount );

    // increase function entrance count
    ++iResChangeActiveCount;
    // if we are still in a previous call then do nothing else
    if ( iResChangeActiveCount == 1 )
        {
        // the active count may increase during execution of the body of the loop
        // (if some observers have active scheduler waits, for example)
        while ( iResChangeActiveCount > 0 )
            {
            if ( aType == KEikDynamicLayoutVariantSwitch )
                {
                HGLOG0( HGLOG_INFO, "dyn layout var switch" );
                // This might be a screen orientation or touch-nontouch switch,
                // so let's check the situation and notify observers if needed.
                CheckTouchState();
                CheckOrientation();
                }
            else if ( aType == KAknsMessageSkinChange )
                {
                HGLOG0( HGLOG_INFO, "skin change" );
                NotifyObservers( MHgDeviceStateObserver::ESkin );
                }
            --iResChangeActiveCount;
            }
        }
        
    HGLOG_OUT();
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::PropertyChanged
// --------------------------------------------------------------------------
//
void CHgTeleportDeviceState::PropertyChanged(TUid aCategory, TUint aKey)
    {
    HGLOG_CONTEXT( PropertyChanged, HGLOG_LOCAL );
    HGLOG2_IN( "aKey = %d aNewValue = %d", aCategory, aKey );
    CheckDeviceType();
    HGLOG_OUT();
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::CheckTouchState
// --------------------------------------------------------------------------
//
void CHgTeleportDeviceState::CheckTouchState()
    {
    HGLOG_CONTEXT( CheckTouchState, HGLOG_LOCAL );
    HGLOG_IN();

    TTouchState oldValue = iTouchState;
    iTouchState = AknLayoutUtils::PenEnabled() ? ETouchEnabled : ETouchDisabled;
    if ( iTouchState != oldValue )
        {
        NotifyObservers( MHgDeviceStateObserver::ETouchState );
        }

    HGLOG1_OUT( "new value for iTouchState: %d", iTouchState );
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::CheckOrientation
// --------------------------------------------------------------------------
//
void CHgTeleportDeviceState::CheckOrientation()
    {
    HGLOG_CONTEXT( CheckOrientation, HGLOG_LOCAL );
    HGLOG_IN();

    TRect rect;
    AknLayoutUtils::LayoutMetricsRect ( AknLayoutUtils::EScreen, rect );
    TOrientation oldValue = iOrientation;
    iOrientation = rect.Width() > rect.Height() ? ELandscape : EPortrait;
    if ( iOrientation != oldValue )
        {
        NotifyObservers( MHgDeviceStateObserver::EOrientation );
        }

    HGLOG1_OUT( "new value for iOrientation: %d", iOrientation );
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::DeviceType
// --------------------------------------------------------------------------
//
void CHgTeleportDeviceState::CheckDeviceType()
    {
    HGLOG_CONTEXT( CheckQwerty, HGLOG_LOCAL );
    HGLOG_IN();

    TInt oldDeviceType = iDeviceType;
    TInt value( 0 );
    if( RProperty::Get( KPSUidHWRM, KHWRMFlipStatus, value ) == KErrNone )
    	{
    	iDeviceType = (value == EPSHWRMFlipOpen ? EHybrid : EFullTouch);
    	}
    
    if( iDeviceType != oldDeviceType )
        {
        NotifyObservers( MHgDeviceStateObserver::EDeviceType);
        }

    HGLOG1_OUT( "new value for iDeviceType: %d", iDeviceType );
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::TouchState
// --------------------------------------------------------------------------
//
CHgTeleportDeviceState::TTouchState CHgTeleportDeviceState::TouchState() const
    {
    return iTouchState;
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::Orientation
// --------------------------------------------------------------------------
//
CHgTeleportDeviceState::TOrientation CHgTeleportDeviceState::Orientation() const
    {
    return iOrientation;
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::Qwerty
// --------------------------------------------------------------------------
//
CHgTeleportDeviceState::TDeviceType CHgTeleportDeviceState::DeviceType() const
    {
    return iDeviceType;
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::ObserverIdentity
// --------------------------------------------------------------------------
//
TBool CHgTeleportDeviceState::ObserverIdentity( const SObserver& aA,
        const SObserver& aB )
    {
    return aA.iObserver == aB.iObserver;
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::AddDeviceStateObserverL
// --------------------------------------------------------------------------
//
void CHgTeleportDeviceState::AddObserverL( MHgDeviceStateObserver& aObserver,
        TInt aMask )
    {
    iObservers.AppendL( SObserver( aMask, &aObserver ) );
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::RemoveObserver
// --------------------------------------------------------------------------
//
void CHgTeleportDeviceState::RemoveObserver( MHgDeviceStateObserver& aObserver )
    {
    for ( ; ; )
        {
        TInt pos = iObservers.Find( SObserver( MHgDeviceStateObserver::EAny,
            &aObserver ), ObserverIdentity );
        if ( pos >= 0 )
            {
            iObservers.Remove( pos );
            }
        else
            {
            break;
            }
        }
    }

// --------------------------------------------------------------------------
// CHgTeleportDeviceState::NotifyObservers
// --------------------------------------------------------------------------
//
void CHgTeleportDeviceState::NotifyObservers(
        MHgDeviceStateObserver::TChangeType aType )
    {
    for ( TInt i = 0, ie = iObservers.Count(); i != ie; ++i )
        {
        const SObserver& obs( iObservers[i] );
        if ( obs.iMask & aType )
            {
            obs.iObserver->HandleDeviceStateChanged( aType );
            }
        }
    }


// end of file