/*
* Copyright (c) 2009-2009 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:   CDisplayServiceUILayout class implementation.
*
*/


// SYSTEM INCLUDES
#include <cfcontextobject.h>
#include <cfcontextinterface.h>
#include <apgwgnam.h>
#include <coedef.h>

// USER INCLUDES
#include "displayserviceuilayout.h"
#include "displaysourcecontextdef.h"
#include "displaysourcepluginpanic.h"
#include "trace.h"

// ======================== LOCAL FUNCTIONS ========================

#ifdef _DEBUG

/** Rotation constants */
_LIT( KGraphicsOrientationNormal, "Normal" );
_LIT( KGraphicsOrientationRotated90, "Rotated 90" );
_LIT( KGraphicsOrientationRotated180, "Rotated 180" );
_LIT( KGraphicsOrientationRotated270, "Rotated 270" );

LOCAL_C const TDesC& RotationAsDesC( TInt aRotation )
    {
    switch( aRotation )
        {
        case CFbsBitGc::EGraphicsOrientationNormal:
            {
            return KGraphicsOrientationNormal;
            }
        case CFbsBitGc::EGraphicsOrientationRotated90:
            {
            return KGraphicsOrientationRotated90;
            }
        case CFbsBitGc::EGraphicsOrientationRotated180:
            {
            return KGraphicsOrientationRotated180;
            }
        case CFbsBitGc::EGraphicsOrientationRotated270:
            {
            return KGraphicsOrientationRotated270;
            }
        default:
            {
            return KNullDesC;
            }
        }
    }

#endif

// ======================== MEMBER FUNCTIONS ========================

// ======================== CDisplayServiceUILayout ========================

// ---------------------------------------------------------------------------
// C++ constructor.
// ---------------------------------------------------------------------------
//
CDisplayServiceUILayout::CDisplayServiceUILayout( MCFContextInterface& aCF ):
    CDisplayServiceBase( CDisplayServiceBase::EDisplayUILayout, aCF ),
    iCurrentLayout( EUILayoutValueUnknown )
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor.
// ---------------------------------------------------------------------------
//
void CDisplayServiceUILayout::ConstructL()
    {
    FUNC_LOG;
    
    // Call base class
    CDisplayServiceBase::ConstructL();
    
    // Configure context source and type
    iContext->SetSourceL( KDisplaySource );
    iContext->SetTypeL( KDisplayUILayoutType );
    
    // Define context:
    // Device: Display.UI.Layout
    TInt err = iCF.DefineContext(
        KDisplaySource, KDisplayUILayoutType, KDisplayUILayoutSec );
    User::LeaveIfError( err );
    
    // Define context:
    // Device: Display.UI.Rotation
    err = iCF.DefineContext(
        KDisplaySource, KDisplayUIRotationType, KDisplayUIRotationSec );
    User::LeaveIfError( err );
    
    // Create window server event handler
    iWsEventHandler = CWsEventHandler::NewL( *this );
    }

// ---------------------------------------------------------------------------
// Symbian two phased constructor.
// ---------------------------------------------------------------------------
//
CDisplayServiceUILayout* CDisplayServiceUILayout::NewL(
    MCFContextInterface& aCF )
    {
    FUNC_LOG;

    CDisplayServiceUILayout* self = CDisplayServiceUILayout::NewLC( aCF );
    CleanupStack::Pop( self );
    
    return self;
    }

// ---------------------------------------------------------------------------
// Symbian two phased constructor.
// Leaves pointer in the cleanup stack.
// ---------------------------------------------------------------------------
//
CDisplayServiceUILayout* CDisplayServiceUILayout::NewLC(
    MCFContextInterface& aCF )
    {
    FUNC_LOG;

    CDisplayServiceUILayout* self =
        new ( ELeave ) CDisplayServiceUILayout( aCF );
    CleanupStack::PushL( self );
    self->ConstructL();
    
    return self;
    }

// ---------------------------------------------------------------------------
// C++ destructor.
// ---------------------------------------------------------------------------
//
CDisplayServiceUILayout::~CDisplayServiceUILayout()
    {
    FUNC_LOG;

    delete iWsEventHandler;
    }

//------------------------------------------------------------------------------
// CDisplayServiceUILayout::StartL
//------------------------------------------------------------------------------
//
void CDisplayServiceUILayout::StartL()
    {
    FUNC_LOG;

    // Get initial values
    TDisplayUILayoutValues layout;
    CFbsBitGc::TGraphicsOrientation rotation;
    iWsEventHandler->ResolveUILayout( layout, rotation );

    // Publish initial UI layout context value
    PublishContextL( layout, ETrue );
    
    // Publish initial UI rotation context value
    PublishContextL( rotation, ETrue );
    
    //  Start listening window server events
    iWsEventHandler->IssueRequest();
    }

//------------------------------------------------------------------------------
// CDisplayServiceUILayout::Stop
//------------------------------------------------------------------------------
//
void CDisplayServiceUILayout::Stop()
    {
    FUNC_LOG;
    
    iWsEventHandler->Cancel();
    }

