/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Device state (touch mode, screen orientation) handler

 *

*/

#include "tsdevicestate.h"

#include "tsapplogging.h"

#include <AknUtils.h>

#include <hwrmdomainpskeys.h>

// -----------------------------------------------------------------------------

// CTsDeviceState::NewL

// -----------------------------------------------------------------------------

//

CTsDeviceState* CTsDeviceState::NewL()

    {

    CTsDeviceState* self = new ( ELeave ) CTsDeviceState;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CTsDeviceState::CTsDeviceState

// -----------------------------------------------------------------------------

//

CTsDeviceState::CTsDeviceState()

    {

    }

// -----------------------------------------------------------------------------

// CTsDeviceState::ConstructL

// -----------------------------------------------------------------------------

//

void CTsDeviceState::ConstructL()

    {

    iFlipStatusObserver = new ( ELeave ) CTsPropertyListener(KPSUidHWRM,	

		KHWRMFlipStatus, *this);

    // check if touch is enabled or not

    CheckTouchState();

    // are we in portrait or landscape

    CheckOrientation();

    // checks the qwerty input mode.

    CheckDeviceType();

    }

// -----------------------------------------------------------------------------

// CTsDeviceState::~CTsDeviceState

// -----------------------------------------------------------------------------

//

CTsDeviceState::~CTsDeviceState()

    {

    iObservers.Close();

    delete iFlipStatusObserver;

    }

// --------------------------------------------------------------------------

// CTsDeviceState::HandleResourceChange

// --------------------------------------------------------------------------

//

void CTsDeviceState::HandleResourceChange( TInt aType )

    {

    TSLOG_CONTEXT( HandleResourceChange, TSLOG_LOCAL );

    TSLOG2_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 )

                {

                TSLOG0( TSLOG_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 )

                {

                TSLOG0( TSLOG_INFO, "skin change" );

                NotifyObservers( MTsDeviceStateObserver::ESkin );

                }

            --iResChangeActiveCount;

            }

        }

    TSLOG_OUT();

    }

// --------------------------------------------------------------------------

// CTsDeviceState::PropertyChanged

// --------------------------------------------------------------------------

//

void CTsDeviceState::PropertyChanged(TUid aCategory, TUint aKey)

    {

    TSLOG_CONTEXT( PropertyChanged, TSLOG_LOCAL );

    TSLOG2_IN( "aKey = %d aNewValue = %d", aCategory, aKey );

    CheckDeviceType();

    TSLOG_OUT();

    }

// --------------------------------------------------------------------------

// CTsDeviceState::CheckTouchState

// --------------------------------------------------------------------------

//

void CTsDeviceState::CheckTouchState()

    {

    TSLOG_CONTEXT( CheckTouchState, TSLOG_LOCAL );

    TSLOG_IN();

    TTouchState oldValue = iTouchState;

    iTouchState = AknLayoutUtils::PenEnabled() ? ETouchEnabled : ETouchDisabled;

    if ( iTouchState != oldValue )

        {

        NotifyObservers( MTsDeviceStateObserver::ETouchState );

        }

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

    }

// --------------------------------------------------------------------------

// CTsDeviceState::CheckOrientation

// --------------------------------------------------------------------------

//

void CTsDeviceState::CheckOrientation()

    {

    TSLOG_CONTEXT( CheckOrientation, TSLOG_LOCAL );

    TSLOG_IN();

    TRect rect;

    AknLayoutUtils::LayoutMetricsRect ( AknLayoutUtils::EScreen, rect );

    TOrientation oldValue = iOrientation;

    iOrientation = rect.Width() > rect.Height() ? ELandscape : EPortrait;

    if ( iOrientation != oldValue )

        {

        NotifyObservers( MTsDeviceStateObserver::EOrientation );

        }

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

    }

// --------------------------------------------------------------------------

// CTsDeviceState::DeviceType

// --------------------------------------------------------------------------

//

void CTsDeviceState::CheckDeviceType()

    {

    TSLOG_CONTEXT( CheckQwerty, TSLOG_LOCAL );

    TSLOG_IN();

    TInt oldDeviceType = iDeviceType;

    TInt value( 0 );

    if( RProperty::Get( KPSUidHWRM, KHWRMFlipStatus, value ) == KErrNone )

    	{

    	iDeviceType = (value == EPSHWRMFlipOpen ? EHybrid : EFullTouch);

    	}

    if( iDeviceType != oldDeviceType )

        {

        NotifyObservers( MTsDeviceStateObserver::EDeviceType);

        }

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

    }

// --------------------------------------------------------------------------

// CTsDeviceState::TouchState

// --------------------------------------------------------------------------

//

CTsDeviceState::TTouchState CTsDeviceState::TouchState() const

    {

    return iTouchState;

    }

// --------------------------------------------------------------------------

// CTsDeviceState::Orientation

// --------------------------------------------------------------------------

//

CTsDeviceState::TOrientation CTsDeviceState::Orientation() const

    {

    return iOrientation;

    }

// --------------------------------------------------------------------------

// CTsDeviceState::Qwerty

// --------------------------------------------------------------------------

//

CTsDeviceState::TDeviceType CTsDeviceState::DeviceType() const

    {

    return iDeviceType;

    }

// --------------------------------------------------------------------------

// CTsDeviceState::ObserverIdentity

// --------------------------------------------------------------------------

//

TBool CTsDeviceState::ObserverIdentity( const SObserver& aA,

        const SObserver& aB )

    {

    return aA.iObserver == aB.iObserver;

    }

// --------------------------------------------------------------------------

// CTsDeviceState::AddDeviceStateObserverL

// --------------------------------------------------------------------------

//

void CTsDeviceState::AddObserverL( MTsDeviceStateObserver& aObserver,

        TInt aMask )

    {

    iObservers.AppendL( SObserver( aMask, &aObserver ) );

    }

// --------------------------------------------------------------------------

// CTsDeviceState::RemoveObserver

// --------------------------------------------------------------------------

//

void CTsDeviceState::RemoveObserver( MTsDeviceStateObserver& aObserver )

    {

    for ( ; ; )

        {

        TInt pos = iObservers.Find( SObserver( MTsDeviceStateObserver::EAny,

            &aObserver ), ObserverIdentity );

        if ( pos >= 0 )

            {

            iObservers.Remove( pos );

            }

        else

            {

            break;

            }

        }

    }

// --------------------------------------------------------------------------

// CTsDeviceState::NotifyObservers

// --------------------------------------------------------------------------

//

void CTsDeviceState::NotifyObservers(

        MTsDeviceStateObserver::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