//------------------------------------------------------------------------------
// CDisplayServiceUILayout::HandleWsEventL
//------------------------------------------------------------------------------
//
void CDisplayServiceUILayout::HandleWsEventL( const TWsEvent &aEvent )
    {
    FUNC_LOG;
    
    INFO_1( "New window server event received: Event: [%d]", aEvent.Type() );

    // New window server event received, solve the event type
    switch( aEvent.Type() )
        {
        case EEventWindowGroupsChanged:
        case EEventScreenDeviceChanged:
            {
            TDisplayUILayoutValues layout = EUILayoutValueUnknown;
            CFbsBitGc::TGraphicsOrientation rotation =
                CFbsBitGc::EGraphicsOrientationNormal;
            iWsEventHandler->ResolveUILayout( layout, rotation );
            PublishContextL( layout );
            PublishContextL( rotation );
            break;
            }
        default:
            {
            // Nothing to do here
            break;
            }
        }
    }

//------------------------------------------------------------------------------
// CDisplayServiceUILayout::HandleWsEventErrorL
//------------------------------------------------------------------------------
//
void CDisplayServiceUILayout::HandleWsEventErrorL( TInt aError )
    {
    FUNC_LOG;
    
    // Remove warnings in urel builds
    (void)aError;
    
    ERROR( aError,
        "Window server event error occured. UI layout set to 'unknown" );

    // Error occured and it is impossible to know the current UI layout.
    // Publish context:
    // Device: Display.UI.Layout: Unknown
    iContext->SetValueL( TPtrC(
        KDisplayUILayoutValues[EUILayoutValueUnknown] ) );
    iCF.PublishContext( *iContext, iThread );
    }

//------------------------------------------------------------------------------
// CDisplayServiceUILayout::PublishContextL
//------------------------------------------------------------------------------
//
void CDisplayServiceUILayout::PublishContextL( TDisplayUILayoutValues aLayout,
    TBool aForce )
    {
    FUNC_LOG;

    if( aLayout != iCurrentLayout || aForce )
        {
        iContext->SetTypeL( KDisplayUILayoutType );
        iContext->SetValueL( TPtrC( KDisplayUILayoutValues[aLayout] ) );
        iCF.PublishContext( *iContext, iThread );
        iCurrentLayout = aLayout;
        }
    }

//------------------------------------------------------------------------------
// CDisplayServiceUILayout::PublishContextL
//------------------------------------------------------------------------------
//
void CDisplayServiceUILayout::PublishContextL(
    CFbsBitGc::TGraphicsOrientation aRotation,
    TBool aForce )
    {
    FUNC_LOG;

    if( aRotation != iCurrentRotation || aForce )
        {
        iContext->SetTypeL( KDisplayUIRotationType );
        iContext->SetValueL( TPtrC( KDisplayUIRotationValues[aRotation] ) );
        iCF.PublishContext( *iContext, iThread );
        iCurrentRotation = aRotation;
        }
    }

// ======================== CWsEventHandler ========================

// ---------------------------------------------------------------------------
// C++ constructor.
// ---------------------------------------------------------------------------
//
CWsEventHandler::CWsEventHandler( MWsEventObserver& aObserver ):
    CActive( CActive::EPriorityStandard ),
    iObserver( aObserver )
    {
    FUNC_LOG;
    
    CActiveScheduler::Add( this );
    }

// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor.
// ---------------------------------------------------------------------------
//
void CWsEventHandler::ConstructL()
    {
    FUNC_LOG;
    
    // Connect to window server server
    User::LeaveIfError( iWsSession.Connect() );
    
    // Construct window group
    iWindowGroup = new( ELeave ) RWindowGroup( iWsSession );
    User::LeaveIfError( iWindowGroup->Construct( (TUint32)this, EFalse ) );
    User::LeaveIfError( iWindowGroup->EnableScreenChangeEvents() );
    User::LeaveIfError( iWindowGroup->EnableGroupChangeEvents() );
    iWindowGroup->SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront );
    iWindowGroup->EnableReceiptOfFocus( EFalse );
    
    // Hide the invisible window from the task manager
    iWindowGroupName = CApaWindowGroupName::NewL( iWsSession );
    iWindowGroupName->SetHidden( ETrue );
    iWindowGroupName->SetWindowGroupName( *iWindowGroup );

    // Construct screen device
    iWsScreenDevice = new( ELeave ) CWsScreenDevice( iWsSession );
    User::LeaveIfError( iWsScreenDevice->Construct() );
    }

// ---------------------------------------------------------------------------
// Symbian two phased constructor.
// ---------------------------------------------------------------------------
//
CWsEventHandler* CWsEventHandler::NewL( MWsEventObserver& aObserver )
    {
    FUNC_LOG;

    CWsEventHandler* self = CWsEventHandler::NewLC( aObserver );
    CleanupStack::Pop( self );
    
    return self;
    }

// ---------------------------------------------------------------------------
// Symbian two phased constructor.
// Leaves pointer in the cleanup stack.
// ---------------------------------------------------------------------------
//
CWsEventHandler* CWsEventHandler::NewLC( MWsEventObserver& aObserver )
    {
    FUNC_LOG;

    CWsEventHandler* self = new ( ELeave ) CWsEventHandler( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    
    return self;
    }

// ---------------------------------------------------------------------------
// C++ destructor.
// ---------------------------------------------------------------------------
//
CWsEventHandler::~CWsEventHandler()
    {
    FUNC_LOG;
    
    Cancel();
    
    // Cleanup screen device
    delete iWsScreenDevice;
    
    // Cleanup window group name
    delete iWindowGroupName;
       
    // Cleanup window group
    if( iWindowGroup )
        {
        iWindowGroup->DisableGroupChangeEvents();
        iWindowGroup->DisableScreenChangeEvents();
        iWindowGroup->Close();
        delete iWindowGroup;
        }
    
    // Cleanup window server session
    iWsSession.Close();
    }

//------------------------------------------------------------------------------
// CWsEventHandler::IssueRequest
//------------------------------------------------------------------------------
//
void CWsEventHandler::IssueRequest()
    {
    FUNC_LOG;

    __ASSERT_DEBUG( !IsActive(), Panic( ERequestAlreadyIssued ) );
    
    // Request events from window server
    iWsSession.EventReady( &iStatus );
    SetActive();
    }

//------------------------------------------------------------------------------
// CWsEventHandler::ResolveUILayout
//------------------------------------------------------------------------------
//
void CWsEventHandler::ResolveUILayout( TDisplayUILayoutValues& aLayout,
    CFbsBitGc::TGraphicsOrientation& aRotation ) const
    {
    FUNC_LOG;
    
    // Resolve the current UI layout from screen dimensions
    TInt mode = iWsScreenDevice->CurrentScreenMode();
    INFO_1( "Current screen mode: [%d]", mode );
    
    TPixelsAndRotation pixelsAndRotation;
    iWsScreenDevice->GetScreenModeSizeAndRotation( mode, pixelsAndRotation );
    INFO_3( "Current screen mode size and rotation: Size: [W=%d, H=%d], Rotation: [%S]",
        pixelsAndRotation.iPixelSize.iWidth,
        pixelsAndRotation.iPixelSize.iHeight,
        &RotationAsDesC( pixelsAndRotation.iRotation ) );
    
    // Resolve current UI rotation
    aRotation = pixelsAndRotation.iRotation;
    
    // Resovle current UI layout mode
    TSize screenSize( pixelsAndRotation.iPixelSize );
    if( screenSize.iWidth < screenSize.iHeight )
        {
        // Assuming portrait layout
        INFO( "Current UI layout resolved to be in 'Portrait' mode" );
        aLayout = EUILayoutValuePortrait;
        }
    else if( screenSize.iWidth > screenSize.iHeight )
        {
        // Assuming landscape layout
        INFO( "Current UI layout resolved to be in 'Landscape' mode" );
        aLayout = EUILayoutValueLandscape;
        }
    else
        {
        // Need to check the rotation even though this might not be correct
        // if wsini.ini has not been configured properly.
        CFbsBitGc::TGraphicsOrientation orientation(
            pixelsAndRotation.iRotation );
        if( orientation == CFbsBitGc::EGraphicsOrientationNormal ||
            orientation == CFbsBitGc::EGraphicsOrientationRotated180 )
            {
            // Assuming portrait layout
            INFO( "Current UI layout resolved to be in 'Portrait' mode" );
            aLayout = EUILayoutValuePortrait;
            }
        else
            {
            // Assuming landscape layout
            INFO( "Current UI layout resolved to be in 'Landscape' mode" );
            aLayout = EUILayoutValueLandscape;
            }
        }
    }

//------------------------------------------------------------------------------
// CWsEventHandler::RunL
//------------------------------------------------------------------------------
//
void CWsEventHandler::RunL()
    {
    FUNC_LOG;
    
    TInt err = iStatus.Int();
    if( err == KErrNone )
        {
        // No errors occured, fetch event
        TWsEvent wsEvent;
        iWsSession.GetEvent( wsEvent );
        
        // Continue listening
        IssueRequest();
        
        // Forward event to observer
        iObserver.HandleWsEventL( wsEvent );
        }
    else
        {
        // Continue listening
        IssueRequest();
        
        // Forward error to observer
        iObserver.HandleWsEventErrorL( err );
        }    
    }

//------------------------------------------------------------------------------
// CWsEventHandler::DoCancel
//------------------------------------------------------------------------------
//
void CWsEventHandler::DoCancel()
    {
    FUNC_LOG;
    
    // Cancel event ready from window server
    iWsSession.EventReadyCancel();
    }

//------------------------------------------------------------------------------
// CWsEventHandler::RunError
//------------------------------------------------------------------------------
//
TInt CWsEventHandler::RunError( TInt /*aError*/ )
    {
    FUNC_LOG;

    // Issue a new request, other error handling is not performed since the
    // problem has occured in the observer code
    IssueRequest();
    
    return KErrNone;
    }

// End of file